luos/workflow/engine/classes/class.groups.php

<?php

/**
 * class.groups.php
 *
 * @package workflow.engine.ProcessMaker
 *
 * ProcessMaker Open Source Edition
 * Copyright (C) 2004 - 2011 Colosa Inc.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * For more information, contact Colosa Inc, 2566 Le Jeune Rd.,
 * Coral Gables, FL, 33134, USA, or email info@colosa.com.
 *
 */
require_once 'classes/model/Groupwf.php';
require_once 'classes/model/GroupUser.php';
require_once 'classes/model/Users.php';

/**
 * Groups - Groups class
 *
 * @package workflow.engine.ProcessMaker
 * @copyright 2007 COLOSA
 */
class Groups
{

    /**
     * Get the assigned users of a group
     *
     * @param string $sGroupUID
     * @return array
     */
    public function getUsersOfGroup($sGroupUID)
    {
        try {
            $aUsers = array();
            $oCriteria = new Criteria();
            $oCriteria->addJoin(UsersPeer::USR_UID, GroupUserPeer::USR_UID, Criteria::LEFT_JOIN);
            $oCriteria->add(GroupUserPeer::GRP_UID, $sGroupUID);
            $oCriteria->add(UsersPeer::USR_STATUS, 'ACTIVE');
            $oDataset = UsersPeer::doSelectRS($oCriteria);
            $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
            $oDataset->next();

            while ($aRow = $oDataset->getRow()) {
                $aUsers[] = $aRow;
                $oDataset->next();
            }
            return $aUsers;
        } catch (exception $oError) {
            throw ($oError);
        }
    }

    /**
     * Get the active groups for an user
     *
     * @param string $sUserUID
     * @return array
     */
    public function getActiveGroupsForAnUser($sUserUID)
    {
        try {
            $oCriteria = new Criteria();
            $oCriteria->addSelectColumn(GroupUserPeer::GRP_UID);
            $oCriteria->addSelectColumn(GroupwfPeer::GRP_STATUS);
            $oCriteria->add(GroupUserPeer::USR_UID, $sUserUID);
            $oCriteria->add(GroupwfPeer::GRP_STATUS, 'ACTIVE');
            $oCriteria->addJoin(GroupUserPeer::GRP_UID, GroupwfPeer::GRP_UID, Criteria::LEFT_JOIN);
            $oDataset = GroupUserPeer::doSelectRS($oCriteria);
            $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
            $oDataset->next();

            $aGroups = array();
            $aRow = $oDataset->getRow();
            while (is_array($aRow)) {
                $aGroups[] = $aRow['GRP_UID'];
                $oDataset->next();
                $aRow = $oDataset->getRow();
            }
            return $aGroups;
        } catch (exception $oError) {
            throw ($oError);
        }
    }

    /**
     * Set a user to group
     *
     * @param string $GrpUid, $UsrUid
     * @return array
     */
    public function addUserToGroup($GrpUid, $UsrUid)
    {
        try {
            $oGrp = GroupUserPeer::retrieveByPk($GrpUid, $UsrUid);
            if (is_object($oGrp) && get_class($oGrp) == 'GroupUser') {
                return true;
            } else {
                $oGrp = new GroupUser();
                $oGrp->setGrpUid($GrpUid);
                $oGrp->setUsrUid($UsrUid);
                $oGrp->Save();

                $oGrpwf = new Groupwf();
                $grpName = $oGrpwf->loadByGroupUid($GrpUid);

                $oUsr = new Users();
                $usrName = $oUsr->load($UsrUid);
                
                G::auditLog("AssignUserToGroup", "Assign user ". $usrName['USR_USERNAME'] ." (".$UsrUid.") to group ".$grpName['CON_VALUE']." (".$GrpUid.") ");
            }
        } catch (exception $oError) {
            throw ($oError);
        }
    }

    /**
     * Remove a user from group
     * @param string $GrpUid, $UsrUid
     * @return array
     */
    public function removeUserOfGroup($GrpUid, $UsrUid)
    {
        $gu = new GroupUser();
        $gu->remove($GrpUid, $UsrUid);
    }

