Exemplo n.º 1
0
 /**
  * Implementation for 'GET' method for Rest API
  *
  * @param  mixed $tasUid, $usrUid, $tuType, $tuRelation Primary key
  *
  * @return array $result Returns array within multiple records or a single record depending if
  *                       a single selection was requested passing id(s) as param
  */
 protected function get($tasUid = null, $usrUid = null, $tuType = null, $tuRelation = null)
 {
     $result = array();
     try {
         $noArguments = true;
         $argumentList = func_get_args();
         foreach ($argumentList as $arg) {
             if (!is_null($arg)) {
                 $noArguments = false;
             }
         }
         if ($noArguments) {
             $criteria = new Criteria('workflow');
             $criteria->addSelectColumn(TaskUserPeer::TAS_UID);
             $criteria->addSelectColumn(TaskUserPeer::USR_UID);
             $criteria->addSelectColumn(TaskUserPeer::TU_TYPE);
             $criteria->addSelectColumn(TaskUserPeer::TU_RELATION);
             $dataset = AppEventPeer::doSelectRS($criteria);
             $dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
             while ($dataset->next()) {
                 $result[] = $dataset->getRow();
             }
         } else {
             $record = TaskUserPeer::retrieveByPK($tasUid, $usrUid, $tuType, $tuRelation);
             if ($record) {
                 $result = $record->toArray(BasePeer::TYPE_FIELDNAME);
             } else {
                 $paramValues = "";
                 foreach ($argumentList as $arg) {
                     $paramValues .= strlen($paramValues) ? ', ' : '';
                     if (!is_null($arg)) {
                         $paramValues .= "{$arg}";
                     } else {
                         $paramValues .= "NULL";
                     }
                 }
                 throw new RestException(417, "table TaskUser ({$paramValues})");
             }
         }
     } catch (RestException $e) {
         throw new RestException($e->getCode(), $e->getMessage());
     } catch (Exception $e) {
         throw new RestException(412, $e->getMessage());
     }
     return $result;
 }
Exemplo n.º 2
0
 public static function retrieveByUserId($value, $criteria = null)
 {
     $c = new Criteria();
     $c->add(TaskUserPeer::USER_ID, $value);
     $results = TaskUserPeer::doSelect($c);
     $task_ids = array();
     foreach ($results as $result) {
         $task_ids[] = $result->getTaskId();
     }
     if ($criteria == null) {
         $c = new Criteria();
     } else {
         $c = clone $criteria;
     }
     $c->add(self::ID, $task_ids, Criteria::IN);
     return self::doSelect($c);
 }
Exemplo n.º 3
0
 /**
  * Get tasks that the usser is assigned
  * @param string $sUsrUID
  * @return array
  */
 public function getTasksThatUserIsAssigned($sUserUID)
 {
     try {
         $aTasks = array();
         $oCriteria = new Criteria('workflow');
         $oCriteria->add(TaskUserPeer::USR_UID, $sUserUID);
         $oCriteria->add(TaskUserPeer::TU_RELATION, 1);
         $oDataset = TaskUserPeer::doSelectRS($oCriteria);
         $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
         $oDataset->next();
         while ($aRow = $oDataset->getRow()) {
             $aTasks[] = $aRow['TAS_UID'];
             $oDataset->next();
         }
         $aGroups = array();
         $oCriteria = new Criteria();
         $oCriteria->add(GroupwfPeer::GRP_UID, '', Criteria::NOT_EQUAL);
         $oCriteria->add(GroupUserPeer::USR_UID, $sUserUID);
         $oCriteria->add(GroupwfPeer::GRP_STATUS, 'ACTIVE');
         $oCriteria->addJoin(GroupUserPeer::GRP_UID, GroupwfPeer::GRP_UID, Criteria::LEFT_JOIN);
         $oDataset = GroupwfPeer::doSelectRS($oCriteria);
         $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
         $oDataset->next();
         while ($aRow = $oDataset->getRow()) {
             $aGroups[] = $aRow['GRP_UID'];
             $oDataset->next();
         }
         $oCriteria = new Criteria('workflow');
         $oCriteria->add(TaskUserPeer::USR_UID, $aGroups, Criteria::IN);
         $oCriteria->add(TaskUserPeer::TU_RELATION, 2);
         $oDataset = TaskUserPeer::doSelectRS($oCriteria);
         $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
         $oDataset->next();
         while ($aRow = $oDataset->getRow()) {
             if (!in_array($aRow['TAS_UID'], $aTasks)) {
                 $aTasks[] = $aRow['TAS_UID'];
             }
             $oDataset->next();
         }
         return $aTasks;
     } catch (Exception $oError) {
         throw $oError;
     }
 }
Exemplo n.º 4
0
 function checkCredentials($params)
 {
     require_once 'classes/model/Event.php';
     require_once 'classes/model/Users.php';
     require_once 'classes/model/TaskUser.php';
     require_once 'classes/model/GroupUser.php';
     $sPRO_UID = $params->PRO_UID;
     $sEVN_UID = $params->EVN_UID;
     //$sDYNAFORM = $params->DYN_UID;
     $sWS_USER = trim($params->WS_USER);
     $sWS_PASS = trim($params->WS_PASS);
     if (G::is_https()) {
         $http = 'https://';
     } else {
         $http = 'http://';
     }
     $endpoint = $http . $_SERVER['HTTP_HOST'] . '/sys' . SYS_SYS . '/' . SYS_LANG . '/' . SYS_SKIN . '/services/wsdl2';
     @($client = new SoapClient($endpoint));
     $user = $sWS_USER;
     $pass = $sWS_PASS;
     $parameters = array('userid' => $user, 'password' => $pass);
     $result = $client->__SoapCall('login', array($parameters));
     $fields['status_code'] = $result->status_code;
     $fields['message'] = 'ProcessMaker WebService version: ' . $result->version . "\n" . $result->message;
     $fields['version'] = $result->version;
     $fields['time_stamp'] = $result->timestamp;
     $messageCode = true;
     $message = $result->message;
     G::LoadClass('Task');
     //G::LoadClass ( 'Event' );
     G::LoadClass('User');
     G::LoadClass('TaskUser');
     G::LoadClass('Groupwf');
     $event = new Event();
     $event->load($sEVN_UID);
     $sTASKS = $event->getEvnTasUidTo();
     $task = new Task();
     $task->load($sTASKS);
     $sTASKS_SEL = $task->getTasTitle();
     if (!class_exists('GroupUser')) {
         G::LoadClass('GroupUser');
     }
     // if the user has been authenticated, then check if has the rights or
     // permissions to create the webentry
     if ($result->status_code == 0) {
         $oCriteria = new Criteria('workflow');
         $oCriteria->addSelectColumn(UsersPeer::USR_UID);
         $oCriteria->addSelectColumn(TaskUserPeer::USR_UID);
         $oCriteria->addSelectColumn(TaskUserPeer::TAS_UID);
         $oCriteria->addJoin(TaskUserPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN);
         $oCriteria->add(TaskUserPeer::TAS_UID, $sTASKS);
         $oCriteria->add(UsersPeer::USR_USERNAME, $sWS_USER);
         //$oCriteria->add(TaskUserPeer::TU_RELATION,1);
         $userIsAssigned = TaskUserPeer::doCount($oCriteria);
         // if the user is not assigned directly, maybe a have the task a group with the user
         if ($userIsAssigned < 1) {
             $oCriteria = new Criteria('workflow');
             $oCriteria->addSelectColumn(UsersPeer::USR_UID);
             $oCriteria->addJoin(UsersPeer::USR_UID, GroupUserPeer::USR_UID, Criteria::LEFT_JOIN);
             $oCriteria->addJoin(GroupUserPeer::GRP_UID, TaskUserPeer::USR_UID, Criteria::LEFT_JOIN);
             $oCriteria->add(TaskUserPeer::TAS_UID, $sTASKS);
             $oCriteria->add(UsersPeer::USR_USERNAME, $sWS_USER);
             $userIsAssigned = GroupUserPeer::doCount($oCriteria);
             if (!($userIsAssigned >= 1)) {
                 $messageCode = false;
                 $message = "The User \"" . $sWS_USER . "\" doesn't have the task \"" . $sTASKS_SEL . "\" assigned.";
             }
         }
     } else {
         $messageCode = false;
     }
     $this->success = $messageCode;
     $this->msg = $message;
 }
