member.php

Go to the documentation of this file.

<?php
use Xoops\Core\Database\Connection;
use Xoops\Core\Kernel\Criteria;
use Xoops\Core\Kernel\CriteriaCompo;
use Xoops\Core\Kernel\CriteriaElement;

class XoopsMemberHandler
{

    private $_gHandler;

    private $_uHandler;

    private $_mHandler;

    private $_members = array();

    public function __construct(Connection $db = null)
    {
        $this->_gHandler = Xoops::getInstance()->getHandlerGroup();
        $this->_uHandler = Xoops::getInstance()->getHandlerUser();
        $this->_mHandler = Xoops::getInstance()->getHandlerMembership();
    }

    public function createGroup()
    {
        $inst = $this->_gHandler->create();
        return $inst;
    }

    public function createUser()
    {
        $inst = $this->_uHandler->create();
        return $inst;
    }

    public function getGroup($id)
    {
        return $this->_gHandler->get($id);
    }

    public function getUser($id)
    {
        if (!isset($this->_members[$id])) {
            $this->_members[$id] = $this->_uHandler->get($id);
        }
        return $this->_members[$id];
    }

    public function deleteGroup(XoopsGroup &$group)
    {
        $this->_gHandler->delete($group);
        $this->_mHandler->deleteAll(new Criteria('groupid', $group->getVar('groupid')));
        return true;
    }

    public function deleteUser(XoopsUser &$user)
    {
        $this->_uHandler->delete($user);
        $this->_mHandler->deleteAll(new Criteria('uid', $user->getVar('uid')));
        return true;
    }

    public function insertGroup(XoopsGroup &$group)
    {
        return $this->_gHandler->insert($group);
    }

    public function insertUser(XoopsUser &$user, $force = false)
    {
        return $this->_uHandler->insert($user, $force);
    }

    public function getGroups(CriteriaElement $criteria = null, $id_as_key = false)
    {
        return $this->_gHandler->getObjects($criteria, $id_as_key);
    }

    public function getUsers(CriteriaElement $criteria = null, $id_as_key = false)
    {
        return $this->_uHandler->getObjects($criteria, $id_as_key);
    }

    public function getGroupList(CriteriaElement $criteria = null)
    {
        $groups = $this->_gHandler->getObjects($criteria, true);
        $ret = array();
        foreach (array_keys($groups) as $i) {
            $ret[$i] = $groups[$i]->getVar('name');
        }
        return $ret;
    }

    public function getUserList(CriteriaElement $criteria = null)
    {
        $users = $this->_uHandler->getObjects($criteria, true);
        $ret = array();
        foreach (array_keys($users) as $i) {
            $ret[$i] = $users[$i]->getVar('uname');
        }
        return $ret;
    }

    public function addUserToGroup($group_id, $user_id)
    {
        $mship = $this->_mHandler->create();
        $mship->setVar('groupid', $group_id);
        $mship->setVar('uid', $user_id);
        return $this->_mHandler->insert($mship);
    }

    public function removeUsersFromGroup($group_id, $user_ids = array())
    {
        $criteria = new CriteriaCompo();
        $criteria->add(new Criteria('groupid', $group_id));
        $criteria2 = new CriteriaCompo();
        foreach ($user_ids as $uid) {
            $criteria2->add(new Criteria('uid', $uid), 'OR');
        }
        $criteria->add($criteria2);
        return $this->_mHandler->deleteAll($criteria);
    }

    public function getUsersByGroup($group_id, $asobject = false, $limit = 0, $start = 0)
    {
        $user_ids = $this->_mHandler->getUsersByGroup($group_id, $limit, $start);
        if (!$asobject) {
            return $user_ids;
        } else {
            $ret = array();
            foreach ($user_ids as $u_id) {
                $user = $this->getUser($u_id);
                if (is_object($user)) {
                    $ret[] = $user;
                }
                unset($user);
            }
            return $ret;
        }
    }

    public function getGroupsByUser($user_id, $asobject = false)
    {
        $ret = array();
        $group_ids = $this->_mHandler->getGroupsByUser($user_id);
        if (!$asobject) {
            return $group_ids;
        } else {
            foreach ($group_ids as $g_id) {
                $ret[] = $this->getGroup($g_id);
            }
            return $ret;
        }
    }