    /**
     * get all groups
     *
     * @param none
     * @return $objects
     */
    public function getAllGroups()
    {
        try {
            $criteria = new Criteria();
            $criteria->add(GroupwfPeer::GRP_UID, "", Criteria::NOT_EQUAL);
            $con = Propel::getConnection(GroupwfPeer::DATABASE_NAME);
            $objects = GroupwfPeer::doSelect($criteria, $con);
            return $objects;
        } catch (exception $e) {
            throw $e;
        }
    }

    /**
     * get all the groups from a single user
     *
     * @param $sUserUid user uid
     * @return an array of group objects
     */
    public function getUserGroups($sUserUID)
    {
        try {
            $criteria = new Criteria();
            $criteria->add(GroupwfPeer::GRP_UID, "", Criteria::NOT_EQUAL);
            $criteria->add(GroupUserPeer::USR_UID, $sUserUID);
            $criteria->add(GroupwfPeer::GRP_STATUS, 'ACTIVE');
            $criteria->addJoin(GroupUserPeer::GRP_UID, GroupwfPeer::GRP_UID, Criteria::LEFT_JOIN);
            $con = Propel::getConnection(GroupwfPeer::DATABASE_NAME);
            $objects = GroupwfPeer::doSelect($criteria, $con);
            return $objects;
        } catch (exception $e) {
            throw $e;
        }
    }

    /**
     * Get Available Groups for a single user
     *
     * @author Qennix
     * @param string $sUserUid
     * @return object
     */
    public function getAvailableGroupsCriteria($sUserUid, $filter = '')
    {
        try {
            $oCriteria = new Criteria('workflow');
            $oCriteria->addSelectColumn(GroupUserPeer::GRP_UID);
            $oCriteria->add(GroupUserPeer::USR_UID, $sUserUid);
            $oCriteria->add(GroupUserPeer::GRP_UID, '', Criteria::NOT_EQUAL);
            $oDataset = GroupUserPeer::doSelectRS($oCriteria);
            $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
            $oDataset->next();
            $gUIDs = array();
            while ($aRow = $oDataset->getRow()) {
                $gUIDs[] = $aRow['GRP_UID'];
                $oDataset->next();
            }
            $oCriteria = new Criteria('workflow');
            $oCriteria->addSelectColumn(GroupwfPeer::GRP_UID);
            $oCriteria->addSelectColumn(GroupwfPeer::GRP_STATUS);
            $oCriteria->addSelectColumn(ContentPeer::CON_VALUE);
            $oCriteria->addJoin(GroupwfPeer::GRP_UID, ContentPeer::CON_ID, Criteria::LEFT_JOIN);
            $oCriteria->add(GroupwfPeer::GRP_UID, $gUIDs, Criteria::NOT_IN);
            $oCriteria->add(GroupwfPeer::GRP_STATUS, 'ACTIVE');
            $oCriteria->add(ContentPeer::CON_CATEGORY, 'GRP_TITLE');
            $oCriteria->add(ContentPeer::CON_LANG, SYS_LANG);

            if ($filter != '') {
                $oCriteria->add(ContentPeer::CON_VALUE, '%' . $filter . '%', Criteria::LIKE);
            }

            return $oCriteria;
        } catch (exception $e) {
            throw $e;
        }
    }