Exemplo n.º 5
0
    function getAllUsersFromAnyTask ($sTasUid)

    {

        $users = array ();

        $c = new Criteria( 'workflow' );

        $c->clearSelectColumns();

        $c->addSelectColumn( TaskUserPeer::USR_UID );

        $c->addSelectColumn( TaskUserPeer::TU_RELATION );

        $c->add( TaskUserPeer::TAS_UID, $sTasUid );

        $c->add( TaskUserPeer::TU_TYPE, 1 );

        $rs = TaskUserPeer::DoSelectRs( $c );

        $rs->setFetchmode( ResultSet::FETCHMODE_ASSOC );

        $rs->next();

        $row = $rs->getRow();

        while (is_array( $row )) {

            if ($row['TU_RELATION'] == '2') {

                $cGrp = new Criteria( 'workflow' );

                $cGrp->add( GroupwfPeer::GRP_STATUS, 'ACTIVE' );

                $cGrp->add( GroupUserPeer::GRP_UID, $row['USR_UID'] );

                $cGrp->addJoin( GroupUserPeer::GRP_UID, GroupwfPeer::GRP_UID, Criteria::LEFT_JOIN );

                $cGrp->addJoin( GroupUserPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN );

                $cGrp->add( UsersPeer::USR_STATUS, 'INACTIVE', Criteria::NOT_EQUAL );

                $rsGrp = GroupUserPeer::DoSelectRs( $cGrp );

                $rsGrp->setFetchmode( ResultSet::FETCHMODE_ASSOC );

                $rsGrp->next();

                $rowGrp = $rsGrp->getRow();

                while (is_array( $rowGrp )) {

                    $users[$rowGrp['USR_UID']] = $rowGrp['USR_UID'];

                    $rsGrp->next();

                    $rowGrp = $rsGrp->getRow();

                }

            } else {

                //filter to users that is in vacation or has an inactive estatus, and others

                $oUser = UsersPeer::retrieveByPK( $row['USR_UID'] );

                if ($oUser->getUsrStatus() == 'ACTIVE') {

                    $users[$row['USR_UID']] = $row['USR_UID'];

                } else {

                    $userUID = $this->checkReplacedByUser( $oUser );

                    if ($userUID != '') {

                        $users[$userUID] = $userUID;

                    }

                }

            }

            $rs->next();

            $row = $rs->getRow();

        }

        //to do: different types of sort

        sort( $users );



        return $users;

    }
Exemplo n.º 6
0
    /**

     * Get Task User Rows for a Process

     *

     * @param array $aTask

     * @return array $aStepTrigger

     */

    public function getTaskUserRows ($aTask)

    {

        try {

            $aInTasks = array ();

            foreach ($aTask as $key => $val) {

                $aInTasks[] = $val['TAS_UID'];

            }



            $aTaskUser = array ();

            $oCriteria = new Criteria( 'workflow' );

            $oCriteria->add( TaskUserPeer::TAS_UID, $aInTasks, Criteria::IN );

            $oCriteria->add( TaskUserPeer::TU_RELATION, 2 );

            $oDataset = TaskUserPeer::doSelectRS( $oCriteria );

            $oDataset->setFetchmode( ResultSet::FETCHMODE_ASSOC );

            $oDataset->next();

            while ($aRow = $oDataset->getRow()) {

                $oCriteria2 = new Criteria( 'workflow' );

                $oCriteria2->clearSelectColumns();

                $oCriteria2->addSelectColumn( 'COUNT(*)' );

                $oCriteria2->add( GroupwfPeer::GRP_UID, $aRow['USR_UID'] );

                $oCriteria2->add( GroupwfPeer::GRP_STATUS, 'ACTIVE' );

                $oDataset2 = GroupwfPeer::doSelectRS( $oCriteria2 );

                //$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);

                $oDataset2->next();

                $aRow2 = $oDataset2->getRow();

                $bActiveGroup = $aRow2[0];

                if ($bActiveGroup == 1) {

                    $aTaskUser[] = $aRow;

                }

                $oDataset->next();

            }

            return $aTaskUser;

        } catch (Exception $oError) {

            throw ($oError);

        }

    }
Exemplo n.º 7
0
 function getAllUsersFromAnyTask($sTasUid)
 {
     $users = array();
     $c = new Criteria('workflow');
     $c->clearSelectColumns();
     $c->addSelectColumn(TaskUserPeer::USR_UID);
     $c->addSelectColumn(TaskUserPeer::TU_RELATION);
     $c->add(TaskUserPeer::TAS_UID, $sTasUid);
     $c->add(TaskUserPeer::TU_TYPE, 1);
     $rs = TaskUserPeer::DoSelectRs($c);
     $rs->setFetchmode(ResultSet::FETCHMODE_ASSOC);
     $rs->next();
     $row = $rs->getRow();
     while (is_array($row)) {
         if ($row['TU_RELATION'] == '2') {
             $cGrp = new Criteria('workflow');
             $cGrp->add(GroupwfPeer::GRP_STATUS, 'ACTIVE');
             $cGrp->add(GroupUserPeer::GRP_UID, $row['USR_UID']);
             $cGrp->addJoin(GroupUserPeer::GRP_UID, GroupwfPeer::GRP_UID, Criteria::LEFT_JOIN);
             $cGrp->addJoin(GroupUserPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN);
             $cGrp->add(UsersPeer::USR_STATUS, 'ACTIVE');
             $rsGrp = GroupUserPeer::DoSelectRs($cGrp);
             $rsGrp->setFetchmode(ResultSet::FETCHMODE_ASSOC);
             $rsGrp->next();
             $rowGrp = $rsGrp->getRow();
             while (is_array($rowGrp)) {
                 $users[$rowGrp['USR_UID']] = $rowGrp['USR_UID'];
                 $rsGrp->next();
                 $rowGrp = $rsGrp->getRow();
             }
         } else {
             //filter to users that is in vacation or has an inactive estatus, and others
             $oUser = UsersPeer::retrieveByPK($row['USR_UID']);
             if ($oUser->getUsrStatus() == 'ACTIVE') {
                 $users[$row['USR_UID']] = $row['USR_UID'];
             } else {
                 if ($oUser->getUsrStatus() == 'VACATION') {
                     //this a litle hook for this issue,...
                     //TODO if the user in getUsrReplacedBy() is not assignet to the same task,. will have problems,....
                     $UsrReplace = $oUser->getUsrReplacedBy();
                     if (trim($UsrReplace) != '') {
                         //$users[$UsrReplace] = $UsrReplace;
                     }
                 }
             }
         }
         $rs->next();
         $row = $rs->getRow();
     }
     //to do: different types of sort
     sort($users);
     return $users;
 }
