Ejemplo n.º 1
0
 /**
  * Implementation for 'GET' method for Rest API
  *
  * @param  mixed $grpUid, $usrUid 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($grpUid = null, $usrUid = 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(GroupUserPeer::GRP_UID);
             $criteria->addSelectColumn(GroupUserPeer::USR_UID);
             $dataset = AppEventPeer::doSelectRS($criteria);
             $dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
             while ($dataset->next()) {
                 $result[] = $dataset->getRow();
             }
         } else {
             $record = GroupUserPeer::retrieveByPK($grpUid, $usrUid);
             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 GroupUser ({$paramValues})");
             }
         }
     } catch (RestException $e) {
         throw new RestException($e->getCode(), $e->getMessage());
     } catch (Exception $e) {
         throw new RestException(412, $e->getMessage());
     }
     return $result;
 }
Ejemplo n.º 2
0
 /**
  * Get all users assigned to Group
  *
  * @param string $gprUid
  * @return array $rows
  */
 public function getAllGroupUser($gprUid)
 {
     $oCriteria = new Criteria('workflow');
     $oCriteria->add(GroupUserPeer::GRP_UID, $gprUid);
     $oDataset = GroupUserPeer::doSelectRS($oCriteria);
     $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
     $rows = array();
     while ($oDataset->next()) {
         $row = $oDataset->getRow();
         $g = new Groupwf();
         try {
             $grpRow = $g->load($row['GRP_UID']);
             $row = array_merge($row, $grpRow);
             $rows[] = $row;
         } catch (Exception $e) {
             continue;
         }
     }
     return $rows;
 }
Ejemplo n.º 3
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;
 }
Ejemplo n.º 4
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;
     }
 }
Ejemplo n.º 5
0
 /**
  * Of to assign a group from a task
  * @param string $sTaskUID
  * @param string $sGroupUID
  * @param integer $iType
  * @return boolean
  */
 public function ofToAssignGroup($sTaskUID = '', $sGroupUID = '', $iType = 0)
 {
     try {
         $oTaskUser = new TaskUser();
         $oCriteria = new Criteria('workflow');
         $oCriteria->add(GroupUserPeer::GRP_UID, $sGroupUID);
         $oDataset = GroupUserPeer::doSelectRS($oCriteria);
         $oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
         $oDataset->next();
         while ($aGroupUser = $oDataset->getRow()) {
             $oCriteria = new Criteria('workflow');
             $oCriteria->add(TaskUserPeer::TAS_UID, $sTaskUID);
             $oCriteria->add(TaskUserPeer::USR_UID, $aGroupUser['USR_UID']);
             $oDataset2 = TaskUserPeer::doSelectRS($oCriteria);
             $oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
             $oDataset2->next();
             $aRow = $oDataset2->getRow();
             if (is_array($aRow)) {
                 $this->ofToAssignUser($sTaskUID, $aGroupUser['USR_UID'], $iType);
             }
             $oDataset->next();
         }
         return $oTaskUser->remove($sTaskUID, $sGroupUID, $iType, 2);
     } catch (Exception $oError) {
         throw $oError;
     }
 }
Ejemplo n.º 6
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;
 }
Ejemplo n.º 7
0
 /**
  * Get data of total Users by Group
  *
  * @param string $groupUid Unique id of Group
  *
  * return array Return an array with data of total Users by Group
  */
 public function getTotalUsersByGroup($groupUid = "")
 {
     try {
         $arrayData = array();
         //Verif data
         if ($groupUid != "") {
             $this->throwExceptionIfNotExistsGroup($groupUid, $this->arrayFieldNameForException["groupUid"]);
         }
         //Get data
         $criteria = new \Criteria("workflow");
         $criteria->addSelectColumn(\GroupUserPeer::GRP_UID);
         $criteria->addAsColumn("NUM_REC", "COUNT(" . \GroupUserPeer::GRP_UID . ")");
         $criteria->addJoin(\GroupUserPeer::USR_UID, \UsersPeer::USR_UID, \Criteria::INNER_JOIN);
         if ($groupUid != "") {
             $criteria->add(\GroupUserPeer::GRP_UID, $groupUid, \Criteria::EQUAL);
         }
         $criteria->add(\UsersPeer::USR_STATUS, "CLOSED", \Criteria::NOT_EQUAL);
         $criteria->addGroupByColumn(\GroupUserPeer::GRP_UID);
         $rsCriteria = \GroupUserPeer::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;
     }
 }