    public function loginUser($uname, $pwd)
    {
        $criteria = new Criteria('uname', $uname);
        //$criteria->add(new Criteria('pass', md5($pwd)));
        $user = $this->_uHandler->getObjects($criteria, false);
        if (!$user || count($user) != 1) {
            return false;
        }
        $rehash = false;
        $hash = $user[0]->pass();
        $type = substr($user[0]->pass(), 0, 1);
        // see if we have a crypt like signature, old md5 hash is just hex digits
        if ($type=='$') {
            if (!password_verify($pwd, $hash)) {
                return false;
            }
            // check if hash uses the best algorithm (i.e. after a PHP upgrade)
            $rehash = password_needs_rehash($hash, PASSWORD_DEFAULT);
        } else {
            if ($hash!=md5($pwd)) {
                return false;
            }
            $rehash = true; // automatically update old style
        }
        // hash used an old algorithm, so make it stronger
        if ($rehash) {
            $user[0]->setVar('pass', password_hash($pwd, PASSWORD_DEFAULT));
            $this->_uHandler->insert($user[0]);
        }
        return $user[0];
    }

    public function loginUserMd5($uname, $md5pwd)
    {
        $criteria = new CriteriaCompo(new Criteria('uname', $uname));
        $criteria->add(new Criteria('pass', $md5pwd));
        $user = $this->_uHandler->getObjects($criteria, false);
        if (!$user || count($user) != 1) {
            $user = false;
            return $user;
        }
        return $user[0];
    }

    public function getUserCount(CriteriaElement $criteria = null)
    {
        return $this->_uHandler->getCount($criteria);
    }

    public function getUserCountByGroup($group_id)
    {
        return $this->_mHandler->getCount(new Criteria('groupid', $group_id));
    }

    public function updateUserByField(XoopsUser &$user, $fieldName, $fieldValue)
    {
        $user->setVar($fieldName, $fieldValue);
        return $this->insertUser($user);
    }

    public function updateUsersByField($fieldName, $fieldValue, CriteriaElement $criteria = null)
    {
        if (is_null($criteria)) {
            $criteria = new Criteria(''); // empty criteria resolves to 'WHERE (1)'
        }
        return $this->_uHandler->updateAll($fieldName, $fieldValue, $criteria);
    }

    public function activateUser(XoopsUser &$user)
    {
        if ($user->getVar('level') != 0) {
            return true;
        }
        $user->setVar('level', 1);
        return $this->_uHandler->insert($user, true);
    }

    public function getUsersByGroupLink(
        $groups,
        CriteriaElement $criteria = null,
        $asobject = false,
        $id_as_key = false
    ) {

        $qb = $this->_uHandler->db2->createXoopsQueryBuilder();
        $eb = $qb->expr();

        $qb ->select('DISTINCT ' . ($asobject ? 'u.*' : 'u.uid'))
            ->fromPrefix('users', 'u')
            ->leftJoinPrefix('u', 'groups_users_link', 'm', 'm.uid = u.uid');

        $where = false;
        if (!empty($groups)) {
            $qb->where($eb->in('m.groupid', $groups));
            $where = true;
        }
        if (isset($criteria) && ($criteria instanceof CriteriaElement)) {
            $whereMode = $where ? 'AND' : '';
            $sql[] = $criteria->renderQb($qb, $whereMode);
        }

        $ret = array();

        if (!$result = $qb->execute()) {
            return $ret;
        }

        while ($myrow = $result->fetch(PDO::FETCH_ASSOC)) {
            if ($asobject) {
                $user = new XoopsUser();
                $user->assignVars($myrow);
                if (!$id_as_key) {
                    $ret[] = $user;
                } else {
                    $ret[$myrow['uid']] = $user;
                }
                unset($user);
            } else {
                $ret[] = $myrow['uid'];
            }
        }
        return $ret;
    }

    public function getUserCountByGroupLink($groups, $criteria = null)
    {
        $qb = $this->_uHandler->db2->createXoopsQueryBuilder();
        $eb = $qb->expr();

        $qb ->select('COUNT(DISTINCT u.uid)')
            ->fromPrefix('users', 'u')
            ->leftJoinPrefix('u', 'groups_users_link', 'm', 'm.uid = u.uid');

        $where = false;
        if (!empty($groups)) {
            $qb->where($eb->in('m.groupid', $groups));
            $where = true;
        }
        if (isset($criteria) && ($criteria instanceof CriteriaElement)) {
            $whereMode = $where ? 'AND' : '';
            $criteria->renderQb($qb, $whereMode);
        }

        $result = $qb->execute();
        $ret = $result->fetchColumn(0);

        return $ret;
    }
}