Exemplo n.º 8
0
 public function getExtTaskUsersAdHocCriteria($start, $limit, $sTaskUID = '', $iType = 1)
 {
     try {
         $aUsers = array();
         $aUsers[] = array('LABEL' => 'char', 'TAS_UID' => 'char', 'USR_UID' => 'char', 'TU_TYPE' => 'integer', 'TU_RELATION' => 'integer');
         $sDelimiter = DBAdapter::getStringDelimiter();
         $oCriteria = new Criteria('workflow');
         $oCriteria->addAsColumn('GRP_TITLE', 'C.CON_VALUE');
         $oCriteria->addSelectColumn(TaskUserPeer::TAS_UID);
         $oCriteria->addSelectColumn(TaskUserPeer::USR_UID);
         $oCriteria->addSelectColumn(TaskUserPeer::TU_TYPE);
         $oCriteria->addSelectColumn(TaskUserPeer::TU_RELATION);
         $oCriteria->addAlias('C', 'CONTENT');
         $aConditions = array();
         $aConditions[] = array(TaskUserPeer::USR_UID, 'C.CON_ID');
         $aConditions[] = array('C.CON_CATEGORY', $sDelimiter . 'GRP_TITLE' . $sDelimiter);
         $aConditions[] = array('C.CON_LANG', $sDelimiter . SYS_LANG . $sDelimiter);
         $oCriteria->addJoinMC($aConditions, Criteria::LEFT_JOIN);
         $oCriteria->add(TaskUserPeer::TAS_UID, $sTaskUID);
         $oCriteria->add(TaskUserPeer::TU_TYPE, $iType);
         $oCriteria->add(TaskUserPeer::TU_RELATION, 2);
         $this->tmpCriteria = clone $oCriteria;
         if ($start != '') {
             $oCriteria->setOffset($start);
         }
         if ($limit != '') {
             $oCriteria->setLimit($limit);
         }
         $oDataset = TaskUserPeer::doSelectRS($oCriteria);
         $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
         $oDataset->next();
         $c = 0;
         while ($aRow = $oDataset->getRow()) {
             $c++;
             $oGroup = new Groupwf();
             $aFields = $oGroup->load($aRow['USR_UID']);
             if ($aFields['GRP_STATUS'] == 'ACTIVE') {
                 $oCriteria = new Criteria('workflow');
                 $oCriteria->addSelectColumn('COUNT(*) AS MEMBERS_NUMBER');
                 $oCriteria->add(GroupUserPeer::GRP_UID, $aRow['USR_UID']);
                 $oDataset2 = GroupUserPeer::doSelectRS($oCriteria);
                 $oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
                 $oDataset2->next();
                 $aRow2 = $oDataset2->getRow();
             } else {
                 $aRow2['GROUP_INACTIVE'] = '<strong>(' . G::LoadTranslation('ID_GROUP_INACTIVE') . ')</strong>';
             }
             $aUsers[] = array('LABEL' => !isset($aRow2['GROUP_INACTIVE']) ? $aRow['GRP_TITLE'] . ' <a href="#" onclick="usersGroup(\'' . $aRow['USR_UID'] . '\', \'' . $c . '\');return false;"><font color="green"><strong>(' . $aRow2['MEMBERS_NUMBER'] . ' ' . ((int) $aRow2['MEMBERS_NUMBER'] == 1 ? G::LoadTranslation('ID_USER') : G::LoadTranslation('ID_USERS')) . ')</strong></font></a> <br /><div id="users' . $c . '" style="display: none"></div>' : $aRow['GRP_TITLE'] . ' ' . $aRow2['GROUP_INACTIVE'], 'TAS_UID' => $aRow['TAS_UID'], 'USR_UID' => $aRow['USR_UID'], 'TU_TYPE' => $aRow['TU_TYPE'], 'TU_RELATION' => $aRow['TU_RELATION']);
             $oDataset->next();
         }
         $oCriteria = new Criteria('workflow');
         $oCriteria->addSelectColumn(UsersPeer::USR_FIRSTNAME);
         $oCriteria->addSelectColumn(UsersPeer::USR_LASTNAME);
         $oCriteria->addSelectColumn(TaskUserPeer::TAS_UID);
         $oCriteria->addSelectColumn(TaskUserPeer::USR_UID);
         $oCriteria->addSelectColumn(TaskUserPeer::TU_TYPE);
         $oCriteria->addSelectColumn(TaskUserPeer::TU_RELATION);
         $oCriteria->addJoin(TaskUserPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN);
         $oCriteria->add(TaskUserPeer::TAS_UID, $sTaskUID);
         $oCriteria->add(TaskUserPeer::TU_TYPE, $iType);
         $oCriteria->add(TaskUserPeer::TU_RELATION, 1);
         $oDataset = TaskUserPeer::doSelectRS($oCriteria);
         $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
         $oDataset->next();
         while ($aRow = $oDataset->getRow()) {
             $aUsers[] = array('LABEL' => $aRow['USR_FIRSTNAME'] . ' ' . $aRow['USR_LASTNAME'], 'TAS_UID' => $aRow['TAS_UID'], 'USR_UID' => $aRow['USR_UID'], 'TU_TYPE' => $aRow['TU_TYPE'], 'TU_RELATION' => $aRow['TU_RELATION']);
             $oDataset->next();
         }
         global $_DBArray;
         $_DBArray = isset($_SESSION['_DBArray']) ? $_SESSION['_DBArray'] : '';
         $_DBArray['taskUsers'] = $aUsers;
         $_SESSION['_DBArray'] = $_DBArray;
         G::LoadClass('ArrayPeer');
         $oCriteria = new Criteria('dbarray');
         $oCriteria->setDBArrayTable('taskUsers');
         $oCriteria->addDescendingOrderByColumn(TaskUserPeer::TU_RELATION);
         $oCriteria->addAscendingOrderByColumn('LABEL');
         return $oCriteria;
     } catch (Exception $oError) {
         throw $oError;
     }
 }