Ejemplo n.º 8
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;
     }
 }
Ejemplo n.º 9
0
 /**
 * Retrieve object using using composite pkey values.
 * @param string $grp_uid
   @param string $usr_uid
   
 * @param      Connection $con
 * @return     GroupUser
 */
 public static function retrieveByPK($grp_uid, $usr_uid, $con = null)
 {
     if ($con === null) {
         $con = Propel::getConnection(self::DATABASE_NAME);
     }
     $criteria = new Criteria();
     $criteria->add(GroupUserPeer::GRP_UID, $grp_uid);
     $criteria->add(GroupUserPeer::USR_UID, $usr_uid);
     $v = GroupUserPeer::doSelect($criteria, $con);
     return !empty($v) ? $v[0] : null;
 }
Ejemplo n.º 10
0
     //Delete permissions
     require_once 'classes/model/ObjectPermission.php';
     $criteria = new Criteria('workflow');
     $criteria->add(ObjectPermissionPeer::USR_UID, $_POST['GRP_UID']);
     ObjectPermissionPeer::doDelete($criteria);
     //Delete supervisors assignments
     require_once 'classes/model/ProcessUser.php';
     $criteria = new Criteria('workflow');
     $criteria->add(ProcessUserPeer::USR_UID, $_POST['GRP_UID']);
     $criteria->add(ProcessUserPeer::PU_TYPE, 'GROUP_SUPERVISOR');
     ProcessUserPeer::doDelete($criteria);
     //Delete group users
     require_once 'classes/model/GroupUser.php';
     $criteria = new Criteria('workflow');
     $criteria->add(GroupUserPeer::GRP_UID, $_POST['GRP_UID']);
     GroupUserPeer::doDelete($criteria);
     echo '{success: true}';
     break;
 case 'assignedMembers':
     require_once 'classes/model/Users.php';
     require_once 'classes/model/GroupUser.php';
     G::LoadClass('configuration');
     $co = new Configurations();
     $config = $co->getConfiguration('groupList', 'pageSize', '', $_SESSION['USER_LOGGED']);
     $env = $co->getConfiguration('ENVIRONMENT_SETTINGS', '');
     $limit_size = isset($config['pageSize']) ? $config['pageSize'] : 20;
     $start = isset($_REQUEST['start']) ? $_REQUEST['start'] : 0;
     $limit = isset($_REQUEST['limit']) ? $_REQUEST['limit'] : $limit_size;
     $filter = isset($_REQUEST['textFilter']) ? $_REQUEST['textFilter'] : '';
     $sGroupUID = $_REQUEST['gUID'];
     $aUsers = array();
