[Sommaire] [Imprimer]

   1  <?php
   2  // $Id: member.php 961 2007-08-07 16:17:12Z malanciault $

   3  //  ------------------------------------------------------------------------ //

   4  //                XOOPS - PHP Content Management System                      //

   5  //                    Copyright (c) 2000 XOOPS.org                           //

   6  //                       <http://www.xoops.org/>                             //

   7  //  ------------------------------------------------------------------------ //

   8  //  This program is free software; you can redistribute it and/or modify     //

   9  //  it under the terms of the GNU General Public License as published by     //

  10  //  the Free Software Foundation; either version 2 of the License, or        //

  11  //  (at your option) any later version.                                      //

  12  //                                                                           //

  13  //  You may not change or alter any portion of this comment or credits       //

  14  //  of supporting developers from this source code or any supporting         //

  15  //  source code which is considered copyrighted (c) material of the          //

  16  //  original comment or credit authors.                                      //

  17  //                                                                           //

  18  //  This program is distributed in the hope that it will be useful,          //

  19  //  but WITHOUT ANY WARRANTY; without even the implied warranty of           //

  20  //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            //

  21  //  GNU General Public License for more details.                             //

  22  //                                                                           //

  23  //  You should have received a copy of the GNU General Public License        //

  24  //  along with this program; if not, write to the Free Software              //

  25  //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA //

  26  //  ------------------------------------------------------------------------ //

  27  // Author: Kazumi Ono (AKA onokazu)                                          //

  28  // URL: http://www.myweb.ne.jp/, http://www.xoops.org/, http://jp.xoops.org/ //

  29  // Project: The XOOPS Project                                                //

  30  // ------------------------------------------------------------------------- //

  31  
  32  if (!defined('XOOPS_ROOT_PATH')) {
  33      exit();
  34  }
  35  require_once XOOPS_ROOT_PATH.'/kernel/user.php';
  36  require_once XOOPS_ROOT_PATH.'/kernel/group.php';
  37  
  38  /**

  39  * XOOPS member handler class.

  40  * This class provides simple interface (a facade class) for handling groups/users/

  41  * membership data.

  42  *

  43  *

  44  * @author  Kazumi Ono <onokazu@xoops.org>

  45  * @copyright copyright (c) 2000-2003 XOOPS.org

  46  * @package kernel

  47  */
  48  
  49  class XoopsMemberHandler{
  50  
  51      /**#@+

  52      * holds reference to group handler(DAO) class

  53      * @access private

  54      */
  55      var $_gHandler;
  56  
  57      /**

  58      * holds reference to user handler(DAO) class

  59      */
  60      var $_uHandler;
  61  
  62      /**

  63      * holds reference to membership handler(DAO) class

  64      */
  65      var $_mHandler;
  66  
  67      /**

  68      * holds temporary user objects

  69      */
  70      var $_members = array();
  71      /**#@-*/

  72  
  73      /**

  74       * constructor

  75       *

  76       */
  77      function XoopsMemberHandler(&$db)
  78      {
  79          $this->_gHandler = new XoopsGroupHandler($db);
  80          $this->_uHandler = new XoopsUserHandler($db);
  81          $this->_mHandler = new XoopsMembershipHandler($db);
  82      }
  83  
  84      /**

  85       * create a new group

  86       *

  87       * @return object XoopsGroup reference to the new group

  88       */
  89      function &createGroup()
  90      {
  91          $inst =& $this->_gHandler->create();
  92          return $inst;
  93      }
  94  
  95      /**

  96       * create a new user

  97       *

  98       * @return object XoopsUser reference to the new user

  99       */
 100      function &createUser()
 101      {
 102          $inst =& $this->_uHandler->create();
 103          return $inst;
 104      }
 105  
 106      /**

 107       * retrieve a group

 108       *

 109       * @param int $id ID for the group

 110       * @return object XoopsGroup reference to the group

 111       */
 112      function getGroup($id)
 113      {
 114          return $this->_gHandler->get($id);
 115      }
 116  
 117      /**

 118       * retrieve a user

 119       *

 120       * @param int $id ID for the user

 121       * @return object XoopsUser reference to the user

 122       */
 123      function &getUser($id)
 124      {
 125          if (!isset($this->_members[$id])) {
 126              $this->_members[$id] =& $this->_uHandler->get($id);
 127          }
 128          return $this->_members[$id];
 129      }
 130  
 131      /**

 132       * delete a group

 133       *

 134       * @param object $group reference to the group to delete

 135       * @return bool FALSE if failed

 136       */
 137      function deleteGroup(&$group)
 138      {
 139          $this->_gHandler->delete($group);
 140          $this->_mHandler->deleteAll(new Criteria('groupid', $group->getVar('groupid')));
 141          return true;
 142      }
 143  
 144      /**

 145       * delete a user

 146       *

 147       * @param object $user reference to the user to delete

 148       * @return bool FALSE if failed

 149       */
 150      function deleteUser(&$user)
 151      {
 152          $this->_uHandler->delete($user);
 153          $this->_mHandler->deleteAll(new Criteria('uid', $user->getVar('uid')));
 154          return true;
 155      }
 156  
 157      /**

 158       * insert a group into the database

 159       *

 160       * @param object $group reference to the group to insert

 161       * @return bool TRUE if already in database and unchanged

 162       * FALSE on failure

 163       */
 164      function insertGroup(&$group)
 165      {
 166          return $this->_gHandler->insert($group);
 167      }
 168  
 169      /**

 170       * insert a user into the database

 171       *

 172       * @param object $user reference to the user to insert

 173       * @return bool TRUE if already in database and unchanged

 174       * FALSE on failure

 175       */
 176      function insertUser(&$user, $force = false)
 177      {
 178          return $this->_uHandler->insert($user, $force);
 179      }
 180  
 181      /**

 182       * retrieve groups from the database

 183       *

 184       * @param object $criteria {@link CriteriaElement}

 185       * @param bool $id_as_key use the group's ID as key for the array?

 186       * @return array array of {@link XoopsGroup} objects

 187       */
 188      function getGroups($criteria = null, $id_as_key = false)
 189      {
 190          return $this->_gHandler->getObjects($criteria, $id_as_key);
 191      }
 192  
 193      /**

 194       * retrieve users from the database

 195       *

 196       * @param object $criteria {@link CriteriaElement}

 197       * @param bool $id_as_key use the group's ID as key for the array?

 198       * @return array array of {@link XoopsUser} objects

 199       */
 200      function getUsers($criteria = null, $id_as_key = false)
 201      {
 202          return $this->_uHandler->getObjects($criteria, $id_as_key);
 203      }
 204  
 205      /**

 206       * get a list of groupnames and their IDs

 207       *

 208       * @param object $criteria {@link CriteriaElement} object

 209       * @return array associative array of group-IDs and names

 210       */
 211      function getGroupList($criteria = null)
 212      {
 213          $groups = $this->_gHandler->getObjects($criteria, true);
 214          $ret = array();
 215          foreach (array_keys($groups) as $i) {
 216              $ret[$i] = $groups[$i]->getVar('name');
 217          }
 218          return $ret;
 219      }
 220  
 221      /**

 222       * get a list of usernames and their IDs

 223       *

 224       * @param object $criteria {@link CriteriaElement} object

 225       * @return array associative array of user-IDs and names

 226       */
 227      function getUserList($criteria = null)
 228      {
 229          $users = $this->_uHandler->getObjects($criteria, true);
 230          $ret = array();
 231          foreach (array_keys($users) as $i) {
 232              $ret[$i] = $users[$i]->getVar('uname');
 233          }
 234          return $ret;
 235      }
 236  
 237      /**

 238       * add a user to a group

 239       *

 240       * @param int $group_id ID of the group

 241       * @param int $user_id ID of the user

 242       * @return object XoopsMembership

 243       */
 244      function addUserToGroup($group_id, $user_id)
 245      {
 246          $mship =& $this->_mHandler->create();
 247          $mship->setVar('groupid', $group_id);
 248          $mship->setVar('uid', $user_id);
 249          return $this->_mHandler->insert($mship);
 250      }
 251  
 252      /**

 253       * remove a list of users from a group

 254       *

 255       * @param int $group_id ID of the group

 256       * @param array $user_ids array of user-IDs

 257       * @return bool success?

 258       */
 259      function removeUsersFromGroup($group_id, $user_ids = array())
 260      {
 261          $criteria = new CriteriaCompo();
 262          $criteria->add(new Criteria('groupid', $group_id));
 263          $criteria2 = new CriteriaCompo();
 264          foreach ($user_ids as $uid) {
 265              $criteria2->add(new Criteria('uid', $uid), 'OR');
 266          }
 267          $criteria->add($criteria2);
 268          return $this->_mHandler->deleteAll($criteria);
 269      }
 270  
 271      /**

 272       * get a list of users belonging to a group

 273       *

 274       * @param int $group_id ID of the group

 275       * @param bool $asobject return the users as objects?

 276       * @param int $limit number of users to return

 277       * @param int $start index of the first user to return

 278       * @return array Array of {@link XoopsUser} objects (if $asobject is TRUE)

 279       * or of associative arrays matching the record structure in the database.

 280       */
 281      function getUsersByGroup($group_id, $asobject = false, $limit = 0, $start = 0)
 282      {
 283          $user_ids = $this->_mHandler->getUsersByGroup($group_id, $limit, $start);
 284          if (!$asobject) {
 285             return $user_ids;
 286          } else {
 287             $ret = array();
 288             foreach ($user_ids as $u_id) {
 289                 $user =& $this->getUser($u_id);
 290                  if (is_object($user)) {
 291                      $ret[] =& $user;
 292                  }
 293                  unset($user);
 294             }
 295             return $ret;
 296          }
 297      }
 298  
 299      /**

 300       * get a list of groups that a user is member of

 301       *

 302       * @param int $user_id ID of the user

 303       * @param bool $asobject return groups as {@link XoopsGroup} objects or arrays?

 304       * @return array array of objects or arrays

 305       */
 306      function getGroupsByUser($user_id, $asobject = false)
 307      {
 308          $group_ids = $this->_mHandler->getGroupsByUser($user_id);
 309          if (!$asobject) {
 310             return $group_ids;
 311          } else {
 312             foreach ($group_ids as $g_id) {
 313                 $ret[] =& $this->getGroup($g_id);
 314             }
 315             return $ret;
 316          }
 317      }
 318  
 319      /**

 320       * log in a user

 321       *

 322       * @param string $uname username as entered in the login form

 323       * @param string $pwd password entered in the login form

 324       * @return object XoopsUser reference to the logged in user. FALSE if failed to log in

 325       */
 326      function &loginUser($uname, $pwd)
 327      {
 328          $criteria = new CriteriaCompo(new Criteria('uname', $uname));
 329          $criteria->add(new Criteria('pass', md5($pwd)));
 330          $user = $this->_uHandler->getObjects($criteria, false);
 331          if (!$user || count($user) != 1) {
 332              $user = false;
 333              return $user;
 334          }
 335          return $user[0];
 336      }
 337  
 338      /**

 339       * logs in a user with an nd5 encrypted password

 340       *

 341       * @param string $uname username

 342       * @param string $md5pwd password encrypted with md5

 343       * @return object XoopsUser reference to the logged in user. FALSE if failed to log in

 344       */
 345      function &loginUserMd5($uname, $md5pwd)
 346      {
 347          $criteria = new CriteriaCompo(new Criteria('uname', $uname));
 348          $criteria->add(new Criteria('pass', $md5pwd));
 349          $user = $this->_uHandler->getObjects($criteria, false);
 350          if (!$user || count($user) != 1) {
 351              $user = false;
 352              return $user;
 353          }
 354          return $user[0];
 355      }
 356  
 357      /**

 358       * count users matching certain conditions

 359       *

 360       * @param object $criteria {@link CriteriaElement} object

 361       * @return int

 362       */
 363      function getUserCount($criteria = null)
 364      {
 365          return $this->_uHandler->getCount($criteria);
 366      }
 367  
 368      /**

 369       * count users belonging to a group

 370       *

 371       * @param int $group_id ID of the group

 372       * @return int

 373       */
 374      function getUserCountByGroup($group_id)
 375      {
 376          return $this->_mHandler->getCount(new Criteria('groupid', $group_id));
 377      }
 378  
 379      /**

 380       * updates a single field in a users record

 381       *

 382       * @param object $user reference to the {@link XoopsUser} object

 383       * @param string $fieldName name of the field to update

 384       * @param string $fieldValue updated value for the field

 385       * @return bool TRUE if success or unchanged, FALSE on failure

 386       */
 387      function updateUserByField(&$user, $fieldName, $fieldValue)
 388      {
 389          $user->setVar($fieldName, $fieldValue);
 390          return $this->insertUser($user);
 391      }
 392  
 393      /**

 394       * updates a single field in a users record

 395       *

 396       * @param string $fieldName name of the field to update

 397       * @param string $fieldValue updated value for the field

 398       * @param object $criteria {@link CriteriaElement} object

 399       * @return bool TRUE if success or unchanged, FALSE on failure

 400       */
 401      function updateUsersByField($fieldName, $fieldValue, $criteria = null)
 402      {
 403          return $this->_uHandler->updateAll($fieldName, $fieldValue, $criteria);
 404      }
 405  
 406      /**

 407       * activate a user

 408       *

 409       * @param object $user reference to the {@link XoopsUser} object

 410       * @return bool successful?

 411       */
 412      function activateUser(&$user)
 413      {
 414          if ($user->getVar('level') != 0) {
 415              return true;
 416          }
 417          $user->setVar('level', 1);
 418          return $this->_uHandler->insert($user, true);
 419      }
 420  
 421      /**

 422       * Get a list of users belonging to certain groups and matching criteria

 423       * Temporary solution

 424       *

 425       * @param int $groups IDs of groups

 426       * @param object $criteria {@link CriteriaElement} object

 427       * @param bool $asobject return the users as objects?

 428       * @param bool $id_as_key use the UID as key for the array if $asobject is TRUE

 429       * @return array Array of {@link XoopsUser} objects (if $asobject is TRUE)

 430       * or of associative arrays matching the record structure in the database.

 431       */
 432      function getUsersByGroupLink($groups, $criteria = null, $asobject = false, $id_as_key = false)
 433      {
 434          $ret = array();
 435  
 436          $select = $asobject ? "u.*" : "u.uid";
 437          $sql[] = "    SELECT DISTINCT {$select} ".
 438                  "    FROM " . $this->_uHandler->db->prefix("users") . " AS u".
 439                  "        LEFT JOIN ". $this->_mHandler->db->prefix("groups_users_link") . " AS m ON m.uid = u.uid".
 440                  "    WHERE 1 = 1";
 441          if (!empty($groups)) {
 442              $sql[] = "m.groupid IN (".implode(", ", $groups).")";
 443          }
 444          $limit = $start = 0;
 445          if (isset($criteria) && is_subclass_of($criteria, 'criteriaelement')) {
 446              $sql_criteria = $criteria->render();
 447              if ($criteria->getSort() != '') {
 448                  $sql_criteria .= ' ORDER BY '.$criteria->getSort().' '.$criteria->getOrder();
 449              }
 450              $limit = $criteria->getLimit();
 451              $start = $criteria->getStart();
 452              if ($sql_criteria) {
 453                  $sql[] = $sql_criteria;
 454              }
 455          }
 456          $sql_string = implode(" AND ", array_filter($sql));
 457          if (!$result = $this->_uHandler->db->query($sql_string, $limit, $start)) {
 458              return $ret;
 459          }
 460          while ($myrow = $this->_uHandler->db->fetchArray($result)) {
 461              if ($asobject) {
 462                  $user = new XoopsUser();
 463                  $user->assignVars($myrow);
 464                  if (!$id_as_key) {
 465                      $ret[] =& $user;
 466                  } else {
 467                      $ret[$myrow['uid']] =& $user;
 468                  }
 469                  unset($user);
 470              } else {
 471                  $ret[] = $myrow['uid'];
 472              }
 473          }
 474          return $ret;
 475      }
 476  
 477      /**

 478       * Get count of users belonging to certain groups and matching criteria

 479       * Temporary solution

 480       *

 481       * @param int $groups IDs of groups

 482       * @return int count of users

 483       */
 484      function getUserCountByGroupLink($groups, $criteria = null)
 485      {
 486          $ret = 0;
 487  
 488          $sql[] = "    SELECT COUNT(DISTINCT u.uid) ".
 489                  "    FROM " . $this->_uHandler->db->prefix("users") . " AS u".
 490                  "        LEFT JOIN ". $this->_mHandler->db->prefix("groups_users_link") . " AS m ON m.uid = u.uid".
 491                  "    WHERE 1 = 1";
 492          if (!empty($groups)) {
 493              $sql[] = "m.groupid IN (".implode(", ", $groups).")";
 494          }
 495          if (isset($criteria) && is_subclass_of($criteria, 'criteriaelement')) {
 496              $sql[] = $criteria->render();
 497          }
 498          $sql_string = implode(" AND ", array_filter($sql));
 499          if (!$result = $this->_uHandler->db->query($sql_string)) {
 500              return $ret;
 501          }
 502          list($ret) = $this->_uHandler->db->fetchRow($result);
 503          return $ret;
 504      }
 505  
 506  }
 507  ?>