Exemplo n.º 9
0
 /**
  * Checks if the user exists
  *
  * @param string $userName  Name
  * @param string $sTaskUID  Task
  *
  * return message
  */
 public function getUser($userName, $sTaskUID)
 {
     try {
         $sTASKS = $sTaskUID;
         $sWS_USER = trim($userName);
         $oCriteria = new \Criteria('workflow');
         $oCriteria->addSelectColumn(\UsersPeer::USR_UID);
         $oCriteria->addSelectColumn(\TaskUserPeer::USR_UID);
         $oCriteria->addSelectColumn(\TaskUserPeer::TAS_UID);
         $oCriteria->addSelectColumn(\UsersPeer::USR_USERNAME);
         $oCriteria->addSelectColumn(\UsersPeer::USR_FIRSTNAME);
         $oCriteria->addSelectColumn(\UsersPeer::USR_LASTNAME);
         $oCriteria->addJoin(\TaskUserPeer::USR_UID, \UsersPeer::USR_UID, \Criteria::LEFT_JOIN);
         $oCriteria->add(\TaskUserPeer::TAS_UID, $sTASKS);
         $oCriteria->add(\UsersPeer::USR_USERNAME, $sWS_USER);
         $userIsAssigned = \TaskUserPeer::doCount($oCriteria);
         if ($userIsAssigned < 1) {
             $oCriteria = new \Criteria('workflow');
             $oCriteria->addSelectColumn(\UsersPeer::USR_UID);
             $oCriteria->addJoin(\UsersPeer::USR_UID, \GroupUserPeer::USR_UID, \Criteria::LEFT_JOIN);
             $oCriteria->addJoin(\GroupUserPeer::GRP_UID, \TaskUserPeer::USR_UID, \Criteria::LEFT_JOIN);
             $oCriteria->add(\TaskUserPeer::TAS_UID, $sTASKS);
             $oCriteria->add(\UsersPeer::USR_USERNAME, $sWS_USER);
             $userIsAssigned = \GroupUserPeer::doCount($oCriteria);
             if (!($userIsAssigned >= 1)) {
                 throw new \Exception(\G::LoadTranslation("ID_USER_DOES_NOT_HAVE_ACTIVITY_ASSIGNED", array($sWS_USER, $sTASKS)));
             }
         }
         $oDataset = \TaskUserPeer::doSelectRS($oCriteria);
         $oDataset->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
         $oDataset->next();
         while ($aRow = $oDataset->getRow()) {
             $messageCode = $aRow['USR_UID'];
             $oDataset->next();
         }
         return $messageCode;
     } catch (\Exception $e) {
         throw $e;
     }
 }
Exemplo n.º 10
0
 public function removeUser($user)
 {
     if (!$this->isUser($user)) {
         return true;
     }
     $taskuser = TaskUserPeer::retrieveByTaskUser($this->getId(), $user->getUserId());
     try {
         $taskuser->delete();
     } catch (Exception $e) {
         return false;
     }
     return true;
 }
Exemplo n.º 11
0
 public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
 {
     $keys = TaskUserPeer::getFieldNames($keyType);
     if (array_key_exists($keys[0], $arr)) {
         $this->setId($arr[$keys[0]]);
     }
     if (array_key_exists($keys[1], $arr)) {
         $this->setUuid($arr[$keys[1]]);
     }
     if (array_key_exists($keys[2], $arr)) {
         $this->setUserId($arr[$keys[2]]);
     }
     if (array_key_exists($keys[3], $arr)) {
         $this->setTaskId($arr[$keys[3]]);
     }
     if (array_key_exists($keys[4], $arr)) {
         $this->setDeletedAt($arr[$keys[4]]);
     }
     if (array_key_exists($keys[5], $arr)) {
         $this->setCreatedAt($arr[$keys[5]]);
     }
 }
Exemplo n.º 12
0
 public static function retrieveByPKs($pks, $con = null)
 {
     if ($con === null) {
         $con = Propel::getConnection(self::DATABASE_NAME);
     }
     $objs = null;
     if (empty($pks)) {
         $objs = array();
     } else {
         $criteria = new Criteria();
         $criteria->add(TaskUserPeer::ID, $pks, Criteria::IN);
         $objs = TaskUserPeer::doSelect($criteria, $con);
     }
     return $objs;
 }