Ejemplo n.º 11
0
 /**
   function executed by the cron
   this function will synchronize users from ldap/active directory to PM users tables
   @return void
 */
 public function executeCron($debug)
 {
     $rbac =& RBAC::getSingleton();
     if (is_null($rbac->authSourcesObj)) {
         $rbac->authSourcesObj = new AuthenticationSource();
     }
     $plugin = new ldapAdvanced();
     $plugin->sSystem = $rbac->sSystem;
     $plugin->setFrontEnd(true);
     $plugin->setDebug($debug);
     //Get all authsource for this plugin ( ldapAdvanced plugin, because other authsources are not needed )
     $arrayAuthenticationSource = $plugin->getAuthSources();
     $aDepartments = $plugin->getDepartments("");
     $aGroups = $plugin->getGroups();
     //$arrayDepartmentUserAd = array(); //(D) Update Users
     //$arrayGroupUserAd = array(); //(G) Update Users
     //echo "\n";
     $plugin->frontEndShow("START");
     $plugin->debugLog("START");
     foreach ($arrayAuthenticationSource as $value) {
         $arrayAuthenticationSourceData = $value;
         $plugin->debugLog("ldapadvanced.php > function executeCron() > foreach > \$arrayAuthenticationSourceData ---->\n" . print_r($arrayAuthenticationSourceData, true));
         $plugin->sAuthSource = $arrayAuthenticationSourceData["AUTH_SOURCE_UID"];
         $plugin->ldapcnn = null;
         $plugin->setArrayDepartmentUserSynchronizedChecked(array());
         $plugin->setArrayUserUpdateChecked(array());
         //Get all User (USR_UID, USR_USERNAME, USR_AUTH_USER_DN) registered in RBAC with this Authentication Source
         $plugin->setArrayAuthenticationSourceUsers($arrayAuthenticationSourceData["AUTH_SOURCE_UID"]);
         //INITIALIZE DATA
         $plugin->frontEndShow("TEXT", "Authentication Source: " . $arrayAuthenticationSourceData["AUTH_SOURCE_NAME"]);
         $plugin->log(null, "Executing cron for Authentication Source: " . $arrayAuthenticationSourceData["AUTH_SOURCE_NAME"]);
         //Get all departments from Ldap/ActiveDirectory and build a hierarchy using dn (ou->ou parent)
         $aLdapDepts = $plugin->searchDepartments();
         //Obtain all departments from PM with a valid department in LDAP/ActiveDirectory
         $aRegisteredDepts = $plugin->getRegisteredDepartments($aLdapDepts, $aDepartments);
         $plugin->debugLog("ldapadvanced.php > function executeCron() > foreach > \$aRegisteredDepts ---->\n" . print_r($aRegisteredDepts, true));
         //Get all group from Ldap/ActiveDirectory
         $aLdapGroups = $plugin->searchGroups();
         //Obtain all groups from PM with a valid group in LDAP/ActiveDirectory
         $aRegisteredGroups = $plugin->getRegisteredGroups($aLdapGroups, $aGroups);
         $plugin->debugLog("ldapadvanced.php > function executeCron() > foreach > \$aRegisteredGroups ---->\n" . print_r($aRegisteredGroups, true));
         //Get all users from Removed OU
         $this->usersRemovedOu = $plugin->getUsersFromRemovedOu($arrayAuthenticationSourceData);
         $plugin->deactiveArrayOfUsers($this->usersRemovedOu);
         //Variables
         $this->deletedRemoved = count($this->usersRemovedOu);
         $this->deletedRemovedUsers = "";
         $this->dAlready = 0;
         $this->dMoved = 0;
         $this->dImpossible = 0;
         $this->dCreated = 0;
         $this->dRemoved = 0;
         $this->dAlreadyUsers = "";
         $this->dMovedUsers = "";
         $this->dImpossibleUsers = "";
         $this->dCreatedUsers = "";
         $this->dRemovedUsers = "";
         $this->gAlready = 0;
         $this->gMoved = 0;
         $this->gImpossible = 0;
         $this->gCreated = 0;
         $this->gRemoved = 0;
         $this->gAlreadyUsers = "";
         $this->gMovedUsers = "";
         $this->gImpossibleUsers = "";
         $this->gCreatedUsers = "";
         $this->gRemovedUsers = "";
         //Department - Synchronize Users
         $numDepartments = count($aRegisteredDepts);
         $count = 0;
         $plugin->debugLog("ldapadvanced.php > function executeCron() > foreach > \$numDepartments ----> {$numDepartments}");
         foreach ($aRegisteredDepts as $registeredDept) {
             $count++;
             //(D) Update Users
             //if (!isset($arrayDepartmentUserAd[$registeredDept["DEP_UID"]])) {
             //    $arrayDepartmentUserAd[$registeredDept["DEP_UID"]] = array(); //Current users in department based in Active Directory
             //}
             //
             //$arrayAux = $this->departmentSynchronizeUsers($plugin, $numDepartments, $count, $registeredDept);
             //$arrayAux = array_merge($arrayDepartmentUserAd[$registeredDept["DEP_UID"]], $arrayAux);
             //
             //$arrayDepartmentUserAd[$registeredDept["DEP_UID"]] = array_unique($arrayAux);
             $arrayAux = $this->departmentSynchronizeUsers($plugin, $numDepartments, $count, $registeredDept);
         }
         //Department - Print log
         $logResults = sprintf("- Departments -> Existing users: %d, moved: %d, impossible: %d, created: %d, removed: %d", $this->dAlready, $this->dMoved, $this->dImpossible, $this->dCreated, $this->dRemoved);
         $plugin->frontEndShow("TEXT", $logResults);
         $plugin->log(null, $logResults);
         //Group - Synchronize Users
         $numGroups = count($aRegisteredGroups);
         $count = 0;
         $plugin->debugLog("ldapadvanced.php > function executeCron() > foreach > \$numGroups ----> {$numGroups}");
         foreach ($aRegisteredGroups as $registeredGroup) {
             $count++;
             //(G) Update Users
             //if (!isset($arrayGroupUserAd[$registeredGroup["GRP_UID"]])) {
             //    $arrayGroupUserAd[$registeredGroup["GRP_UID"]] = array(); //Current users in group based in Active Directory
             //}
             //
             //$arrayAux = $this->groupSynchronizeUsers($plugin, $numGroups, $count, $registeredGroup);
             //$arrayAux = array_merge($arrayGroupUserAd[$registeredGroup["GRP_UID"]], $arrayAux);
             //
             //$arrayGroupUserAd[$registeredGroup["GRP_UID"]] = array_unique($arrayAux);
             $arrayAux = $this->groupSynchronizeUsers($plugin, $numGroups, $count, $registeredGroup);
         }
         //Group - Print log
         $logResults = sprintf("- Groups -> Existing users: %d, moved: %d, impossible: %d, created: %d, removed: %d", $this->gAlready, $this->gMoved, $this->gImpossible, $this->gCreated, $this->gRemoved);
         $plugin->frontEndShow("TEXT", $logResults);
         $plugin->log(null, $logResults);
         //Manager
         $plugin->clearManager($this->managersToClear);
         if (isset($arrayAuthenticationSourceData["AUTH_SOURCE_DATA"]["DEPARTMENTS_TO_UNASSIGN"])) {
             if (is_array($arrayAuthenticationSourceData["AUTH_SOURCE_DATA"]["DEPARTMENTS_TO_UNASSIGN"])) {
                 foreach ($arrayAuthenticationSourceData["AUTH_SOURCE_DATA"]["DEPARTMENTS_TO_UNASSIGN"] as $departmentUID) {
                     // Delete manager assignments
                     $criteriaSet = new Criteria("workflow");
                     $criteriaSet->add(UsersPeer::USR_REPORTS_TO, "");
                     $criteriaWhere = new Criteria("workflow");
                     $criteriaWhere->add(UsersPeer::DEP_UID, $departmentUID);
                     $criteriaWhere->add(UsersPeer::USR_REPORTS_TO, "", Criteria::NOT_EQUAL);
                     $this->deletedManager = BasePeer::doUpdate($criteriaWhere, $criteriaSet, Propel::getConnection("workflow"));
                     // Delete department assignments
                     $criteriaSet = new Criteria("workflow");
                     $criteriaSet->add(UsersPeer::DEP_UID, "");
                     $criteriaWhere = new Criteria("workflow");
                     $criteriaWhere->add(UsersPeer::DEP_UID, $departmentUID);
                     $this->dMoved += UsersPeer::doCount($criteriaWhere);
                     BasePeer::doUpdate($criteriaWhere, $criteriaSet, Propel::getConnection("workflow"));
                 }
             }
             unset($arrayAuthenticationSourceData["AUTH_SOURCE_DATA"]["DEPARTMENTS_TO_UNASSIGN"]);
             $rbac =& RBAC::getSingleton();
             $rbac->authSourcesObj->update($arrayAuthenticationSourceData);
         }
         if (isset($arrayAuthenticationSourceData["AUTH_SOURCE_DATA"]["GROUPS_TO_UNASSIGN"])) {
             if (is_array($arrayAuthenticationSourceData["AUTH_SOURCE_DATA"]["GROUPS_TO_UNASSIGN"])) {
                 foreach ($arrayAuthenticationSourceData["AUTH_SOURCE_DATA"]["GROUPS_TO_UNASSIGN"] as $groupUID) {
                     // Delete manager assignments
                     $groupsInstance = new Groups();
                     $criteria = $groupsInstance->getUsersGroupCriteria($groupUID);
                     $dataset = UsersPeer::doSelectRS($criteria);
                     $dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
                     $dataset->next();
                     $users = array();
                     while ($row = $dataset->getRow()) {
                         $users[] = $row["USR_UID"];
                         $dataset->next();
                     }
                     $criteriaSet = new Criteria("workflow");
                     $criteriaSet->add(UsersPeer::USR_REPORTS_TO, "");
                     $criteriaWhere = new Criteria("workflow");
                     $criteriaWhere->add(UsersPeer::USR_UID, $users, Criteria::IN);
                     $criteriaWhere->add(UsersPeer::USR_REPORTS_TO, "", Criteria::NOT_EQUAL);
                     $this->deletedManager = BasePeer::doUpdate($criteriaWhere, $criteriaSet, Propel::getConnection("workflow"));
                     // Delete group assignments
                     $criteria = new Criteria("workflow");
                     $criteria->add(GroupUserPeer::GRP_UID, $groupUID);
                     $this->gMoved += GroupUserPeer::doCount($criteria);
                     BasePeer::doDelete($criteria, Propel::getConnection("workflow"));
                 }
             }
             unset($arrayAuthenticationSourceData["AUTH_SOURCE_DATA"]["GROUPS_TO_UNASSIGN"]);
             $rbac =& RBAC::getSingleton();
             $rbac->authSourcesObj->update($arrayAuthenticationSourceData);
         }
         // Delete the managers that not exists in PM
         $criteria = new Criteria("rbac");
         $criteria->addSelectColumn(RbacUsersPeer::USR_AUTH_USER_DN);
         $criteria->add(RbacUsersPeer::USR_AUTH_USER_DN, "", Criteria::NOT_EQUAL);
         $dataset = RbacUsersPeer::doSelectRS($criteria);
         $dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
         $dataset->next();
         $existingUsers = array();
         while ($row = $dataset->getRow()) {
             $existingUsers[] = $row["USR_AUTH_USER_DN"];
             $dataset->next();
         }
         foreach ($this->managersHierarchy as $managerDN => $subordinates) {
             if (!in_array($managerDN, $existingUsers)) {
                 unset($this->managersHierarchy[$managerDN]);
             }
         }
         // Get the managers assigments counters
         $plugin->synchronizeManagers($this->managersHierarchy);
         $deletedManagersAssignments = self::array_diff_assoc_recursive($this->oldManagersHierarchy, $this->managersHierarchy);
         $newManagersAssignments = self::array_diff_assoc_recursive($this->managersHierarchy, $this->oldManagersHierarchy);
         $deletedManagers = array();
         $newManagers = array();
         $movedManagers = array();
         if (is_array($deletedManagersAssignments)) {
             foreach ($deletedManagersAssignments as $dn1 => $subordinates1) {
                 foreach ($subordinates1 as $subordinate) {
                     if (!in_array($subordinate, $deletedManagers)) {
                         $deletedManagers[] = $subordinate;
                     }
                     foreach ($newManagersAssignments as $dn2 => $subordinates2) {
                         if (isset($subordinates2[$subordinate])) {
                             $movedManagers[] = $subordinate;
                         }
                     }
                 }
             }
         }
         if (is_array($newManagersAssignments)) {
             foreach ($newManagersAssignments as $dn1 => $subordinates1) {
                 foreach ($subordinates1 as $subordinate) {
                     if (!in_array($subordinate, $newManagers)) {
                         $newManagers[] = $subordinate;
                     }
                     foreach ($deletedManagersAssignments as $dn2 => $subordinates2) {
                         if (isset($subordinates2[$subordinate])) {
                             if (!in_array($subordinate, $movedManagers)) {
                                 $movedManagers[] = $subordinate;
                             }
                         }
                     }
                 }
             }
         }
         //Print and log the users's information
         //Deleted/Removed Users
         $logResults = sprintf("- Deleted/Removed Users: %d", $this->deletedRemoved);
         $plugin->frontEndShow("TEXT", $logResults);
         $plugin->log(null, $logResults);
         if ($this->deletedRemoved > 0) {
             $plugin->log(null, "Deleted/Removed Users: ");
             $plugin->log(null, $this->deletedRemovedUsers);
         }
         if ($this->dAlready + $this->gAlready > 0) {
             $plugin->log(null, "Existing Users: ");
             $plugin->log(null, $this->dAlreadyUsers . " " . $this->gAlreadyUsers);
         }
         if ($this->dMoved + $this->gMoved > 0) {
             $plugin->log(null, "Moved Users: ");
             $plugin->log(null, $this->dMovedUsers . " " . $this->gMovedUsers);
         }
         if ($this->dImpossible + $this->gImpossible > 0) {
             $plugin->log(null, "Impossible Users: ");
             $plugin->log(null, $this->dImpossibleUsers . " " . $this->gImpossibleUsers);
         }
         if ($this->dCreated + $this->gCreated > 0) {
             $plugin->log(null, "Created Users: ");
             $plugin->log(null, $this->dCreatedUsers . " " . $this->gCreatedUsers);
         }
         if ($this->dRemoved + $this->gRemoved > 0) {
             $plugin->log(null, "Removed Users: ");
             $plugin->log(null, $this->dRemovedUsers . " " . $this->gRemovedUsers);
         }
         //Print and log the managers assignments"s information
         $logResults = sprintf("- Managers assignments: created %d, moved %d, removed %d", count($newManagers) - count($movedManagers), count($movedManagers), count($deletedManagers) - count($movedManagers) + $this->deletedManager);
         $plugin->frontEndShow("TEXT", $logResults);
         $plugin->log(null, $logResults);
         //Update Users data based on the LDAP Server
         $plugin->usersUpdateData($arrayAuthenticationSourceData["AUTH_SOURCE_UID"]);
     }
     $plugin->frontEndShow("END");
     //(D) Update Users
     ////Department //Upgrade users in departments
     //foreach ($arrayDepartmentUserAd as $departmentUid => $arrayUserAd) {
     //    $plugin->setArrayDepartmentUsers($departmentUid); //INITIALIZE DATA
     //
     //    $arrayAux = array_diff(array_keys($plugin->arrayDepartmentUsersByUid), $arrayUserAd);
     //
     //    $this->departmentRemoveUsers($departmentUid, $arrayAux);
     //}
     //(G) Update Users
     ////Group //Upgrade users in groups
     //foreach ($arrayGroupUserAd as $groupUid => $arrayUserAd) {
     //    $plugin->setArrayGroupUsers($groupUid); //INITIALIZE DATA
     //
     //    $arrayAux = array_diff(array_keys($plugin->arrayGroupUsersByUid), $arrayUserAd);
     //
     //    $this->groupRemoveUsers($groupUid, $arrayAux);
     //}
     //// Developed by Gary and Ronald
     //$usersInfo = $plugin->ASUpdateInfo('');
     //if (isset($usersInfo) && $usersInfo > 0) {
     //    $this->dMoved = $usersInfo;
     //}
     //// End Developed by Gary and Ronald
     $plugin->debugLog("END");
 }