    /**
     * Get Assigned Groups for a single user
     *
     * @author Qennix
     * @param string $sUserUid
     * @return object
     */
    public function getAssignedGroupsCriteria($sUserUid, $filter = '')
    {
        try {
            $oCriteria = new Criteria('workflow');
            $oCriteria->addSelectColumn(GroupwfPeer::GRP_UID);
            $oCriteria->addSelectColumn(GroupwfPeer::GRP_STATUS);
            $oCriteria->addSelectColumn(GroupwfPeer::GRP_LDAP_DN);
            $oCriteria->addSelectColumn(ContentPeer::CON_VALUE);
            $oCriteria->addJoin(GroupUserPeer::GRP_UID, GroupwfPeer::GRP_UID, Criteria::LEFT_JOIN);
            $oCriteria->addJoin(GroupwfPeer::GRP_UID, ContentPeer::CON_ID, Criteria::LEFT_JOIN);
            $oCriteria->add(GroupUserPeer::USR_UID, $sUserUid, Criteria::EQUAL);
            $oCriteria->add(GroupwfPeer::GRP_STATUS, 'ACTIVE');
            $oCriteria->add(ContentPeer::CON_CATEGORY, 'GRP_TITLE');
            $oCriteria->add(ContentPeer::CON_LANG, SYS_LANG);

            if ($filter != '') {
                $oCriteria->add(ContentPeer::CON_VALUE, '%' . $filter . '%', Criteria::LIKE);
            }

            return $oCriteria;
        } catch (exception $e) {
            throw $e;
        }
    }

    public function getGroupsForUser($usrUid)
    {
        $criteria = $this->getAssignedGroupsCriteria($usrUid);
        $criteria->addAscendingOrderByColumn(ContentPeer::CON_VALUE);
        $dataset = GroupwfPeer::doSelectRS($criteria);
        $dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
        $dataset->next();
        $groups = array();
        while ($row = $dataset->getRow()) {
            if (!isset($groups[$row['GRP_UID']])) {
                $groups[$row['GRP_UID']] = $row;
            }
            $dataset->next();
        }
        return $groups;
    }

    /**
     * Remove a user from all groups
     *
     * @param string $sUsrUid
     * @return void
     */
    public function removeUserOfAllGroups($sUserUID = '')
    {
        try {
            $oCriteria = new Criteria('workflow');
            $oCriteria->add(GroupUserPeer::USR_UID, $sUserUID);
            GroupUserPeer::doDelete($oCriteria);
        } catch (exception $oError) {
            throw ($oError);
        }
    }

    /**
     * Get a criteria object of all users from group
     *
     * @param string $sGroupUID
     * @return array
     */
    public function getUsersGroupCriteria($sGroupUID = '')
    {
        require_once 'classes/model/GroupUser.php';
        require_once 'classes/model/Users.php';
        try {
            $oCriteria = new Criteria('workflow');
            $oCriteria->addSelectColumn(GroupUserPeer::GRP_UID);
            $oCriteria->addSelectColumn(UsersPeer::USR_UID);
            $oCriteria->addSelectColumn(UsersPeer::USR_USERNAME);
            $oCriteria->addSelectColumn(UsersPeer::USR_FIRSTNAME);
            $oCriteria->addSelectColumn(UsersPeer::USR_LASTNAME);
            $oCriteria->addSelectColumn(UsersPeer::USR_EMAIL);
            $oCriteria->addJoin(GroupUserPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN);
            $oCriteria->add(GroupUserPeer::GRP_UID, $sGroupUID);
            $oCriteria->add(UsersPeer::USR_STATUS, 'ACTIVE');
            return $oCriteria;
        } catch (exception $oError) {
            throw ($oError);
        }
    }

    /**
     * Get a criteria object of all groups from user
     *
     * @param string $sGroupUID
     * @return array
     */
    public function getUserGroupsCriteria($sUserUID = '')
    {
        require_once 'classes/model/GroupUser.php';
        require_once 'classes/model/Users.php';
        try {
            $oCriteria = new Criteria('workflow');
            $oCriteria->addSelectColumn(UsersPeer::USR_UID);
            $oCriteria->addSelectColumn(GroupUserPeer::GRP_UID);
            $oCriteria->addSelectColumn(UsersPeer::USR_FIRSTNAME);
            $oCriteria->addSelectColumn(UsersPeer::USR_LASTNAME);
            $oCriteria->addJoin(GroupUserPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN);
            $oCriteria->add(GroupUserPeer::GRP_UID, $sUserUID);
            $oCriteria->add(UsersPeer::USR_STATUS, 'ACTIVE');
            return $oCriteria;
        } catch (exception $oError) {
            throw ($oError);
        }
    }