Exemplo n.º 13
0
 /**
  * Update WebEntry-Event
  *
  * @param string $webEntryEventUid Unique id of WebEntry-Event
  * @param string $userUidUpdater   Unique id of updater User
  * @param array  $arrayData        Data
  *
  * return array Return data of the WebEntry-Event updated
  */
 public function update($webEntryEventUid, $userUidUpdater, array $arrayData)
 {
     try {
         //Verify data
         $process = new \ProcessMaker\BusinessModel\Process();
         $validator = new \ProcessMaker\BusinessModel\Validator();
         $validator->throwExceptionIfDataIsNotArray($arrayData, "\$arrayData");
         $validator->throwExceptionIfDataIsEmpty($arrayData, "\$arrayData");
         //Set data
         $arrayData = array_change_key_case($arrayData, CASE_UPPER);
         $arrayDataBackup = $arrayData;
         unset($arrayData["WEE_UID"]);
         unset($arrayData["PRJ_UID"]);
         unset($arrayData["WEE_WE_UID"]);
         unset($arrayData["WEE_WE_TAS_UID"]);
         //Set variables
         $arrayWebEntryEventData = $this->getWebEntryEvent($webEntryEventUid, true);
         $arrayFinalData = array_merge($arrayWebEntryEventData, $arrayData);
         //Verify data
         $this->throwExceptionIfNotExistsWebEntryEvent($webEntryEventUid, $this->arrayFieldNameForException["webEntryEventUid"]);
         $this->throwExceptionIfDataIsInvalid($webEntryEventUid, $arrayWebEntryEventData["PRJ_UID"], $arrayData);
         //Update
         $cnn = \Propel::getConnection("workflow");
         $this->webEntryEventWebEntryUid = "";
         $this->webEntryEventWebEntryTaskUid = "";
         try {
             //WebEntry
             $option = "UPDATE";
             if (isset($arrayData["WEE_STATUS"])) {
                 if ($arrayData["WEE_STATUS"] == "ENABLED") {
                     if ($arrayWebEntryEventData["WEE_STATUS"] == "DISABLED") {
                         $option = "INSERT";
                     }
                 } else {
                     if ($arrayWebEntryEventData["WEE_STATUS"] == "ENABLED") {
                         $option = "DELETE";
                     }
                 }
             }
             switch ($option) {
                 case "INSERT":
                     $this->createWebEntry($arrayFinalData["PRJ_UID"], $arrayFinalData["EVN_UID"], $arrayFinalData["ACT_UID"], $arrayFinalData["DYN_UID"], $arrayFinalData["USR_UID"], $arrayFinalData["WEE_TITLE"], $arrayFinalData["WEE_DESCRIPTION"], $userUidUpdater);
                     $arrayData["WEE_WE_UID"] = $this->webEntryEventWebEntryUid;
                     $arrayData["WEE_WE_TAS_UID"] = $this->webEntryEventWebEntryTaskUid;
                     break;
                 case "UPDATE":
                     if ($arrayWebEntryEventData["WEE_WE_UID"] != "") {
                         $task = new \Tasks();
                         //Task - Step
                         if (isset($arrayData["DYN_UID"]) && $arrayData["DYN_UID"] != $arrayWebEntryEventData["DYN_UID"]) {
                             //Delete
                             $step = new \Step();
                             $criteria = new \Criteria("workflow");
                             $criteria->add(\StepPeer::TAS_UID, $arrayWebEntryEventData["WEE_WE_TAS_UID"]);
                             $rsCriteria = \StepPeer::doSelectRS($criteria);
                             $rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
                             while ($rsCriteria->next()) {
                                 $row = $rsCriteria->getRow();
                                 $result = $step->remove($row["STEP_UID"]);
                             }
                             //Add
                             $step = new \Step();
                             $stepUid = $step->create(array("PRO_UID" => $arrayWebEntryEventData["PRJ_UID"], "TAS_UID" => $arrayWebEntryEventData["WEE_WE_TAS_UID"]));
                             $result = $step->update(array("STEP_UID" => $stepUid, "STEP_TYPE_OBJ" => "DYNAFORM", "STEP_UID_OBJ" => $arrayData["DYN_UID"], "STEP_POSITION" => 1, "STEP_MODE" => "EDIT"));
                         }
                         //Task - User
                         if (isset($arrayData["USR_UID"]) && $arrayData["USR_UID"] != $arrayWebEntryEventData["USR_UID"]) {
                             //Unassign
                             $taskUser = new \TaskUser();
                             $criteria = new \Criteria("workflow");
                             $criteria->add(\TaskUserPeer::TAS_UID, $arrayWebEntryEventData["WEE_WE_TAS_UID"]);
                             $rsCriteria = \TaskUserPeer::doSelectRS($criteria);
                             $rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
                             while ($rsCriteria->next()) {
                                 $row = $rsCriteria->getRow();
                                 $result = $taskUser->remove($row["TAS_UID"], $row["USR_UID"], $row["TU_TYPE"], $row["TU_RELATION"]);
                             }
                             //Assign
                             $result = $task->assignUser($arrayWebEntryEventData["WEE_WE_TAS_UID"], $arrayData["USR_UID"], 1);
                         }
                         //Route
                         if (isset($arrayData["ACT_UID"]) && $arrayData["ACT_UID"] != $arrayWebEntryEventData["ACT_UID"]) {
                             //Delete
                             $result = $task->deleteAllRoutesOfTask($arrayWebEntryEventData["PRJ_UID"], $arrayWebEntryEventData["WEE_WE_TAS_UID"], true);
                             //Add
                             $workflow = \ProcessMaker\Project\Workflow::load($arrayWebEntryEventData["PRJ_UID"]);
                             $result = $workflow->addRoute($arrayWebEntryEventData["WEE_WE_TAS_UID"], $arrayData["ACT_UID"], "SEQUENTIAL");
                         }
                         //WebEntry
                         $arrayDataAux = array();
                         if (isset($arrayData["DYN_UID"])) {
                             $arrayDataAux["DYN_UID"] = $arrayData["DYN_UID"];
                         }
                         if (isset($arrayData["USR_UID"])) {
                             $arrayDataAux["USR_UID"] = $arrayData["USR_UID"];
                         }
                         if (isset($arrayData["WEE_TITLE"])) {
                             $arrayDataAux["WE_TITLE"] = $arrayData["WEE_TITLE"];
                         }
                         if (isset($arrayData["WEE_DESCRIPTION"])) {
                             $arrayDataAux["WE_DESCRIPTION"] = $arrayData["WEE_DESCRIPTION"];
                         }
                         if (count($arrayDataAux) > 0) {
                             $arrayDataAux = $this->webEntry->update($arrayWebEntryEventData["WEE_WE_UID"], $userUidUpdater, $arrayDataAux);
                         }
                     }
                     break;
                 case "DELETE":
                     $this->deleteWebEntry($arrayWebEntryEventData["WEE_WE_UID"], $arrayWebEntryEventData["WEE_WE_TAS_UID"]);
                     $arrayData["WEE_WE_UID"] = "";
                     $arrayData["WEE_WE_TAS_UID"] = "";
                     break;
             }
             //WebEntry-Event
             $webEntryEvent = \WebEntryEventPeer::retrieveByPK($webEntryEventUid);
             $webEntryEvent->fromArray($arrayData, \BasePeer::TYPE_FIELDNAME);
             if ($webEntryEvent->validate()) {
                 $cnn->begin();
                 $result = $webEntryEvent->save();
                 $cnn->commit();
                 //Set WEE_TITLE
                 if (isset($arrayData["WEE_TITLE"])) {
                     $result = \Content::addContent("WEE_TITLE", "", $webEntryEventUid, SYS_LANG, $arrayData["WEE_TITLE"]);
                 }
                 //Set WEE_DESCRIPTION
                 if (isset($arrayData["WEE_DESCRIPTION"])) {
                     $result = \Content::addContent("WEE_DESCRIPTION", "", $webEntryEventUid, SYS_LANG, $arrayData["WEE_DESCRIPTION"]);
                 }
                 //Return
                 $arrayData = $arrayDataBackup;
                 if (!$this->formatFieldNameInUppercase) {
                     $arrayData = array_change_key_case($arrayData, CASE_LOWER);
                 }
                 return $arrayData;
             } else {
                 $msg = "";
                 foreach ($webEntryEvent->getValidationFailures() as $validationFailure) {
                     $msg = $msg . ($msg != "" ? "\n" : "") . $validationFailure->getMessage();
                 }
                 throw new \Exception(\G::LoadTranslation("ID_REGISTRY_CANNOT_BE_UPDATED") . ($msg != "" ? "\n" . $msg : ""));
             }
         } catch (\Exception $e) {
             $cnn->rollback();
             $this->deleteWebEntry($this->webEntryEventWebEntryUid, $this->webEntryEventWebEntryTaskUid);
             throw $e;
         }
     } catch (\Exception $e) {
         throw $e;
     }
 }
Exemplo n.º 14
0
 /**
  * Verify if the User is assigned to Task
  *
  * @param string $userUid Unique id of User
  * @param string $taskUid Unique id of Task
  *
  * return bool Return true if the User is assigned to Task, false otherwise
  */
 public function userIsAssignedToTask($userUid, $taskUid)
 {
     try {
         $criteria = new \Criteria("workflow");
         $criteria->addSelectColumn(\TaskUserPeer::TAS_UID);
         $criteria->add(\TaskUserPeer::TAS_UID, $taskUid, \Criteria::EQUAL);
         $criteria->add(\TaskUserPeer::USR_UID, $userUid, \Criteria::EQUAL);
         $rsCriteria = \TaskUserPeer::doSelectRS($criteria);
         //If the User is not assigned directly, maybe a have the Task a Group with the User
         if (!$rsCriteria->next()) {
             $criteria = new \Criteria("workflow");
             $criteria->addSelectColumn(\UsersPeer::USR_UID);
             $criteria->addJoin(\UsersPeer::USR_UID, \GroupUserPeer::USR_UID, \Criteria::LEFT_JOIN);
             $criteria->addJoin(\GroupUserPeer::GRP_UID, \TaskUserPeer::USR_UID, \Criteria::LEFT_JOIN);
             $criteria->add(\TaskUserPeer::TAS_UID, $taskUid, \Criteria::EQUAL);
             $criteria->add(\UsersPeer::USR_UID, $userUid, \Criteria::EQUAL);
             $rsCriteria = \UsersPeer::doSelectRS($criteria);
             if (!$rsCriteria->next()) {
                 return false;
             }
         }
         return true;
     } catch (\Exception $e) {
         throw $e;
     }
 }
Exemplo n.º 15
0
 /**
  * Get All users assigned to task
  *
  * @param string $TAS_UID
  * @return array users info
  *
  */
 public function getAllUsersTask($TAS_UID)
 {
     require_once 'classes/model/Users.php';
     $groupsTask = array();
     $usersTask = array();
     //getting task's users
     $criteria = new Criteria('workflow');
     $criteria->addSelectColumn(UsersPeer::USR_FIRSTNAME);
     $criteria->addSelectColumn(UsersPeer::USR_LASTNAME);
     $criteria->addSelectColumn(UsersPeer::USR_USERNAME);
     $criteria->addSelectColumn(TaskUserPeer::TAS_UID);
     $criteria->addSelectColumn(TaskUserPeer::USR_UID);
     $criteria->addSelectColumn(TaskUserPeer::TU_TYPE);
     $criteria->addSelectColumn(TaskUserPeer::TU_RELATION);
     $criteria->addJoin(TaskUserPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN);
     $criteria->add(TaskUserPeer::TAS_UID, $TAS_UID);
     $dataset = TaskUserPeer::doSelectRS($criteria);
     $dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
     while ($dataset->next()) {
         $row = $dataset->getRow();
         if ($row["TU_RELATION"] == 2) {
             $gpr = new GroupUser();
             $array = $gpr->getAllGroupUser($row["USR_UID"]);
             foreach ($array as $urow) {
                 $usersTask[] = $urow;
             }
         } else {
             $usersTask[] = $row;
         }
     }
     return $usersTask;
 }