Ejemplo n.º 12
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 = GroupUserPeer::getFieldNames($keyType);
     if (array_key_exists($keys[0], $arr)) {
         $this->setGrpUid($arr[$keys[0]]);
     }
     if (array_key_exists($keys[1], $arr)) {
         $this->setUsrUid($arr[$keys[1]]);
     }
 }
Ejemplo n.º 13
0
 /**
  * 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
  */
 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;
     }
 }
Ejemplo n.º 14
0
 /**
  * Return the user that can start a task
  *
  * @param string $sProcessUID {@min 32} {@max 32}
  * @param string $sActivityUID {@min 32} {@max 32}
  * @param array  $oData
  *
  * return array
  *
  * @access public
  */
 public function projectWsUserCanStartTask($sProcessUID, $sActivityUID, $oData)
 {
     try {
         Validator::proUid($sProcessUID, '$prj_uid');
         /**
          * process_webEntryValidate
          * validates if the username and password are valid data and if the user assigned
          * to the webentry has the rights and persmissions required
          */
         $sTASKS = $sActivityUID;
         $sWS_USER = trim($oData['username']);
         $sWS_PASS = trim($oData['password']);
         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;
         $params = array('userid' => $user, 'password' => $pass);
         $result = $client->__SoapCall('login', array($params));
         $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 = 1;
         \G::LoadClass('Task');
         \G::LoadClass('User');
         \G::LoadClass('TaskUser');
         \G::LoadClass('Groupwf');
         /**
          * note added by gustavo cruz gustavo-at-colosa-dot-com
          * This is a little check to see if the GroupUser class has been declared or not.
          * Seems that the problem its present in a windows installation of PM however.
          * It's seems that could be replicated in a Linux server easily.
          * I recomend that in some way check already if a imported class is declared
          * somewhere else or maybe delegate the task to the G Class LoadClass method.
          */
         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->addSelectColumn(\UsersPeer::USR_USERNAME);
             $oCriteria->addSelectColumn(\UsersPeer::USR_FIRSTNAME);
             $oCriteria->addSelectColumn(\UsersPeer::USR_LASTNAME);
             $oCriteria->addSelectColumn(\TaskPeer::PRO_UID);
             $oCriteria->addJoin(\TaskUserPeer::USR_UID, \UsersPeer::USR_UID, \Criteria::LEFT_JOIN);
             $oCriteria->addJoin(\TaskUserPeer::TAS_UID, \TaskPeer::TAS_UID, \Criteria::LEFT_JOIN);
             if ($sTASKS) {
                 $oCriteria->add(\TaskUserPeer::TAS_UID, $sTASKS);
             }
             $oCriteria->add(\UsersPeer::USR_USERNAME, $sWS_USER);
             $oCriteria->add(\TaskPeer::PRO_UID, $sProcessUID);
             $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->addSelectColumn(\UsersPeer::USR_USERNAME);
                 $oCriteria->addSelectColumn(\UsersPeer::USR_FIRSTNAME);
                 $oCriteria->addSelectColumn(\UsersPeer::USR_LASTNAME);
                 $oCriteria->addJoin(\UsersPeer::USR_UID, \GroupUserPeer::USR_UID, \Criteria::LEFT_JOIN);
                 $oCriteria->addJoin(\GroupUserPeer::GRP_UID, \TaskUserPeer::USR_UID, \Criteria::LEFT_JOIN);
                 $oCriteria->addJoin(\TaskUserPeer::TAS_UID, \TaskPeer::TAS_UID, \Criteria::LEFT_JOIN);
                 if ($sTASKS) {
                     $oCriteria->add(\TaskUserPeer::TAS_UID, $sTASKS);
                 }
                 $oCriteria->add(\UsersPeer::USR_USERNAME, $sWS_USER);
                 $oCriteria->add(\TaskPeer::PRO_UID, $sProcessUID);
                 $userIsAssigned = \GroupUserPeer::doCount($oCriteria);
                 if (!($userIsAssigned >= 1)) {
                     if ($sTASKS) {
                         throw new \Exception(\G::LoadTranslation("ID_USER_NOT_ID_ACTIVITY", array($sWS_USER, $sTASKS)));
                     } else {
                         throw new \Exception(\G::LoadTranslation("ID_USER_NOT_ACTIVITY", array($sWS_USER)));
                     }
                 }
             }
             $oDataset = \TaskUserPeer::doSelectRS($oCriteria);
             $oDataset->setFetchmode(\ResultSet::FETCHMODE_ASSOC);
             $oDataset->next();
             while ($aRow = $oDataset->getRow()) {
                 $messageCode = array('usr_uid' => $aRow['USR_UID'], 'usr_username' => $aRow['USR_USERNAME'], 'usr_firstname' => $aRow['USR_FIRSTNAME'], 'usr_lastname' => $aRow['USR_LASTNAME']);
                 $oDataset->next();
             }
         } else {
             throw new \Exception($result->message);
         }
         return $messageCode;
     } catch (Exception $e) {
         throw $e;
     }
 }
Ejemplo n.º 15
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;

    }
    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;
}
echo $messageCode;
Ejemplo n.º 17
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;
     }
 }
Ejemplo n.º 18
0
 /**
  * Verify if exists the User in Group
  *
  * @param string $groupUid              Unique id of Group
  * @param string $userUid               Unique id of User
  * @param string $fieldNameForException Field name for the exception
  *
  * return void Throw exception if exists the User in Group
  */
 public function throwExceptionIfExistsGroupUser($groupUid, $userUid, $fieldNameForException)
 {
     try {
         $obj = \GroupUserPeer::retrieveByPK($groupUid, $userUid);
         if (is_object($obj) && get_class($obj) == "GroupUser") {
             throw new \Exception(\G::LoadTranslation("ID_GROUP_USER_IS_ALREADY_ASSIGNED", array($fieldNameForException, $userUid)));
         }
     } catch (\Exception $e) {
         throw $e;
     }
 }