    /**
     * Get the number of groups
     *
     * @param string $sGroupUid
     * @return integer $cnt
     */
    public function getNumberGroups($sUserUID)
    {
        try {
            $allGroups = $this->getUserGroups($sUserUID);
            $cnt = 0;
            foreach ($allGroups as $group) {
                $cnt++;
            }
            return $cnt;
        } catch (exception $oError) {
            print_r($oError);
        }
    }

    /**
     * Return the available users list criteria object
     *
     * @param string $sGroupUID
     * @return object
     */
    public function getAvailableUsersCriteria($sGroupUID = '')
    {
        try {
            $oCriteria = new Criteria('workflow');
            $oCriteria->addSelectColumn(UsersPeer::USR_UID);
            $oCriteria->addJoin(GroupUserPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN);
            $oCriteria->add(GroupUserPeer::GRP_UID, $sGroupUID);
            $oCriteria->add(UsersPeer::USR_STATUS, 'ACTIVE');
            $oDataset = UsersPeer::doSelectRS($oCriteria);
            $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
            $oDataset->next();
            $aUIDs = array();
            while ($aRow = $oDataset->getRow()) {
                $aUIDs[] = $aRow['USR_UID'];
                $oDataset->next();
            }
            $oCriteria = new Criteria('workflow');
            $oCriteria->addSelectColumn(UsersPeer::USR_UID);
            $oCriteria->addSelectColumn(UsersPeer::USR_FIRSTNAME);
            $oCriteria->addSelectColumn(UsersPeer::USR_LASTNAME);
            $oCriteria->add(UsersPeer::USR_UID, $aUIDs, Criteria::NOT_IN);
            $oCriteria->add(UsersPeer::USR_STATUS, 'ACTIVE');
            return $oCriteria;
        } catch (exception $oError) {
            throw ($oError);
        }
    }

    /**
     * Verify if a user is assigned to a group
     *
     * @param $GrpUid group Uid
     * @param $UsrUid user Uid
     * @return 1/0 if it's or not assigned
     */
    public function verifyUsertoGroup($GrpUid, $UsrUid)
    {
        try {
            $oGrp = GroupUserPeer::retrieveByPk($GrpUid, $UsrUid);
            if (is_object($oGrp) && get_class($oGrp) == 'GroupUser') {
                return 1;
            } else {
                return 0;
            }
        } catch (exception $oError) {
            throw ($oError);
        }
    }

    /**
     * Verify the existence of a Group
     *
     * @param $sGroupUid group Uid
     * @return 1/0 if exist or not
     */
    public function verifyGroup($sGroupUID)
    {
        try {
            $aUsers = array();
            $oCriteria = new Criteria();
            //$oCriteria->addJoin(UsersPeer::USR_UID, GroupUserPeer::USR_UID, Criteria::LEFT_JOIN);
            $oCriteria->add(GroupwfPeer::GRP_UID, $sGroupUID);
            //$oCriteria->add(UsersPeer::USR_STATUS, 'ACTIVE');
            $oDataset = GroupwfPeer::doSelectRS($oCriteria);
            $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
            $oDataset->next();
            $aRow = $oDataset->getRow();
            if (is_array($aRow)) {
                return 1;
            } else {
                return 0;
            }
        } catch (exception $oError) {
            throw ($oError);
        }
    }

    /**
     * Load all the data of a group with a search based on it uid
     *
     * @param $GrpUid group uid
     * @return an array of objects/false/exception object
     *
     */
    public function load($GrpUid)
    {
        try {
            $criteria = new Criteria();
            $criteria->add(GroupwfPeer::GRP_UID, $GrpUid, Criteria::EQUAL);
            $con = Propel::getConnection(GroupwfPeer::DATABASE_NAME);
            $objects = GroupwfPeer::doSelect($criteria, $con);
            if (is_array($objects) && count($objects) > 0) {
                return $objects[0];
            } else {
                return false;
            }
        } catch (exception $e) {
            throw $e;
        }
    }
}