Exemplo n.º 16
0
 /**
 * Retrieve object using using composite pkey values.
 * @param string $tas_uid
   @param string $usr_uid
   @param int $tu_type
   @param int $tu_relation
   
 * @param      Connection $con
 * @return     TaskUser
 */
 public static function retrieveByPK($tas_uid, $usr_uid, $tu_type, $tu_relation, $con = null)
 {
     if ($con === null) {
         $con = Propel::getConnection(self::DATABASE_NAME);
     }
     $criteria = new Criteria();
     $criteria->add(TaskUserPeer::TAS_UID, $tas_uid);
     $criteria->add(TaskUserPeer::USR_UID, $usr_uid);
     $criteria->add(TaskUserPeer::TU_TYPE, $tu_type);
     $criteria->add(TaskUserPeer::TU_RELATION, $tu_relation);
     $v = TaskUserPeer::doSelect($criteria, $con);
     return !empty($v) ? $v[0] : null;
 }
Exemplo n.º 17
0
 $result = $pmDrive->uploadFile('application/' . $sExtension, $arrayFileTmpName[$i], $arrayFileName[$i], $appData['APP_DRIVE_FOLDER_UID']);
 $oAppDocument->setDriveDownload('ATTACHED', $result->webContentLink);
 $fileIdDrive = $result->id;
 $aFields['DOC_VERSION'] = $iDocVersion;
 $aFields['APP_DOC_UID'] = $sAppDocUid;
 $oAppDocument->update($aFields);
 //add permissions
 $criteria = new Criteria('workflow');
 $criteria->addSelectColumn(ApplicationPeer::PRO_UID);
 $criteria->addSelectColumn(TaskUserPeer::TAS_UID);
 $criteria->addSelectColumn(TaskUserPeer::USR_UID);
 $criteria->addSelectColumn(TaskUserPeer::TU_RELATION);
 $criteria->add(ApplicationPeer::APP_UID, $_SESSION['APPLICATION']);
 $criteria->addJoin(ApplicationPeer::PRO_UID, TaskPeer::PRO_UID, Criteria::LEFT_JOIN);
 $criteria->addJoin(TaskPeer::TAS_UID, TaskUserPeer::TAS_UID, Criteria::LEFT_JOIN);
 $dataset = TaskUserPeer::doSelectRs($criteria);
 $dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
 $userPermission = array();
 $case = new Cases();
 while ($dataset->next()) {
     $row = $dataset->getRow();
     if ($row['TU_RELATION'] == 1) {
         //users
         $dataUser = $user->load($row['USR_UID']);
         if (array_search($dataUser['USR_EMAIL'], $userPermission) === false) {
             $userPermission[] = $dataUser['USR_EMAIL'];
         }
     } else {
         //Groups
         $criteria = new Criteria('workflow');
         $criteria->addSelectColumn(UsersPeer::USR_EMAIL);
Exemplo n.º 18
0
 public function getTaskUsersJoinTask($criteria = null, $con = null)
 {
     include_once 'lib/model/om/BaseTaskUserPeer.php';
     if ($criteria === null) {
         $criteria = new Criteria();
     } elseif ($criteria instanceof Criteria) {
         $criteria = clone $criteria;
     }
     if ($this->collTaskUsers === null) {
         if ($this->isNew()) {
             $this->collTaskUsers = array();
         } else {
             $criteria->add(TaskUserPeer::USER_ID, $this->getId());
             $this->collTaskUsers = TaskUserPeer::doSelectJoinTask($criteria, $con);
         }
     } else {
         $criteria->add(TaskUserPeer::USER_ID, $this->getId());
         if (!isset($this->lastTaskUserCriteria) || !$this->lastTaskUserCriteria->equals($criteria)) {
             $this->collTaskUsers = TaskUserPeer::doSelectJoinTask($criteria, $con);
         }
     }
     $this->lastTaskUserCriteria = $criteria;
     return $this->collTaskUsers;
 }
Exemplo n.º 19
0
 /**
  * Populates the object using an array.
  *
  * This is particularly useful when populating an object from one of the
  * request arrays (e.g. $_POST).  This method goes through the column
  * names, checking to see whether a matching key exists in populated
  * array. If so the setByName() method is called for that column.
  *
  * You can specify the key type of the array by additionally passing one
  * of the class type constants TYPE_PHPNAME, TYPE_COLNAME, TYPE_FIELDNAME,
  * TYPE_NUM. The default key type is the column's phpname (e.g. 'authorId')
  *
  * @param      array  $arr     An array to populate the object from.
  * @param      string $keyType The type of keys the array uses.
  * @return     void
  */
 public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
 {
     $keys = TaskUserPeer::getFieldNames($keyType);
     if (array_key_exists($keys[0], $arr)) {
         $this->setTasUid($arr[$keys[0]]);
     }
     if (array_key_exists($keys[1], $arr)) {
         $this->setUsrUid($arr[$keys[1]]);
     }
     if (array_key_exists($keys[2], $arr)) {
         $this->setTuType($arr[$keys[2]]);
     }
     if (array_key_exists($keys[3], $arr)) {
         $this->setTuRelation($arr[$keys[3]]);
     }
 }
 */
if (!class_exists('GroupUser')) {
    G::LoadClass('GroupUser');
}
// if the user has been authenticated, then check if has the rights or
// permissions to create the webentry
if ($result->status_code == 0) {
    $oCriteria = new Criteria('workflow');
    $oCriteria->addSelectColumn(UsersPeer::USR_UID);
    $oCriteria->addSelectColumn(TaskUserPeer::USR_UID);
    $oCriteria->addSelectColumn(TaskUserPeer::TAS_UID);
    $oCriteria->addJoin(TaskUserPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN);
    $oCriteria->add(TaskUserPeer::TAS_UID, $sTASKS);
    $oCriteria->add(UsersPeer::USR_USERNAME, $sWS_USER);
    //$oCriteria->add(TaskUserPeer::TU_RELATION,1);
    $userIsAssigned = TaskUserPeer::doCount($oCriteria);
    // if the user is not assigned directly, maybe a have the task a group with the user
    if ($userIsAssigned < 1) {
        $oCriteria = new Criteria('workflow');
        $oCriteria->addSelectColumn(UsersPeer::USR_UID);
        $oCriteria->addJoin(UsersPeer::USR_UID, GroupUserPeer::USR_UID, Criteria::LEFT_JOIN);
        $oCriteria->addJoin(GroupUserPeer::GRP_UID, TaskUserPeer::USR_UID, Criteria::LEFT_JOIN);
        $oCriteria->add(TaskUserPeer::TAS_UID, $sTASKS);
        $oCriteria->add(UsersPeer::USR_USERNAME, $sWS_USER);
        $userIsAssigned = GroupUserPeer::doCount($oCriteria);
        if (!($userIsAssigned >= 1)) {
            $messageCode = "The User \"" . $sWS_USER . "\" doesn't have the task \"" . $sTASKS_SEL . "\" assigned";
        }
    }
} else {
    $messageCode = $result->message;
Exemplo n.º 21
0
            G::SendTemporalMessage('ID_USER_HAVENT_RIGHTS_PAGE', 'error', 'labels');
            G::header('location: ../login/login');
            die;
            break;
        case -2:
            G::SendTemporalMessage('ID_USER_HAVENT_RIGHTS_SYSTEM', 'error', 'labels');
            G::header('location: ../login/login');
            die;
            break;
        default:
            G::SendTemporalMessage('ID_USER_HAVENT_RIGHTS_PAGE', 'error', 'labels');
            G::header('location: ../login/login');
            die;
            break;
    }
}
if (($RBAC_Response = $RBAC->userCanAccess("PM_USERS")) != 1) {
    return $RBAC_Response;
}
G::LoadClass('groups');
$group = new Groupwf();
if (!isset($_POST['GRP_UID'])) {
    return;
}
$group->remove(urldecode($_POST['GRP_UID']));
require_once 'classes/model/TaskUser.php';
$oProcess = new TaskUser();
$oCriteria = new Criteria('workflow');
$oCriteria->add(TaskUserPeer::USR_UID, $_POST['GRP_UID']);
TaskUserPeer::doDelete($oCriteria);
Exemplo n.º 22
0
            $oGroup->removeUserOfGroup($GRP_UID, $USR_UID);
        }
        break;
    case 'updatePageSize':
        G::LoadClass('configuration');
        $c = new Configurations();
        $arr['pageSize'] = $_REQUEST['size'];
        $arr['dateSave'] = date('Y-m-d H:i:s');
        $config = array();
        $config[] = $arr;
        $c->aConfig = $config;
        $c->saveConfig('groupList', 'pageSize', '', $_SESSION['USER_LOGGED']);
        echo '{success: true}';
        break;
    case "verifyIfAssigned":
        $groupUid = $_POST["groupUid"];
        $message = "OK";
        $criteria = new Criteria("workflow");
        $criteria->addSelectColumn(TaskUserPeer::TAS_UID);
        $criteria->add(TaskUserPeer::USR_UID, $groupUid, Criteria::EQUAL);
        $criteria->add(TaskUserPeer::TU_RELATION, "2", Criteria::EQUAL);
        $rsCriteria = TaskUserPeer::doSelectRS($criteria);
        $rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC);
        if ($rsCriteria->next()) {
            $message = "ERROR";
        }
        $response = array();
        $response["result"] = $message;
        echo G::json_encode($response);
        break;
}
<?php

