diff --git a/workflow/engine/bin/cron_single.php b/workflow/engine/bin/cron_single.php index d33524d33..a04ec1d14 100755 --- a/workflow/engine/bin/cron_single.php +++ b/workflow/engine/bin/cron_single.php @@ -340,6 +340,7 @@ function processWorkspace() fillReportByUser(); fillReportByProcess(); synchronizeDrive(); + synchronizeGmailLabels(); /*----------------------------------********---------------------------------*/ } catch (Exception $oError) { saveLog("main", "error", "Error processing workspace : " . $oError->getMessage() . "\n"); @@ -982,5 +983,26 @@ function synchronizeDrive () } } -/*----------------------------------********---------------------------------*/ +function synchronizeGmailLabels() +{ + try + { + global $argvx; + if (strpos($argvx, "synchronize-gmail-labels") === false) { + return false; + } + + setExecutionMessage("Synchronize labels in Gmail"); + G::LoadClass('labelsGmail'); + $labGmail = new labelsGmail(); + $labGmail->processPendingRelabelingInQueue(); + setExecutionResultMessage("DONE"); + + } catch (Exception $e) { + setExecutionResultMessage("WITH ERRORS", "error"); + eprintln(" '-" . $e->getMessage(), "red"); + saveLog("synchronizeGmailLabels", "error", "Error when synchronizing Gmail labels: " . $e->getMessage()); + } +} +/*----------------------------------********---------------------------------*/ diff --git a/workflow/engine/classes/class.labelsGmail.php b/workflow/engine/classes/class.labelsGmail.php index 6b6680c8d..4c07f82fc 100644 --- a/workflow/engine/classes/class.labelsGmail.php +++ b/workflow/engine/classes/class.labelsGmail.php @@ -12,6 +12,7 @@ class labelsGmail } } catch (Exception $e) { print G::LoadTranslation("ID_PMGMAIL_GENERAL_ERROR") . $e->getMessage(); + throw ($e); } return $labels; } @@ -34,6 +35,7 @@ class labelsGmail $message = $service->users_messages->modify($userId, $messageId, $mods); } catch (Exception $e) { print G::LoadTranslation("ID_PMGMAIL_GENERAL_ERROR") . $e->getMessage(); + throw ($e); } } @@ -63,6 +65,7 @@ class labelsGmail } } catch (Exception $e) { print G::LoadTranslation("ID_PMGMAIL_GENERAL_ERROR") . $e->getMessage(); + throw ($e); } } while ($pageToken); @@ -286,31 +289,68 @@ class labelsGmail return $count . ' labels successfully deleted.'; } + public function addRelabelingToQueue($caseId, $index, $actualLastIndex, $unassigned=false) + { + $labelingQueue = new GmailRelabeling(); + $labelingQueue->setAppUid($caseId); + $labelingQueue->setDelIndex($index); + $labelingQueue->setCurrentLastIndex($actualLastIndex); + $labelingQueue->setUnassigned(($unassigned === true) ? 1 : 0); + $labelingQueue->setStatus('pending'); + $labelingQueue->save(); + } + + public function processPendingRelabelingInQueue() + { + $c = new \Criteria( 'workflow' ); + $c->add( \GmailRelabelingPeer::STATUS, 'pending' ); + $list = \GmailRelabelingPeer::doSelect($c); + foreach($list as $task) { + try { + $oResponse = $this->setLabels($task->getAppUid(), + $task->getDelIndex(), + $task->getCurrentLastIndex(), + ($task->getUnassigned() === 1) ? true : false + ); + $task->setStatus('completed'); + } + catch(exception $e){ + $task->setMsgError($e->getMessage()); + $task->setStatus('pending'); + } + $task->save(); + } + } private function getLabelsIds($service) { $result = array(); - $listlabels = $this->listLabels($service); - foreach ($listlabels as $label) { - $labId = $label->getId(); - $labName = $label->getName(); - switch($labName){ - case "* Inbox": - $result['Inbox'] = $labId; - break; - case "* Participated": - $result['Participated'] = $labId; - break; - case "* Unassigned": - $result['Unassigned'] = $labId; - break; - case "* Draft": - $result['Draft'] = $labId; - break; - case "* Paused": - $result['Paused'] = $labId; - break; + try { + $listlabels = $this->listLabels($service); + foreach ($listlabels as $label) { + $labId = $label->getId(); + $labName = $label->getName(); + switch($labName){ + case "* Inbox": + $result['Inbox'] = $labId; + break; + case "* Participated": + $result['Participated'] = $labId; + break; + case "* Unassigned": + $result['Unassigned'] = $labId; + break; + case "* Draft": + $result['Draft'] = $labId; + break; + case "* Paused": + $result['Paused'] = $labId; + break; + } } } + catch(Exception $e) { + throw $e; + } return $result; } } diff --git a/workflow/engine/classes/model/GmailRelabeling.php b/workflow/engine/classes/model/GmailRelabeling.php new file mode 100644 index 000000000..29102525c --- /dev/null +++ b/workflow/engine/classes/model/GmailRelabeling.php @@ -0,0 +1,19 @@ +dbMap !== null); + } + + /** + * Gets the databasemap this map builder built. + * + * @return the databasemap + */ + public function getDatabaseMap() + { + return $this->dbMap; + } + + /** + * The doBuild() method builds the DatabaseMap + * + * @return void + * @throws PropelException + */ + public function doBuild() + { + $this->dbMap = Propel::getDatabaseMap('workflow'); + + $tMap = $this->dbMap->addTable('GMAIL_RELABELING'); + $tMap->setPhpName('GmailRelabeling'); + + $tMap->setUseIdGenerator(false); + + $tMap->addPrimaryKey('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32); + + $tMap->addPrimaryKey('DEL_INDEX', 'DelIndex', 'int', CreoleTypes::INTEGER, true, null); + + $tMap->addColumn('CURRENT_LAST_INDEX', 'CurrentLastIndex', 'int', CreoleTypes::INTEGER, true, null); + + $tMap->addColumn('UNASSIGNED', 'Unassigned', 'int', CreoleTypes::INTEGER, true, null); + + $tMap->addColumn('STATUS', 'Status', 'string', CreoleTypes::VARCHAR, true, 32); + + $tMap->addColumn('MSG_ERROR', 'MsgError', 'string', CreoleTypes::LONGVARCHAR, false, null); + + } // doBuild() + +} // GmailRelabelingMapBuilder diff --git a/workflow/engine/classes/model/om/BaseGmailRelabeling.php b/workflow/engine/classes/model/om/BaseGmailRelabeling.php new file mode 100644 index 000000000..ef8ada700 --- /dev/null +++ b/workflow/engine/classes/model/om/BaseGmailRelabeling.php @@ -0,0 +1,812 @@ +app_uid; + } + + /** + * Get the [del_index] column value. + * + * @return int + */ + public function getDelIndex() + { + + return $this->del_index; + } + + /** + * Get the [current_last_index] column value. + * + * @return int + */ + public function getCurrentLastIndex() + { + + return $this->current_last_index; + } + + /** + * Get the [unassigned] column value. + * + * @return int + */ + public function getUnassigned() + { + + return $this->unassigned; + } + + /** + * Get the [status] column value. + * + * @return string + */ + public function getStatus() + { + + return $this->status; + } + + /** + * Get the [msg_error] column value. + * + * @return string + */ + public function getMsgError() + { + + return $this->msg_error; + } + + /** + * Set the value of [app_uid] column. + * + * @param string $v new value + * @return void + */ + public function setAppUid($v) + { + + // Since the native PHP type for this column is string, + // we will cast the input to a string (if it is not). + if ($v !== null && !is_string($v)) { + $v = (string) $v; + } + + if ($this->app_uid !== $v || $v === '') { + $this->app_uid = $v; + $this->modifiedColumns[] = GmailRelabelingPeer::APP_UID; + } + + } // setAppUid() + + /** + * Set the value of [del_index] column. + * + * @param int $v new value + * @return void + */ + public function setDelIndex($v) + { + + // Since the native PHP type for this column is integer, + // we will cast the input value to an int (if it is not). + if ($v !== null && !is_int($v) && is_numeric($v)) { + $v = (int) $v; + } + + if ($this->del_index !== $v || $v === 0) { + $this->del_index = $v; + $this->modifiedColumns[] = GmailRelabelingPeer::DEL_INDEX; + } + + } // setDelIndex() + + /** + * Set the value of [current_last_index] column. + * + * @param int $v new value + * @return void + */ + public function setCurrentLastIndex($v) + { + + // Since the native PHP type for this column is integer, + // we will cast the input value to an int (if it is not). + if ($v !== null && !is_int($v) && is_numeric($v)) { + $v = (int) $v; + } + + if ($this->current_last_index !== $v || $v === 0) { + $this->current_last_index = $v; + $this->modifiedColumns[] = GmailRelabelingPeer::CURRENT_LAST_INDEX; + } + + } // setCurrentLastIndex() + + /** + * Set the value of [unassigned] column. + * + * @param int $v new value + * @return void + */ + public function setUnassigned($v) + { + + // Since the native PHP type for this column is integer, + // we will cast the input value to an int (if it is not). + if ($v !== null && !is_int($v) && is_numeric($v)) { + $v = (int) $v; + } + + if ($this->unassigned !== $v || $v === 0) { + $this->unassigned = $v; + $this->modifiedColumns[] = GmailRelabelingPeer::UNASSIGNED; + } + + } // setUnassigned() + + /** + * Set the value of [status] column. + * + * @param string $v new value + * @return void + */ + public function setStatus($v) + { + + // Since the native PHP type for this column is string, + // we will cast the input to a string (if it is not). + if ($v !== null && !is_string($v)) { + $v = (string) $v; + } + + if ($this->status !== $v || $v === 'pending') { + $this->status = $v; + $this->modifiedColumns[] = GmailRelabelingPeer::STATUS; + } + + } // setStatus() + + /** + * Set the value of [msg_error] column. + * + * @param string $v new value + * @return void + */ + public function setMsgError($v) + { + + // Since the native PHP type for this column is string, + // we will cast the input to a string (if it is not). + if ($v !== null && !is_string($v)) { + $v = (string) $v; + } + + if ($this->msg_error !== $v) { + $this->msg_error = $v; + $this->modifiedColumns[] = GmailRelabelingPeer::MSG_ERROR; + } + + } // setMsgError() + + /** + * Hydrates (populates) the object variables with values from the database resultset. + * + * An offset (1-based "start column") is specified so that objects can be hydrated + * with a subset of the columns in the resultset rows. This is needed, for example, + * for results of JOIN queries where the resultset row includes columns from two or + * more tables. + * + * @param ResultSet $rs The ResultSet class with cursor advanced to desired record pos. + * @param int $startcol 1-based offset column which indicates which restultset column to start with. + * @return int next starting column + * @throws PropelException - Any caught Exception will be rewrapped as a PropelException. + */ + public function hydrate(ResultSet $rs, $startcol = 1) + { + try { + + $this->app_uid = $rs->getString($startcol + 0); + + $this->del_index = $rs->getInt($startcol + 1); + + $this->current_last_index = $rs->getInt($startcol + 2); + + $this->unassigned = $rs->getInt($startcol + 3); + + $this->status = $rs->getString($startcol + 4); + + $this->msg_error = $rs->getString($startcol + 5); + + $this->resetModified(); + + $this->setNew(false); + + // FIXME - using NUM_COLUMNS may be clearer. + return $startcol + 6; // 6 = GmailRelabelingPeer::NUM_COLUMNS - GmailRelabelingPeer::NUM_LAZY_LOAD_COLUMNS). + + } catch (Exception $e) { + throw new PropelException("Error populating GmailRelabeling object", $e); + } + } + + /** + * Removes this object from datastore and sets delete attribute. + * + * @param Connection $con + * @return void + * @throws PropelException + * @see BaseObject::setDeleted() + * @see BaseObject::isDeleted() + */ + public function delete($con = null) + { + if ($this->isDeleted()) { + throw new PropelException("This object has already been deleted."); + } + + if ($con === null) { + $con = Propel::getConnection(GmailRelabelingPeer::DATABASE_NAME); + } + + try { + $con->begin(); + GmailRelabelingPeer::doDelete($this, $con); + $this->setDeleted(true); + $con->commit(); + } catch (PropelException $e) { + $con->rollback(); + throw $e; + } + } + + /** + * Stores the object in the database. If the object is new, + * it inserts it; otherwise an update is performed. This method + * wraps the doSave() worker method in a transaction. + * + * @param Connection $con + * @return int The number of rows affected by this insert/update + * @throws PropelException + * @see doSave() + */ + public function save($con = null) + { + if ($this->isDeleted()) { + throw new PropelException("You cannot save an object that has been deleted."); + } + + if ($con === null) { + $con = Propel::getConnection(GmailRelabelingPeer::DATABASE_NAME); + } + + try { + $con->begin(); + $affectedRows = $this->doSave($con); + $con->commit(); + return $affectedRows; + } catch (PropelException $e) { + $con->rollback(); + throw $e; + } + } + + /** + * Stores the object in the database. + * + * If the object is new, it inserts it; otherwise an update is performed. + * All related objects are also updated in this method. + * + * @param Connection $con + * @return int The number of rows affected by this insert/update and any referring + * @throws PropelException + * @see save() + */ + protected function doSave($con) + { + $affectedRows = 0; // initialize var to track total num of affected rows + if (!$this->alreadyInSave) { + $this->alreadyInSave = true; + + + // If this object has been modified, then save it to the database. + if ($this->isModified()) { + if ($this->isNew()) { + $pk = GmailRelabelingPeer::doInsert($this, $con); + $affectedRows += 1; // we are assuming that there is only 1 row per doInsert() which + // should always be true here (even though technically + // BasePeer::doInsert() can insert multiple rows). + + $this->setNew(false); + } else { + $affectedRows += GmailRelabelingPeer::doUpdate($this, $con); + } + $this->resetModified(); // [HL] After being saved an object is no longer 'modified' + } + + $this->alreadyInSave = false; + } + return $affectedRows; + } // doSave() + + /** + * Array of ValidationFailed objects. + * @var array ValidationFailed[] + */ + protected $validationFailures = array(); + + /** + * Gets any ValidationFailed objects that resulted from last call to validate(). + * + * + * @return array ValidationFailed[] + * @see validate() + */ + public function getValidationFailures() + { + return $this->validationFailures; + } + + /** + * Validates the objects modified field values and all objects related to this table. + * + * If $columns is either a column name or an array of column names + * only those columns are validated. + * + * @param mixed $columns Column name or an array of column names. + * @return boolean Whether all columns pass validation. + * @see doValidate() + * @see getValidationFailures() + */ + public function validate($columns = null) + { + $res = $this->doValidate($columns); + if ($res === true) { + $this->validationFailures = array(); + return true; + } else { + $this->validationFailures = $res; + return false; + } + } + + /** + * This function performs the validation work for complex object models. + * + * In addition to checking the current object, all related objects will + * also be validated. If all pass then true is returned; otherwise + * an aggreagated array of ValidationFailed objects will be returned. + * + * @param array $columns Array of column names to validate. + * @return mixed true if all validations pass; + array of ValidationFailed objects otherwise. + */ + protected function doValidate($columns = null) + { + if (!$this->alreadyInValidation) { + $this->alreadyInValidation = true; + $retval = null; + + $failureMap = array(); + + + if (($retval = GmailRelabelingPeer::doValidate($this, $columns)) !== true) { + $failureMap = array_merge($failureMap, $retval); + } + + + + $this->alreadyInValidation = false; + } + + return (!empty($failureMap) ? $failureMap : true); + } + + /** + * Retrieves a field from the object by name passed in as a string. + * + * @param string $name name + * @param string $type The type of fieldname the $name is of: + * one of the class type constants TYPE_PHPNAME, + * TYPE_COLNAME, TYPE_FIELDNAME, TYPE_NUM + * @return mixed Value of field. + */ + public function getByName($name, $type = BasePeer::TYPE_PHPNAME) + { + $pos = GmailRelabelingPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM); + return $this->getByPosition($pos); + } + + /** + * Retrieves a field from the object by Position as specified in the xml schema. + * Zero-based. + * + * @param int $pos position in xml schema + * @return mixed Value of field at $pos + */ + public function getByPosition($pos) + { + switch($pos) { + case 0: + return $this->getAppUid(); + break; + case 1: + return $this->getDelIndex(); + break; + case 2: + return $this->getCurrentLastIndex(); + break; + case 3: + return $this->getUnassigned(); + break; + case 4: + return $this->getStatus(); + break; + case 5: + return $this->getMsgError(); + break; + default: + return null; + break; + } // switch() + } + + /** + * Exports the object as an array. + * + * You can specify the key type of the array by passing one of the class + * type constants. + * + * @param string $keyType One of the class type constants TYPE_PHPNAME, + * TYPE_COLNAME, TYPE_FIELDNAME, TYPE_NUM + * @return an associative array containing the field names (as keys) and field values + */ + public function toArray($keyType = BasePeer::TYPE_PHPNAME) + { + $keys = GmailRelabelingPeer::getFieldNames($keyType); + $result = array( + $keys[0] => $this->getAppUid(), + $keys[1] => $this->getDelIndex(), + $keys[2] => $this->getCurrentLastIndex(), + $keys[3] => $this->getUnassigned(), + $keys[4] => $this->getStatus(), + $keys[5] => $this->getMsgError(), + ); + return $result; + } + + /** + * Sets a field from the object by name passed in as a string. + * + * @param string $name peer name + * @param mixed $value field value + * @param string $type The type of fieldname the $name is of: + * one of the class type constants TYPE_PHPNAME, + * TYPE_COLNAME, TYPE_FIELDNAME, TYPE_NUM + * @return void + */ + public function setByName($name, $value, $type = BasePeer::TYPE_PHPNAME) + { + $pos = GmailRelabelingPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM); + return $this->setByPosition($pos, $value); + } + + /** + * Sets a field from the object by Position as specified in the xml schema. + * Zero-based. + * + * @param int $pos position in xml schema + * @param mixed $value field value + * @return void + */ + public function setByPosition($pos, $value) + { + switch($pos) { + case 0: + $this->setAppUid($value); + break; + case 1: + $this->setDelIndex($value); + break; + case 2: + $this->setCurrentLastIndex($value); + break; + case 3: + $this->setUnassigned($value); + break; + case 4: + $this->setStatus($value); + break; + case 5: + $this->setMsgError($value); + break; + } // switch() + } + + /** + * 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 = GmailRelabelingPeer::getFieldNames($keyType); + + if (array_key_exists($keys[0], $arr)) { + $this->setAppUid($arr[$keys[0]]); + } + + if (array_key_exists($keys[1], $arr)) { + $this->setDelIndex($arr[$keys[1]]); + } + + if (array_key_exists($keys[2], $arr)) { + $this->setCurrentLastIndex($arr[$keys[2]]); + } + + if (array_key_exists($keys[3], $arr)) { + $this->setUnassigned($arr[$keys[3]]); + } + + if (array_key_exists($keys[4], $arr)) { + $this->setStatus($arr[$keys[4]]); + } + + if (array_key_exists($keys[5], $arr)) { + $this->setMsgError($arr[$keys[5]]); + } + + } + + /** + * Build a Criteria object containing the values of all modified columns in this object. + * + * @return Criteria The Criteria object containing all modified values. + */ + public function buildCriteria() + { + $criteria = new Criteria(GmailRelabelingPeer::DATABASE_NAME); + + if ($this->isColumnModified(GmailRelabelingPeer::APP_UID)) { + $criteria->add(GmailRelabelingPeer::APP_UID, $this->app_uid); + } + + if ($this->isColumnModified(GmailRelabelingPeer::DEL_INDEX)) { + $criteria->add(GmailRelabelingPeer::DEL_INDEX, $this->del_index); + } + + if ($this->isColumnModified(GmailRelabelingPeer::CURRENT_LAST_INDEX)) { + $criteria->add(GmailRelabelingPeer::CURRENT_LAST_INDEX, $this->current_last_index); + } + + if ($this->isColumnModified(GmailRelabelingPeer::UNASSIGNED)) { + $criteria->add(GmailRelabelingPeer::UNASSIGNED, $this->unassigned); + } + + if ($this->isColumnModified(GmailRelabelingPeer::STATUS)) { + $criteria->add(GmailRelabelingPeer::STATUS, $this->status); + } + + if ($this->isColumnModified(GmailRelabelingPeer::MSG_ERROR)) { + $criteria->add(GmailRelabelingPeer::MSG_ERROR, $this->msg_error); + } + + + return $criteria; + } + + /** + * Builds a Criteria object containing the primary key for this object. + * + * Unlike buildCriteria() this method includes the primary key values regardless + * of whether or not they have been modified. + * + * @return Criteria The Criteria object containing value(s) for primary key(s). + */ + public function buildPkeyCriteria() + { + $criteria = new Criteria(GmailRelabelingPeer::DATABASE_NAME); + + $criteria->add(GmailRelabelingPeer::APP_UID, $this->app_uid); + $criteria->add(GmailRelabelingPeer::DEL_INDEX, $this->del_index); + + return $criteria; + } + + /** + * Returns the composite primary key for this object. + * The array elements will be in same order as specified in XML. + * @return array + */ + public function getPrimaryKey() + { + $pks = array(); + + $pks[0] = $this->getAppUid(); + + $pks[1] = $this->getDelIndex(); + + return $pks; + } + + /** + * Set the [composite] primary key. + * + * @param array $keys The elements of the composite key (order must match the order in XML file). + * @return void + */ + public function setPrimaryKey($keys) + { + + $this->setAppUid($keys[0]); + + $this->setDelIndex($keys[1]); + + } + + /** + * Sets contents of passed object to values from current object. + * + * If desired, this method can also make copies of all associated (fkey referrers) + * objects. + * + * @param object $copyObj An object of GmailRelabeling (or compatible) type. + * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row. + * @throws PropelException + */ + public function copyInto($copyObj, $deepCopy = false) + { + + $copyObj->setCurrentLastIndex($this->current_last_index); + + $copyObj->setUnassigned($this->unassigned); + + $copyObj->setStatus($this->status); + + $copyObj->setMsgError($this->msg_error); + + + $copyObj->setNew(true); + + $copyObj->setAppUid(''); // this is a pkey column, so set to default value + + $copyObj->setDelIndex('0'); // this is a pkey column, so set to default value + + } + + /** + * Makes a copy of this object that will be inserted as a new row in table when saved. + * It creates a new object filling in the simple attributes, but skipping any primary + * keys that are defined for the table. + * + * If desired, this method can also make copies of all associated (fkey referrers) + * objects. + * + * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row. + * @return GmailRelabeling Clone of current object. + * @throws PropelException + */ + public function copy($deepCopy = false) + { + // we use get_class(), because this might be a subclass + $clazz = get_class($this); + $copyObj = new $clazz(); + $this->copyInto($copyObj, $deepCopy); + return $copyObj; + } + + /** + * Returns a peer instance associated with this om. + * + * Since Peer classes are not to have any instance attributes, this method returns the + * same instance for all member of this class. The method could therefore + * be static, but this would prevent one from overriding the behavior. + * + * @return GmailRelabelingPeer + */ + public function getPeer() + { + if (self::$peer === null) { + self::$peer = new GmailRelabelingPeer(); + } + return self::$peer; + } +} + diff --git a/workflow/engine/classes/model/om/BaseGmailRelabelingPeer.php b/workflow/engine/classes/model/om/BaseGmailRelabelingPeer.php new file mode 100644 index 000000000..a180c7fbf --- /dev/null +++ b/workflow/engine/classes/model/om/BaseGmailRelabelingPeer.php @@ -0,0 +1,582 @@ + array ('AppUid', 'DelIndex', 'CurrentLastIndex', 'Unassigned', 'Status', 'MsgError', ), + BasePeer::TYPE_COLNAME => array (GmailRelabelingPeer::APP_UID, GmailRelabelingPeer::DEL_INDEX, GmailRelabelingPeer::CURRENT_LAST_INDEX, GmailRelabelingPeer::UNASSIGNED, GmailRelabelingPeer::STATUS, GmailRelabelingPeer::MSG_ERROR, ), + BasePeer::TYPE_FIELDNAME => array ('APP_UID', 'DEL_INDEX', 'CURRENT_LAST_INDEX', 'UNASSIGNED', 'STATUS', 'MSG_ERROR', ), + BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, ) + ); + + /** + * holds an array of keys for quick access to the fieldnames array + * + * first dimension keys are the type constants + * e.g. self::$fieldNames[BasePeer::TYPE_PHPNAME]['Id'] = 0 + */ + private static $fieldKeys = array ( + BasePeer::TYPE_PHPNAME => array ('AppUid' => 0, 'DelIndex' => 1, 'CurrentLastIndex' => 2, 'Unassigned' => 3, 'Status' => 4, 'MsgError' => 5, ), + BasePeer::TYPE_COLNAME => array (GmailRelabelingPeer::APP_UID => 0, GmailRelabelingPeer::DEL_INDEX => 1, GmailRelabelingPeer::CURRENT_LAST_INDEX => 2, GmailRelabelingPeer::UNASSIGNED => 3, GmailRelabelingPeer::STATUS => 4, GmailRelabelingPeer::MSG_ERROR => 5, ), + BasePeer::TYPE_FIELDNAME => array ('APP_UID' => 0, 'DEL_INDEX' => 1, 'CURRENT_LAST_INDEX' => 2, 'UNASSIGNED' => 3, 'STATUS' => 4, 'MSG_ERROR' => 5, ), + BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, ) + ); + + /** + * @return MapBuilder the map builder for this peer + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + */ + public static function getMapBuilder() + { + include_once 'classes/model/map/GmailRelabelingMapBuilder.php'; + return BasePeer::getMapBuilder('classes.model.map.GmailRelabelingMapBuilder'); + } + /** + * Gets a map (hash) of PHP names to DB column names. + * + * @return array The PHP to DB name map for this peer + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + * @deprecated Use the getFieldNames() and translateFieldName() methods instead of this. + */ + public static function getPhpNameMap() + { + if (self::$phpNameMap === null) { + $map = GmailRelabelingPeer::getTableMap(); + $columns = $map->getColumns(); + $nameMap = array(); + foreach ($columns as $column) { + $nameMap[$column->getPhpName()] = $column->getColumnName(); + } + self::$phpNameMap = $nameMap; + } + return self::$phpNameMap; + } + /** + * Translates a fieldname to another type + * + * @param string $name field name + * @param string $fromType One of the class type constants TYPE_PHPNAME, + * TYPE_COLNAME, TYPE_FIELDNAME, TYPE_NUM + * @param string $toType One of the class type constants + * @return string translated name of the field. + */ + static public function translateFieldName($name, $fromType, $toType) + { + $toNames = self::getFieldNames($toType); + $key = isset(self::$fieldKeys[$fromType][$name]) ? self::$fieldKeys[$fromType][$name] : null; + if ($key === null) { + throw new PropelException("'$name' could not be found in the field names of type '$fromType'. These are: " . print_r(self::$fieldKeys[$fromType], true)); + } + return $toNames[$key]; + } + + /** + * Returns an array of of field names. + * + * @param string $type The type of fieldnames to return: + * One of the class type constants TYPE_PHPNAME, + * TYPE_COLNAME, TYPE_FIELDNAME, TYPE_NUM + * @return array A list of field names + */ + + static public function getFieldNames($type = BasePeer::TYPE_PHPNAME) + { + if (!array_key_exists($type, self::$fieldNames)) { + throw new PropelException('Method getFieldNames() expects the parameter $type to be one of the class constants TYPE_PHPNAME, TYPE_COLNAME, TYPE_FIELDNAME, TYPE_NUM. ' . $type . ' was given.'); + } + return self::$fieldNames[$type]; + } + + /** + * Convenience method which changes table.column to alias.column. + * + * Using this method you can maintain SQL abstraction while using column aliases. + * + * $c->addAlias("alias1", TablePeer::TABLE_NAME); + * $c->addJoin(TablePeer::alias("alias1", TablePeer::PRIMARY_KEY_COLUMN), TablePeer::PRIMARY_KEY_COLUMN); + * + * @param string $alias The alias for the current table. + * @param string $column The column name for current table. (i.e. GmailRelabelingPeer::COLUMN_NAME). + * @return string + */ + public static function alias($alias, $column) + { + return str_replace(GmailRelabelingPeer::TABLE_NAME.'.', $alias.'.', $column); + } + + /** + * Add all the columns needed to create a new object. + * + * Note: any columns that were marked with lazyLoad="true" in the + * XML schema will not be added to the select list and only loaded + * on demand. + * + * @param criteria object containing the columns to add. + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + */ + public static function addSelectColumns(Criteria $criteria) + { + + $criteria->addSelectColumn(GmailRelabelingPeer::APP_UID); + + $criteria->addSelectColumn(GmailRelabelingPeer::DEL_INDEX); + + $criteria->addSelectColumn(GmailRelabelingPeer::CURRENT_LAST_INDEX); + + $criteria->addSelectColumn(GmailRelabelingPeer::UNASSIGNED); + + $criteria->addSelectColumn(GmailRelabelingPeer::STATUS); + + $criteria->addSelectColumn(GmailRelabelingPeer::MSG_ERROR); + + } + + const COUNT = 'COUNT(GMAIL_RELABELING.APP_UID)'; + const COUNT_DISTINCT = 'COUNT(DISTINCT GMAIL_RELABELING.APP_UID)'; + + /** + * Returns the number of rows matching criteria. + * + * @param Criteria $criteria + * @param boolean $distinct Whether to select only distinct columns (You can also set DISTINCT modifier in Criteria). + * @param Connection $con + * @return int Number of matching rows. + */ + public static function doCount(Criteria $criteria, $distinct = false, $con = null) + { + // we're going to modify criteria, so copy it first + $criteria = clone $criteria; + + // clear out anything that might confuse the ORDER BY clause + $criteria->clearSelectColumns()->clearOrderByColumns(); + if ($distinct || in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) { + $criteria->addSelectColumn(GmailRelabelingPeer::COUNT_DISTINCT); + } else { + $criteria->addSelectColumn(GmailRelabelingPeer::COUNT); + } + + // just in case we're grouping: add those columns to the select statement + foreach ($criteria->getGroupByColumns() as $column) { + $criteria->addSelectColumn($column); + } + + $rs = GmailRelabelingPeer::doSelectRS($criteria, $con); + if ($rs->next()) { + return $rs->getInt(1); + } else { + // no rows returned; we infer that means 0 matches. + return 0; + } + } + /** + * Method to select one object from the DB. + * + * @param Criteria $criteria object used to create the SELECT statement. + * @param Connection $con + * @return GmailRelabeling + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + */ + public static function doSelectOne(Criteria $criteria, $con = null) + { + $critcopy = clone $criteria; + $critcopy->setLimit(1); + $objects = GmailRelabelingPeer::doSelect($critcopy, $con); + if ($objects) { + return $objects[0]; + } + return null; + } + /** + * Method to do selects. + * + * @param Criteria $criteria The Criteria object used to build the SELECT statement. + * @param Connection $con + * @return array Array of selected Objects + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + */ + public static function doSelect(Criteria $criteria, $con = null) + { + return GmailRelabelingPeer::populateObjects(GmailRelabelingPeer::doSelectRS($criteria, $con)); + } + /** + * Prepares the Criteria object and uses the parent doSelect() + * method to get a ResultSet. + * + * Use this method directly if you want to just get the resultset + * (instead of an array of objects). + * + * @param Criteria $criteria The Criteria object used to build the SELECT statement. + * @param Connection $con the connection to use + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + * @return ResultSet The resultset object with numerically-indexed fields. + * @see BasePeer::doSelect() + */ + public static function doSelectRS(Criteria $criteria, $con = null) + { + if ($con === null) { + $con = Propel::getConnection(self::DATABASE_NAME); + } + + if (!$criteria->getSelectColumns()) { + $criteria = clone $criteria; + GmailRelabelingPeer::addSelectColumns($criteria); + } + + // Set the correct dbName + $criteria->setDbName(self::DATABASE_NAME); + + // BasePeer returns a Creole ResultSet, set to return + // rows indexed numerically. + return BasePeer::doSelect($criteria, $con); + } + /** + * The returned array will contain objects of the default type or + * objects that inherit from the default. + * + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + */ + public static function populateObjects(ResultSet $rs) + { + $results = array(); + + // set the class once to avoid overhead in the loop + $cls = GmailRelabelingPeer::getOMClass(); + $cls = Propel::import($cls); + // populate the object(s) + while ($rs->next()) { + + $obj = new $cls(); + $obj->hydrate($rs); + $results[] = $obj; + + } + return $results; + } + /** + * Returns the TableMap related to this peer. + * This method is not needed for general use but a specific application could have a need. + * @return TableMap + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + */ + public static function getTableMap() + { + return Propel::getDatabaseMap(self::DATABASE_NAME)->getTable(self::TABLE_NAME); + } + + /** + * The class that the Peer will make instances of. + * + * This uses a dot-path notation which is tranalted into a path + * relative to a location on the PHP include_path. + * (e.g. path.to.MyClass -> 'path/to/MyClass.php') + * + * @return string path.to.ClassName + */ + public static function getOMClass() + { + return GmailRelabelingPeer::CLASS_DEFAULT; + } + + /** + * Method perform an INSERT on the database, given a GmailRelabeling or Criteria object. + * + * @param mixed $values Criteria or GmailRelabeling object containing data that is used to create the INSERT statement. + * @param Connection $con the connection to use + * @return mixed The new primary key. + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + */ + public static function doInsert($values, $con = null) + { + if ($con === null) { + $con = Propel::getConnection(self::DATABASE_NAME); + } + + if ($values instanceof Criteria) { + $criteria = clone $values; // rename for clarity + } else { + $criteria = $values->buildCriteria(); // build Criteria from GmailRelabeling object + } + + + // Set the correct dbName + $criteria->setDbName(self::DATABASE_NAME); + + try { + // use transaction because $criteria could contain info + // for more than one table (I guess, conceivably) + $con->begin(); + $pk = BasePeer::doInsert($criteria, $con); + $con->commit(); + } catch (PropelException $e) { + $con->rollback(); + throw $e; + } + + return $pk; + } + + /** + * Method perform an UPDATE on the database, given a GmailRelabeling or Criteria object. + * + * @param mixed $values Criteria or GmailRelabeling object containing data create the UPDATE statement. + * @param Connection $con The connection to use (specify Connection exert more control over transactions). + * @return int The number of affected rows (if supported by underlying database driver). + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + */ + public static function doUpdate($values, $con = null) + { + if ($con === null) { + $con = Propel::getConnection(self::DATABASE_NAME); + } + + $selectCriteria = new Criteria(self::DATABASE_NAME); + + if ($values instanceof Criteria) { + $criteria = clone $values; // rename for clarity + + $comparison = $criteria->getComparison(GmailRelabelingPeer::APP_UID); + $selectCriteria->add(GmailRelabelingPeer::APP_UID, $criteria->remove(GmailRelabelingPeer::APP_UID), $comparison); + + $comparison = $criteria->getComparison(GmailRelabelingPeer::DEL_INDEX); + $selectCriteria->add(GmailRelabelingPeer::DEL_INDEX, $criteria->remove(GmailRelabelingPeer::DEL_INDEX), $comparison); + + } else { + $criteria = $values->buildCriteria(); // gets full criteria + $selectCriteria = $values->buildPkeyCriteria(); // gets criteria w/ primary key(s) + } + + // set the correct dbName + $criteria->setDbName(self::DATABASE_NAME); + + return BasePeer::doUpdate($selectCriteria, $criteria, $con); + } + + /** + * Method to DELETE all rows from the GMAIL_RELABELING table. + * + * @return int The number of affected rows (if supported by underlying database driver). + */ + public static function doDeleteAll($con = null) + { + if ($con === null) { + $con = Propel::getConnection(self::DATABASE_NAME); + } + $affectedRows = 0; // initialize var to track total num of affected rows + try { + // use transaction because $criteria could contain info + // for more than one table or we could emulating ON DELETE CASCADE, etc. + $con->begin(); + $affectedRows += BasePeer::doDeleteAll(GmailRelabelingPeer::TABLE_NAME, $con); + $con->commit(); + return $affectedRows; + } catch (PropelException $e) { + $con->rollback(); + throw $e; + } + } + + /** + * Method perform a DELETE on the database, given a GmailRelabeling or Criteria object OR a primary key value. + * + * @param mixed $values Criteria or GmailRelabeling object or primary key or array of primary keys + * which is used to create the DELETE statement + * @param Connection $con the connection to use + * @return int The number of affected rows (if supported by underlying database driver). + * This includes CASCADE-related rows + * if supported by native driver or if emulated using Propel. + * @throws PropelException Any exceptions caught during processing will be + * rethrown wrapped into a PropelException. + */ + public static function doDelete($values, $con = null) + { + if ($con === null) { + $con = Propel::getConnection(GmailRelabelingPeer::DATABASE_NAME); + } + + if ($values instanceof Criteria) { + $criteria = clone $values; // rename for clarity + } elseif ($values instanceof GmailRelabeling) { + + $criteria = $values->buildPkeyCriteria(); + } else { + // it must be the primary key + $criteria = new Criteria(self::DATABASE_NAME); + // primary key is composite; we therefore, expect + // the primary key passed to be an array of pkey + // values + if (count($values) == count($values, COUNT_RECURSIVE)) { + // array is not multi-dimensional + $values = array($values); + } + $vals = array(); + foreach ($values as $value) { + + $vals[0][] = $value[0]; + $vals[1][] = $value[1]; + } + + $criteria->add(GmailRelabelingPeer::APP_UID, $vals[0], Criteria::IN); + $criteria->add(GmailRelabelingPeer::DEL_INDEX, $vals[1], Criteria::IN); + } + + // Set the correct dbName + $criteria->setDbName(self::DATABASE_NAME); + + $affectedRows = 0; // initialize var to track total num of affected rows + + try { + // use transaction because $criteria could contain info + // for more than one table or we could emulating ON DELETE CASCADE, etc. + $con->begin(); + + $affectedRows += BasePeer::doDelete($criteria, $con); + $con->commit(); + return $affectedRows; + } catch (PropelException $e) { + $con->rollback(); + throw $e; + } + } + + /** + * Validates all modified columns of given GmailRelabeling object. + * If parameter $columns is either a single column name or an array of column names + * than only those columns are validated. + * + * NOTICE: This does not apply to primary or foreign keys for now. + * + * @param GmailRelabeling $obj The object to validate. + * @param mixed $cols Column name or array of column names. + * + * @return mixed TRUE if all columns are valid or the error message of the first invalid column. + */ + public static function doValidate(GmailRelabeling $obj, $cols = null) + { + $columns = array(); + + if ($cols) { + $dbMap = Propel::getDatabaseMap(GmailRelabelingPeer::DATABASE_NAME); + $tableMap = $dbMap->getTable(GmailRelabelingPeer::TABLE_NAME); + + if (! is_array($cols)) { + $cols = array($cols); + } + + foreach ($cols as $colName) { + if ($tableMap->containsColumn($colName)) { + $get = 'get' . $tableMap->getColumn($colName)->getPhpName(); + $columns[$colName] = $obj->$get(); + } + } + } else { + + } + + return BasePeer::doValidate(GmailRelabelingPeer::DATABASE_NAME, GmailRelabelingPeer::TABLE_NAME, $columns); + } + + /** + * Retrieve object using using composite pkey values. + * @param string $app_uid + * @param int $del_index + * @param Connection $con + * @return GmailRelabeling + */ + public static function retrieveByPK($app_uid, $del_index, $con = null) + { + if ($con === null) { + $con = Propel::getConnection(self::DATABASE_NAME); + } + $criteria = new Criteria(); + $criteria->add(GmailRelabelingPeer::APP_UID, $app_uid); + $criteria->add(GmailRelabelingPeer::DEL_INDEX, $del_index); + $v = GmailRelabelingPeer::doSelect($criteria, $con); + + return !empty($v) ? $v[0] : null; + } +} + + +// static code to register the map builder for this Peer with the main Propel class +if (Propel::isInit()) { + // the MapBuilder classes register themselves with Propel during initialization + // so we need to load them here. + try { + BaseGmailRelabelingPeer::getMapBuilder(); + } catch (Exception $e) { + Propel::log('Could not initialize Peer: ' . $e->getMessage(), Propel::LOG_ERR); + } +} else { + // even if Propel is not yet initialized, the map builder class can be registered + // now and then it will be loaded when Propel initializes. + require_once 'classes/model/map/GmailRelabelingMapBuilder.php'; + Propel::registerMapBuilder('classes.model.map.GmailRelabelingMapBuilder'); +} + diff --git a/workflow/engine/config/schema.xml b/workflow/engine/config/schema.xml index bd9971362..d5afc40c6 100755 --- a/workflow/engine/config/schema.xml +++ b/workflow/engine/config/schema.xml @@ -5246,4 +5246,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + +
diff --git a/workflow/engine/data/mysql/schema.sql b/workflow/engine/data/mysql/schema.sql index 2b82268bf..9efa03817 100755 --- a/workflow/engine/data/mysql/schema.sql +++ b/workflow/engine/data/mysql/schema.sql @@ -2930,3 +2930,23 @@ CREATE TABLE `NOTIFICATION_DEVICE` )ENGINE=InnoDB DEFAULT CHARSET='utf8' COMMENT='Definitions Notification device.'; # This restores the fkey checks, after having unset them earlier # SET FOREIGN_KEY_CHECKS = 1; + + + +#----------------------------------------------------------------------------- +#-- GMAIL_RELABELING +#----------------------------------------------------------------------------- + +CREATE TABLE `GMAIL_RELABELING` ( + `APP_UID` VARCHAR(32) NOT NULL DEFAULT '', + `DEL_INDEX` INT(11) NOT NULL DEFAULT '0', + `CURRENT_LAST_INDEX` INT(11) NOT NULL DEFAULT '0', + `UNASSIGNED` INT(11) NOT NULL DEFAULT '0', + `STATUS` VARCHAR(32) NOT NULL DEFAULT 'pending', + `MSG_ERROR` TEXT NULL, + PRIMARY KEY (`APP_UID`, `DEL_INDEX`), + KEY `indexStatus` (`STATUS`) +)ENGINE=InnoDB DEFAULT CHARSET='utf8' COMMENT='Task to synchronize Gmail Labels'; +# This restores the fkey checks, after having unset them earlier +# SET FOREIGN_KEY_CHECKS = 1; + diff --git a/workflow/engine/methods/cases/cases_CatchExecute.php b/workflow/engine/methods/cases/cases_CatchExecute.php index 060a09d5e..76f0cfa37 100755 --- a/workflow/engine/methods/cases/cases_CatchExecute.php +++ b/workflow/engine/methods/cases/cases_CatchExecute.php @@ -71,8 +71,7 @@ if ($aDelegation['USR_UID'] == "") { if(array_key_exists('gmail',$_SESSION) && $_SESSION['gmail'] == 1){ require_once (PATH_HOME . "engine" . PATH_SEP . "classes" . PATH_SEP . "class.labelsGmail.php"); $labGmail = new labelsGmail(); - $oResponse = $labGmail->setLabels($sAppUid, $iDelIndex, -1, true); - + $labGmail->addRelabelingToQueue($sAppUid, $iDelIndex, -1, true); die( '' ); diff --git a/workflow/engine/methods/cases/derivatedGmail.php b/workflow/engine/methods/cases/derivatedGmail.php index c3769774f..6fb43eb70 100644 --- a/workflow/engine/methods/cases/derivatedGmail.php +++ b/workflow/engine/methods/cases/derivatedGmail.php @@ -32,7 +32,7 @@ foreach ($appDelPrev as $app){ require_once (PATH_HOME . "engine" . PATH_SEP . "classes" . PATH_SEP . "class.labelsGmail.php"); $oLabels = new labelsGmail(); -$oResponse = $oLabels->setLabels($caseId, $actualIndex, $actualLastIndex, false); +$oLabels->addRelabelingToQueue($caseId, $actualIndex, $actualLastIndex, false); G::LoadClass( "AppDocumentDrive" ); $drive = new AppDocumentDrive();