//$oUserId = '2963666854afbb1cea372c4011254883';
$oUserId = $_POST['USR_UID'];
$process = isset($_POST['PRO_UID']) ? $_POST['PRO_UID'] : $_SESSION['PROCESS'];
//echo '<select style="width: 300px;" readOnly name="form[PRO_UID]" id="form[PRO_UID]" class="module_app_input___gray" required="1" onChange="loadTasksDropdown(this.value,\''.$oUserId.'\');">';
require_once "classes/model/TaskPeer.php";
require_once "classes/model/ProcessPeer.php";
require_once "classes/model/TaskUserPeer.php";
G::LoadClass('Content');
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn(ProcessPeer::PRO_UID);
$oCriteria->setDistinct();
$oCriteria->addSelectColumn(ContentPeer::CON_VALUE);
$oCriteria->addJoin(ProcessPeer::PRO_UID, TaskPeer::PRO_UID, Criteria::LEFT_JOIN);
$oCriteria->addJoin(ProcessPeer::PRO_UID, ContentPeer::CON_ID, Criteria::LEFT_JOIN);
$oCriteria->addJoin(TaskPeer::TAS_UID, TaskUserPeer::TAS_UID, Criteria::LEFT_JOIN);
$oCriteria->add(TaskUserPeer::USR_UID, $oUserId);
$oCriteria->add(TaskPeer::TAS_START, 'true');
$oCriteria->add(ContentPeer::CON_CATEGORY, 'PRO_TITLE');
$oCriteria->add(ContentPeer::CON_LANG, SYS_LANG);
$oCriteria->addAnd(ProcessPeer::PRO_UID, $process);
$resultSet = TaskUserPeer::doSelectRS($oCriteria);
while ($resultSet->next()) {
    $row = $resultSet->getRow();
    echo $row[1];
    echo "<input name=\"form[PRO_UID]\" id=\"form[PRO_UID]\" type=\"hidden\" value=\"" . $row[0] . "\"></input>";
    //var_dump($row);
}
//echo "</select>";
Exemplo n.º 24
0
 /**
  * Get data of total Tasks by Group
  *
  * @param string $groupUid Unique id of Group
  *
  * return array Return an array with data of total Tasks by Group
  */
 public function getTotalTasksByGroup($groupUid = "")
 {
     try {
         $arrayData = array();
         //Verif data
         if ($groupUid != "") {
             $this->throwExceptionIfNotExistsGroup($groupUid, $this->arrayFieldNameForException["groupUid"]);
         }
         //Get data
         $criteria = new \Criteria("workflow");
         $criteria->addAsColumn("GRP_UID", \TaskUserPeer::USR_UID);
         $criteria->addAsColumn("NUM_REC", "COUNT(" . \TaskUserPeer::USR_UID . ")");
         if ($groupUid != "") {
             $criteria->add(\TaskUserPeer::USR_UID, $groupUid, \Criteria::EQUAL);
         }
         $criteria->add(\TaskUserPeer::TU_TYPE, 1, \Criteria::EQUAL);
         $criteria->add(\TaskUserPeer::TU_RELATION, 2, \Criteria::EQUAL);
         $criteria->addGroupByColumn(\TaskUserPeer::USR_UID);
         $rsCriteria = \TaskUserPeer::doSelectRS($criteria);
         $rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
         while ($rsCriteria->next()) {
             $row = $rsCriteria->getRow();
             $arrayData[$row["GRP_UID"]] = (int) $row["NUM_REC"];
         }
         //Return
         return $arrayData;
     } catch (\Exception $e) {
         throw $e;
     }
 }
Exemplo n.º 25
0
 /**
  * Return a list of adhoc assignees of an activity
  *
  * @param string $sProcessUID {@min 32} {@max 32}
  * @param string $sTaskUID {@min 32} {@max 32}
  * @param string $filter
  * @param int    $start
  * @param int    $limit
  * @param string $type
  *
  * return array
  *
  * @access public
  */
 public function getTaskAdhocAssigneesAll($sProcessUID, $sTaskUID, $filter, $start, $limit, $type)
 {
     try {
         Validator::proUid($sProcessUID, '$prj_uid');
         $this->validateActUid($sTaskUID);
         $aUsers = array();
         $oTasks = new \Tasks();
         $aAux = $oTasks->getGroupsOfTask($sTaskUID, 2);
         $aGroupUids = array();
         foreach ($aAux as $aGroup) {
             $aGroupUids[] = $aGroup['GRP_UID'];
         }
         foreach ($aGroupUids as $results) {
             $oCriteria = new \Criteria('workflow');
             $oCriteria->addSelectColumn('USR_UID');
             $oCriteria->add(\GroupUserPeer::GRP_UID, $results);
             $oGroupDataset = \GroupUserPeer::doSelectRS($oCriteria);
             $oGroupDataset->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
             while ($oGroupDataset->next()) {
                 $aGroupRow = $oGroupDataset->getRow();
                 $oGroupCriteria = new \Criteria('workflow');
                 $oGroupCriteria->addSelectColumn(\UsersPeer::USR_UID);
                 $oGroupCriteria->addSelectColumn(\UsersPeer::USR_FIRSTNAME);
                 $oGroupCriteria->addSelectColumn(\UsersPeer::USR_LASTNAME);
                 $oGroupCriteria->addSelectColumn(\UsersPeer::USR_USERNAME);
                 if ($filter != '') {
                     $oGroupCriteria->add($oGroupCriteria->getNewCriterion(\UsersPeer::USR_USERNAME, "%{$filter}%", \Criteria::LIKE)->addOr($oGroupCriteria->getNewCriterion(\UsersPeer::USR_FIRSTNAME, "%{$filter}%", \Criteria::LIKE))->addOr($oGroupCriteria->getNewCriterion(\UsersPeer::USR_LASTNAME, "%{$filter}%", \Criteria::LIKE)));
                 }
                 $oGroupCriteria->add(\UsersPeer::USR_UID, $aGroupRow["USR_UID"]);
                 $oUserDataset = \UsersPeer::doSelectRS($oGroupCriteria);
                 $oUserDataset->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
                 $oUserDataset->next();
                 while ($aUserRow = $oUserDataset->getRow()) {
                     $aUsers[] = array('aas_uid' => $aUserRow['USR_UID'], 'aas_name' => $aUserRow['USR_FIRSTNAME'], 'aas_lastname' => $aUserRow['USR_LASTNAME'], 'aas_username' => $aUserRow['USR_USERNAME'], 'aas_type' => "user");
                     $oUserDataset->next();
                 }
             }
         }
         $oCriteria = new \Criteria('workflow');
         $oCriteria->addSelectColumn(\UsersPeer::USR_UID);
         $oCriteria->addSelectColumn(\UsersPeer::USR_FIRSTNAME);
         $oCriteria->addSelectColumn(\UsersPeer::USR_LASTNAME);
         $oCriteria->addSelectColumn(\UsersPeer::USR_USERNAME);
         if ($filter != '') {
             $oCriteria->add($oCriteria->getNewCriterion(\UsersPeer::USR_USERNAME, "%{$filter}%", \Criteria::LIKE)->addOr($oCriteria->getNewCriterion(\UsersPeer::USR_FIRSTNAME, "%{$filter}%", \Criteria::LIKE))->addOr($oCriteria->getNewCriterion(\UsersPeer::USR_LASTNAME, "%{$filter}%", \Criteria::LIKE)));
         }
         $oCriteria->addJoin(\TaskUserPeer::USR_UID, \UsersPeer::USR_UID, \Criteria::LEFT_JOIN);
         $oCriteria->add(\TaskUserPeer::TAS_UID, $sTaskUID);
         $oCriteria->add(\TaskUserPeer::TU_TYPE, 2);
         $oCriteria->add(\TaskUserPeer::TU_RELATION, 1);
         $oDataset = \TaskUserPeer::doSelectRS($oCriteria);
         $oDataset->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
         $oDataset->next();
         while ($aRow = $oDataset->getRow()) {
             if ($type == '' || $type == 'user') {
                 $aUsers[] = array('aas_uid' => $aRow['USR_UID'], 'aas_name' => $aRow['USR_FIRSTNAME'], 'aas_lastname' => $aRow['USR_LASTNAME'], 'aas_username' => $aRow['USR_USERNAME'], 'aas_type' => "user");
             }
             $oDataset->next();
         }
         $aUsersGroups = array();
         $exclude = array("");
         for ($i = 0; $i <= count($aUsers) - 1; $i++) {
             if (!in_array(trim($aUsers[$i]["aas_uid"]), $exclude)) {
                 $aUsersGroups[] = $aUsers[$i];
                 $exclude[] = trim($aUsers[$i]["aas_uid"]);
             }
         }
         if ($start) {
             if ($start < 0) {
                 throw new \Exception(\G::LoadTranslation("ID_INVALID_START"));
             }
         } else {
             $start = 0;
         }
         if (isset($limit)) {
             if ($limit < 0) {
                 throw new \Exception(\G::LoadTranslation("ID_INVALID_LIMIT"));
             } else {
                 if ($limit == 0) {
                     return array();
                 }
             }
         } else {
             $limit = count($aUsersGroups) + 1;
         }
         $aUsersGroups = $this->arrayPagination($aUsersGroups, $start, $limit);
         return $aUsersGroups;
     } catch (\Exception $e) {
         throw $e;
     }
 }
Exemplo n.º 26
0
 function getUsersTask($TAS_UID, $TU_TYPE = 1)
 {
     require_once 'classes/model/Users.php';
     $groupsTask = array();
     $usersTask = array();
     //getting task's users
     $criteria = new Criteria('workflow');
     $criteria->addSelectColumn(UsersPeer::USR_FIRSTNAME);
     $criteria->addSelectColumn(UsersPeer::USR_LASTNAME);
     $criteria->addSelectColumn(UsersPeer::USR_USERNAME);
     $criteria->addSelectColumn(TaskUserPeer::TAS_UID);
     $criteria->addSelectColumn(TaskUserPeer::USR_UID);
     $criteria->addSelectColumn(TaskUserPeer::TU_TYPE);
     $criteria->addSelectColumn(TaskUserPeer::TU_RELATION);
     $criteria->addJoin(TaskUserPeer::USR_UID, UsersPeer::USR_UID, Criteria::LEFT_JOIN);
     $criteria->add(TaskUserPeer::TAS_UID, $TAS_UID);
     $criteria->add(TaskUserPeer::TU_TYPE, $TU_TYPE);
     $criteria->add(TaskUserPeer::TU_RELATION, 1);
     $dataset = TaskUserPeer::doSelectRS($criteria);
     $dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
     while ($dataset->next()) {
         $usersTask[] = $dataset->getRow();
     }
     //getting task's groups
     $delimiter = DBAdapter::getStringDelimiter();
     $criteria = new Criteria('workflow');
     $criteria->addAsColumn('GRP_TITLE', 'CONTENT.CON_VALUE');
     $criteria->addSelectColumn(TaskUserPeer::TAS_UID);
     $criteria->addSelectColumn(TaskUserPeer::USR_UID);
     $criteria->addSelectColumn(TaskUserPeer::TU_TYPE);
     $criteria->addSelectColumn(TaskUserPeer::TU_RELATION);
     $aConditions[] = array(TaskUserPeer::USR_UID, 'CONTENT.CON_ID');
     $aConditions[] = array('CONTENT.CON_CATEGORY', $delimiter . 'GRP_TITLE' . $delimiter);
     $aConditions[] = array('CONTENT.CON_LANG', $delimiter . SYS_LANG . $delimiter);
     $criteria->addJoinMC($aConditions, Criteria::LEFT_JOIN);
     $criteria->add(TaskUserPeer::TAS_UID, $TAS_UID);
     $criteria->add(TaskUserPeer::TU_TYPE, $TU_TYPE);
     $criteria->add(TaskUserPeer::TU_RELATION, 2);
     $dataset = TaskUserPeer::doSelectRS($criteria);
     $dataset = TaskUserPeer::doSelectRS($criteria);
     $dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
     while ($dataset->next()) {
         $usersTask[] = $dataset->getRow();
     }
     $result->data = $usersTask;
     $result->totalCount = sizeof($usersTask);
     return $result;
 }