fernando/luos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

HOR-935 Retirar las notificaciones Mobile del proceso de derivación y ejecutarlas asincronamente

Browse Source 
up observations by QA
This commit is contained in:
Ronald Q
2016-06-02 11:27:55 -04:00
parent 012fa791f2
commit f20b5d0788
13 changed files with 1840 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
workflow/engine/bin/cron.php
View File

@@ -8,7 +8,8 @@ try {
'cron' => ['title' => 'CRON'],
'ldapcron' => ['title' => 'LDAP Advanced CRON'],
'messageeventcron' => ['title' => 'Message-Event CRON'],
'timereventcron' => ['title' => 'Timer-Event CRON']
'timereventcron' => ['title' => 'Timer-Event CRON'],
'sendnotificationscron' => ['title' => 'Send-Notifications CRON']
];
//Define constants

50
workflow/engine/bin/cron_single.php
View File

@@ -304,6 +304,9 @@ try {
$timerEvent->startContinueCaseByTimerEvent(date('Y-m-d H:i:s'), true);
break;
case 'sendnotificationscron':
sendNotifications();
break;
}
} catch (Exception $e) {
echo $e->getMessage() . "\n";
@@ -1036,3 +1039,50 @@ function synchronizeGmailLabels()
}
}
/*----------------------------------********---------------------------------*/
function sendNotifications()
{
try {
global $argvx;
if ($argvx != "" && strpos($argvx, "send-notifications") === false) {
return false;
}
setExecutionMessage("Resending Notifications");
setExecutionResultMessage("PROCESSING");
$notQueue = new \NotificationQueue();
$notificationsAndroid = $notQueue->loadStatusDeviceType('pending', 'android');
if ($notificationsAndroid) {
setExecutionMessage("|-- Send Android's Notifications");
$n = 0;
foreach ($notificationsAndroid as $key => $item) {
$oNotification = new \ProcessMaker\BusinessModel\Light\PushMessageAndroid();
$oNotification->setSettingNotification();
$oNotification->setDevices(unserialize($item['DEV_UID']));
$response['android'] = $oNotification->send($item['NOT_MSG'], unserialize($item['NOT_DATA']));
$notQueue = new \NotificationQueue();
$notQueue->changeStatusSent($item['NOT_UID']);
$n += $oNotification->getNumberDevices();
}
setExecutionResultMessage("Processed $n");
}
$notificationsApple = $notQueue->loadStatusDeviceType('pending', 'apple');
if($notificationsApple) {
setExecutionMessage("|-- Send Apple Notifications");
$n = 0;
foreach ($notificationsApple as $key => $item) {
$oNotification = new \ProcessMaker\BusinessModel\Light\PushMessageIOS();
$oNotification->setSettingNotification();
$oNotification->setDevices(unserialize($item['DEV_UID']));
$response['apple'] = $oNotification->send($item['NOT_MSG'], unserialize($item['NOT_DATA']));
$notQueue = new \NotificationQueue();
$notQueue->changeStatusSent($item['NOT_UID']);
$n += $oNotification->getNumberDevices();
}
setExecutionResultMessage("Processed $n");
}
} catch (Exception $e) {
setExecutionResultMessage("WITH ERRORS", "error");
eprintln(" '-" . $e->getMessage(), "red");
saveLog("ExecuteSendNotifications", "error", "Error when sending notifications " . $e->getMessage());
}
}

2
workflow/engine/bin/sendnotificationscron.php Normal file
View File

@@ -0,0 +1,2 @@
<?php
require_once("cron.php");

107
workflow/engine/classes/model/NotificationQueue.php Normal file
View File

@@ -0,0 +1,107 @@
<?php
require_once 'classes/model/om/BaseNotificationQueue.php';
/**
* Skeleton subclass for representing a row from the 'NOTIFICATION_QUEUE' table.
*
*
*
* You should add additional methods to this class to meet the
* application requirements. This class will only be generated as
* long as it does not already exist in the output directory.
*
* @package classes.model
*/
class NotificationQueue extends BaseNotificationQueue
{
public function create(array $arrayData)
{
$cnn = Propel::getConnection(NotificationDevicePeer::DATABASE_NAME);
try {
$this->setNotUid(G::generateUniqueID());
$this->setDevType($arrayData['DEV_TYPE']);
$this->setDevUid($arrayData['DEV_UID']);
$this->setNotMsg($arrayData['NOT_MSG']);
$this->setNotData($arrayData['NOT_DATA']);
$this->setNotStatus($arrayData['NOT_STATUS']);
$this->setNotSendDate('now');
if ($this->validate()) {
$cnn->begin();
$result = $this->save();
$cnn->commit();
} else {
throw new Exception(G::LoadTranslation("ID_RECORD_CANNOT_BE_CREATED"));
}
} catch (Exception $e) {
$cnn->rollback();
throw $e;
}
return $result;
}
public function loadStatus($status)
{
try {
$criteria = new Criteria();
$criteria->clearSelectColumns();
$criteria->add(NotificationQueuePeer::NOT_STATUS, $status, Criteria::EQUAL);
$rs = NotificationQueuePeer::doSelectRS($criteria);
$rs->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$notifications = array();
while ($rs->next()) {
$row = $rs->getRow();
$notifications[] = $row;
}
} catch (Exception $error) {
throw $error;
}
return $notifications;
}
public function loadStatusDeviceType($status, $devType)
{
try {
$criteria = new Criteria();
$criteria->clearSelectColumns();
$criteria->add(NotificationQueuePeer::NOT_STATUS, $status, Criteria::EQUAL);
$criteria->add(NotificationQueuePeer::DEV_TYPE, $devType, Criteria::EQUAL);
$rs = NotificationQueuePeer::doSelectRS($criteria);
$rs->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$notifications = array();
while ($rs->next()) {
$row = $rs->getRow();
$notifications[] = $row;
}
} catch (Exception $error) {
throw $error;
}
return $notifications;
}
public function changeStatusSent($not_uid)
{
$cnn = Propel::getConnection(NotificationDevicePeer::DATABASE_NAME);
$rs = NotificationQueuePeer::retrieveByPK($not_uid);
try {
$arrayData['NOT_STATUS'] = "sent";
$arrayData['NOT_SEND_DATE'] = date('Y-m-d H:i:s');
$rs->fromArray($arrayData, BasePeer::TYPE_FIELDNAME);
if ($this->validate()) {
$cnn->begin();
$result = $rs->save();
$cnn->commit();
} else {
throw new Exception(G::LoadTranslation("ID_RECORD_CANNOT_BE_CREATED"));
}
} catch (Exception $e) {
$cnn->rollback();
throw $e;
}
return $result;
}
} // NotificationQueue

23
workflow/engine/classes/model/NotificationQueuePeer.php Normal file
View File

@@ -0,0 +1,23 @@
<?php
// include base peer class
require_once 'classes/model/om/BaseNotificationQueuePeer.php';
// include object class
include_once 'classes/model/NotificationQueue.php';
/**
* Skeleton subclass for performing query and update operations on the 'NOTIFICATION_QUEUE' table.
*
*
*
* You should add additional methods to this class to meet the
* application requirements. This class will only be generated as
* long as it does not already exist in the output directory.
*
* @package classes.model
*/
class NotificationQueuePeer extends BaseNotificationQueuePeer {
} // NotificationQueuePeer

84
workflow/engine/classes/model/map/NotificationQueueMapBuilder.php Normal file
View File

@@ -0,0 +1,84 @@
<?php
require_once 'propel/map/MapBuilder.php';
include_once 'creole/CreoleTypes.php';
/**
* This class adds structure of 'NOTIFICATION_QUEUE' table to 'workflow' DatabaseMap object.
*
*
*
* These statically-built map classes are used by Propel to do runtime db structure discovery.
* For example, the createSelectSql() method checks the type of a given column used in an
* ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
* (i.e. if it's a text column type).
*
* @package workflow.classes.model.map
*/
class NotificationQueueMapBuilder
{
/**
* The (dot-path) name of this class
*/
const CLASS_NAME = 'classes.model.map.NotificationQueueMapBuilder';
/**
* The database map.
*/
private $dbMap;
/**
* Tells us if this DatabaseMapBuilder is built so that we
* don't have to re-build it every time.
*
* @return boolean true if this DatabaseMapBuilder is built, false otherwise.
*/
public function isBuilt()
{
return ($this->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('NOTIFICATION_QUEUE');
$tMap->setPhpName('NotificationQueue');
$tMap->setUseIdGenerator(false);
$tMap->addPrimaryKey('NOT_UID', 'NotUid', 'string', CreoleTypes::VARCHAR, true, 32);
$tMap->addColumn('DEV_TYPE', 'DevType', 'string', CreoleTypes::VARCHAR, true, 50);
$tMap->addColumn('DEV_UID', 'DevUid', 'string', CreoleTypes::LONGVARCHAR, true, null);
$tMap->addColumn('NOT_MSG', 'NotMsg', 'string', CreoleTypes::LONGVARCHAR, true, null);
$tMap->addColumn('NOT_DATA', 'NotData', 'string', CreoleTypes::LONGVARCHAR, true, null);
$tMap->addColumn('NOT_STATUS', 'NotStatus', 'string', CreoleTypes::VARCHAR, true, 150);
$tMap->addColumn('NOT_SEND_DATE', 'NotSendDate', 'int', CreoleTypes::TIMESTAMP, true, null);
} // doBuild()
} // NotificationQueueMapBuilder

886
workflow/engine/classes/model/om/BaseNotificationQueue.php Normal file
View File

@@ -0,0 +1,886 @@
<?php
require_once 'propel/om/BaseObject.php';
require_once 'propel/om/Persistent.php';
include_once 'propel/util/Criteria.php';
include_once 'classes/model/NotificationQueuePeer.php';
/**
* Base class that represents a row from the 'NOTIFICATION_QUEUE' table.
*
*
*
* @package workflow.classes.model.om
*/
abstract class BaseNotificationQueue extends BaseObject implements Persistent
{
/**
* The Peer class.
* Instance provides a convenient way of calling static methods on a class
* that calling code may not be able to identify.
* @var NotificationQueuePeer
*/
protected static $peer;
/**
* The value for the not_uid field.
* @var string
*/
protected $not_uid;
/**
* The value for the dev_type field.
* @var string
*/
protected $dev_type;
/**
* The value for the dev_uid field.
* @var string
*/
protected $dev_uid;
/**
* The value for the not_msg field.
* @var string
*/
protected $not_msg;
/**
* The value for the not_data field.
* @var string
*/
protected $not_data;
/**
* The value for the not_status field.
* @var string
*/
protected $not_status;
/**
* The value for the not_send_date field.
* @var int
*/
protected $not_send_date;
/**
* Flag to prevent endless save loop, if this object is referenced
* by another object which falls in this transaction.
* @var boolean
*/
protected $alreadyInSave = false;
/**
* Flag to prevent endless validation loop, if this object is referenced
* by another object which falls in this transaction.
* @var boolean
*/
protected $alreadyInValidation = false;
/**
* Get the [not_uid] column value.
*
* @return string
*/
public function getNotUid()
{
return $this->not_uid;
}
/**
* Get the [dev_type] column value.
*
* @return string
*/
public function getDevType()
{
return $this->dev_type;
}
/**
* Get the [dev_uid] column value.
*
* @return string
*/
public function getDevUid()
{
return $this->dev_uid;
}
/**
* Get the [not_msg] column value.
*
* @return string
*/
public function getNotMsg()
{
return $this->not_msg;
}
/**
* Get the [not_data] column value.
*
* @return string
*/
public function getNotData()
{
return $this->not_data;
}
/**
* Get the [not_status] column value.
*
* @return string
*/
public function getNotStatus()
{
return $this->not_status;
}
/**
* Get the [optionally formatted] [not_send_date] column value.
*
* @param string $format The date/time format string (either date()-style or strftime()-style).
* If format is NULL, then the integer unix timestamp will be returned.
* @return mixed Formatted date/time value as string or integer unix timestamp (if format is NULL).
* @throws PropelException - if unable to convert the date/time to timestamp.
*/
public function getNotSendDate($format = 'Y-m-d H:i:s')
{
if ($this->not_send_date === null || $this->not_send_date === '') {
return null;
} elseif (!is_int($this->not_send_date)) {
// a non-timestamp value was set externally, so we convert it
$ts = strtotime($this->not_send_date);
if ($ts === -1 || $ts === false) {
throw new PropelException("Unable to parse value of [not_send_date] as date/time value: " .
var_export($this->not_send_date, true));
}
} else {
$ts = $this->not_send_date;
}
if ($format === null) {
return $ts;
} elseif (strpos($format, '%') !== false) {
return strftime($format, $ts);
} else {
return date($format, $ts);
}
}
/**
* Set the value of [not_uid] column.
*
* @param string $v new value
* @return void
*/
public function setNotUid($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->not_uid !== $v) {
$this->not_uid = $v;
$this->modifiedColumns[] = NotificationQueuePeer::NOT_UID;
}
} // setNotUid()
/**
* Set the value of [dev_type] column.
*
* @param string $v new value
* @return void
*/
public function setDevType($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->dev_type !== $v) {
$this->dev_type = $v;
$this->modifiedColumns[] = NotificationQueuePeer::DEV_TYPE;
}
} // setDevType()
/**
* Set the value of [dev_uid] column.
*
* @param string $v new value
* @return void
*/
public function setDevUid($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->dev_uid !== $v) {
$this->dev_uid = $v;
$this->modifiedColumns[] = NotificationQueuePeer::DEV_UID;
}
} // setDevUid()
/**
* Set the value of [not_msg] column.
*
* @param string $v new value
* @return void
*/
public function setNotMsg($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->not_msg !== $v) {
$this->not_msg = $v;
$this->modifiedColumns[] = NotificationQueuePeer::NOT_MSG;
}
} // setNotMsg()
/**
* Set the value of [not_data] column.
*
* @param string $v new value
* @return void
*/
public function setNotData($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->not_data !== $v) {
$this->not_data = $v;
$this->modifiedColumns[] = NotificationQueuePeer::NOT_DATA;
}
} // setNotData()
/**
* Set the value of [not_status] column.
*
* @param string $v new value
* @return void
*/
public function setNotStatus($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->not_status !== $v) {
$this->not_status = $v;
$this->modifiedColumns[] = NotificationQueuePeer::NOT_STATUS;
}
} // setNotStatus()
/**
* Set the value of [not_send_date] column.
*
* @param int $v new value
* @return void
*/
public function setNotSendDate($v)
{
if ($v !== null && !is_int($v)) {
$ts = strtotime($v);
//Date/time accepts null values
if ($v == '') {
$ts = null;
}
if ($ts === -1 || $ts === false) {
throw new PropelException("Unable to parse date/time value for [not_send_date] from input: " .
var_export($v, true));
}
} else {
$ts = $v;
}
if ($this->not_send_date !== $ts) {
$this->not_send_date = $ts;
$this->modifiedColumns[] = NotificationQueuePeer::NOT_SEND_DATE;
}
} // setNotSendDate()
/**
* 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->not_uid = $rs->getString($startcol + 0);
$this->dev_type = $rs->getString($startcol + 1);
$this->dev_uid = $rs->getString($startcol + 2);
$this->not_msg = $rs->getString($startcol + 3);
$this->not_data = $rs->getString($startcol + 4);
$this->not_status = $rs->getString($startcol + 5);
$this->not_send_date = $rs->getTimestamp($startcol + 6, null);
$this->resetModified();
$this->setNew(false);
// FIXME - using NUM_COLUMNS may be clearer.
return $startcol + 7; // 7 = NotificationQueuePeer::NUM_COLUMNS - NotificationQueuePeer::NUM_LAZY_LOAD_COLUMNS).
} catch (Exception $e) {
throw new PropelException("Error populating NotificationQueue 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(NotificationQueuePeer::DATABASE_NAME);
}
try {
$con->begin();
NotificationQueuePeer::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(NotificationQueuePeer::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 = NotificationQueuePeer::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 += NotificationQueuePeer::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 <code>true</code> is returned; otherwise
* an aggreagated array of ValidationFailed objects will be returned.
*
* @param array $columns Array of column names to validate.
* @return mixed <code>true</code> if all validations pass;
array of <code>ValidationFailed</code> objects otherwise.
*/
protected function doValidate($columns = null)
{
if (!$this->alreadyInValidation) {
$this->alreadyInValidation = true;
$retval = null;
$failureMap = array();
if (($retval = NotificationQueuePeer::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 = NotificationQueuePeer::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->getNotUid();
break;
case 1:
return $this->getDevType();
break;
case 2:
return $this->getDevUid();
break;
case 3:
return $this->getNotMsg();
break;
case 4:
return $this->getNotData();
break;
case 5:
return $this->getNotStatus();
break;
case 6:
return $this->getNotSendDate();
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 = NotificationQueuePeer::getFieldNames($keyType);
$result = array(
$keys[0] => $this->getNotUid(),
$keys[1] => $this->getDevType(),
$keys[2] => $this->getDevUid(),
$keys[3] => $this->getNotMsg(),
$keys[4] => $this->getNotData(),
$keys[5] => $this->getNotStatus(),
$keys[6] => $this->getNotSendDate(),
);
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 = NotificationQueuePeer::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->setNotUid($value);
break;
case 1:
$this->setDevType($value);
break;
case 2:
$this->setDevUid($value);
break;
case 3:
$this->setNotMsg($value);
break;
case 4:
$this->setNotData($value);
break;
case 5:
$this->setNotStatus($value);
break;
case 6:
$this->setNotSendDate($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 = NotificationQueuePeer::getFieldNames($keyType);
if (array_key_exists($keys[0], $arr)) {
$this->setNotUid($arr[$keys[0]]);
}
if (array_key_exists($keys[1], $arr)) {
$this->setDevType($arr[$keys[1]]);
}
if (array_key_exists($keys[2], $arr)) {
$this->setDevUid($arr[$keys[2]]);
}
if (array_key_exists($keys[3], $arr)) {
$this->setNotMsg($arr[$keys[3]]);
}
if (array_key_exists($keys[4], $arr)) {
$this->setNotData($arr[$keys[4]]);
}
if (array_key_exists($keys[5], $arr)) {
$this->setNotStatus($arr[$keys[5]]);
}
if (array_key_exists($keys[6], $arr)) {
$this->setNotSendDate($arr[$keys[6]]);
}
}
/**
* 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(NotificationQueuePeer::DATABASE_NAME);
if ($this->isColumnModified(NotificationQueuePeer::NOT_UID)) {
$criteria->add(NotificationQueuePeer::NOT_UID, $this->not_uid);
}
if ($this->isColumnModified(NotificationQueuePeer::DEV_TYPE)) {
$criteria->add(NotificationQueuePeer::DEV_TYPE, $this->dev_type);
}
if ($this->isColumnModified(NotificationQueuePeer::DEV_UID)) {
$criteria->add(NotificationQueuePeer::DEV_UID, $this->dev_uid);
}
if ($this->isColumnModified(NotificationQueuePeer::NOT_MSG)) {
$criteria->add(NotificationQueuePeer::NOT_MSG, $this->not_msg);
}
if ($this->isColumnModified(NotificationQueuePeer::NOT_DATA)) {
$criteria->add(NotificationQueuePeer::NOT_DATA, $this->not_data);
}
if ($this->isColumnModified(NotificationQueuePeer::NOT_STATUS)) {
$criteria->add(NotificationQueuePeer::NOT_STATUS, $this->not_status);
}
if ($this->isColumnModified(NotificationQueuePeer::NOT_SEND_DATE)) {
$criteria->add(NotificationQueuePeer::NOT_SEND_DATE, $this->not_send_date);
}
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(NotificationQueuePeer::DATABASE_NAME);
$criteria->add(NotificationQueuePeer::NOT_UID, $this->not_uid);
return $criteria;
}
/**
* Returns the primary key for this object (row).
* @return string
*/
public function getPrimaryKey()
{
return $this->getNotUid();
}
/**
* Generic method to set the primary key (not_uid column).
*
* @param string $key Primary key.
* @return void
*/
public function setPrimaryKey($key)
{
$this->setNotUid($key);
}
/**
* 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 NotificationQueue (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->setDevType($this->dev_type);
$copyObj->setDevUid($this->dev_uid);
$copyObj->setNotMsg($this->not_msg);
$copyObj->setNotData($this->not_data);
$copyObj->setNotStatus($this->not_status);
$copyObj->setNotSendDate($this->not_send_date);
$copyObj->setNew(true);
$copyObj->setNotUid(NULL); // 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 NotificationQueue 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 NotificationQueuePeer
*/
public function getPeer()
{
if (self::$peer === null) {
self::$peer = new NotificationQueuePeer();
}
return self::$peer;
}
}

597
workflow/engine/classes/model/om/BaseNotificationQueuePeer.php Normal file
View File

@@ -0,0 +1,597 @@
<?php
require_once 'propel/util/BasePeer.php';
// The object class -- needed for instanceof checks in this class.
// actual class may be a subclass -- as returned by NotificationQueuePeer::getOMClass()
include_once 'classes/model/NotificationQueue.php';
/**
* Base static class for performing query and update operations on the 'NOTIFICATION_QUEUE' table.
*
*
*
* @package workflow.classes.model.om
*/
abstract class BaseNotificationQueuePeer
{
/** the default database name for this class */
const DATABASE_NAME = 'workflow';
/** the table name for this class */
const TABLE_NAME = 'NOTIFICATION_QUEUE';
/** A class that can be returned by this peer. */
const CLASS_DEFAULT = 'classes.model.NotificationQueue';
/** The total number of columns. */
const NUM_COLUMNS = 7;
/** The number of lazy-loaded columns. */
const NUM_LAZY_LOAD_COLUMNS = 0;
/** the column name for the NOT_UID field */
const NOT_UID = 'NOTIFICATION_QUEUE.NOT_UID';
/** the column name for the DEV_TYPE field */
const DEV_TYPE = 'NOTIFICATION_QUEUE.DEV_TYPE';
/** the column name for the DEV_UID field */
const DEV_UID = 'NOTIFICATION_QUEUE.DEV_UID';
/** the column name for the NOT_MSG field */
const NOT_MSG = 'NOTIFICATION_QUEUE.NOT_MSG';
/** the column name for the NOT_DATA field */
const NOT_DATA = 'NOTIFICATION_QUEUE.NOT_DATA';
/** the column name for the NOT_STATUS field */
const NOT_STATUS = 'NOTIFICATION_QUEUE.NOT_STATUS';
/** the column name for the NOT_SEND_DATE field */
const NOT_SEND_DATE = 'NOTIFICATION_QUEUE.NOT_SEND_DATE';
/** The PHP to DB Name Mapping */
private static $phpNameMap = null;
/**
* holds an array of fieldnames
*
* first dimension keys are the type constants
* e.g. self::$fieldNames[self::TYPE_PHPNAME][0] = 'Id'
*/
private static $fieldNames = array (
BasePeer::TYPE_PHPNAME => array ('NotUid', 'DevType', 'DevUid', 'NotMsg', 'NotData', 'NotStatus', 'NotSendDate', ),
BasePeer::TYPE_COLNAME => array (NotificationQueuePeer::NOT_UID, NotificationQueuePeer::DEV_TYPE, NotificationQueuePeer::DEV_UID, NotificationQueuePeer::NOT_MSG, NotificationQueuePeer::NOT_DATA, NotificationQueuePeer::NOT_STATUS, NotificationQueuePeer::NOT_SEND_DATE, ),
BasePeer::TYPE_FIELDNAME => array ('NOT_UID', 'DEV_TYPE', 'DEV_UID', 'NOT_MSG', 'NOT_DATA', 'NOT_STATUS', 'NOT_SEND_DATE', ),
BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, )
);
/**
* 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 ('NotUid' => 0, 'DevType' => 1, 'DevUid' => 2, 'NotMsg' => 3, 'NotData' => 4, 'NotStatus' => 5, 'NotSendDate' => 6, ),
BasePeer::TYPE_COLNAME => array (NotificationQueuePeer::NOT_UID => 0, NotificationQueuePeer::DEV_TYPE => 1, NotificationQueuePeer::DEV_UID => 2, NotificationQueuePeer::NOT_MSG => 3, NotificationQueuePeer::NOT_DATA => 4, NotificationQueuePeer::NOT_STATUS => 5, NotificationQueuePeer::NOT_SEND_DATE => 6, ),
BasePeer::TYPE_FIELDNAME => array ('NOT_UID' => 0, 'DEV_TYPE' => 1, 'DEV_UID' => 2, 'NOT_MSG' => 3, 'NOT_DATA' => 4, 'NOT_STATUS' => 5, 'NOT_SEND_DATE' => 6, ),
BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, )
);
/**
* @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/NotificationQueueMapBuilder.php';
return BasePeer::getMapBuilder('classes.model.map.NotificationQueueMapBuilder');
}
/**
* 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 = NotificationQueuePeer::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.
* <code>
* $c->addAlias("alias1", TablePeer::TABLE_NAME);
* $c->addJoin(TablePeer::alias("alias1", TablePeer::PRIMARY_KEY_COLUMN), TablePeer::PRIMARY_KEY_COLUMN);
* </code>
* @param string $alias The alias for the current table.
* @param string $column The column name for current table. (i.e. NotificationQueuePeer::COLUMN_NAME).
* @return string
*/
public static function alias($alias, $column)
{
return str_replace(NotificationQueuePeer::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(NotificationQueuePeer::NOT_UID);
$criteria->addSelectColumn(NotificationQueuePeer::DEV_TYPE);
$criteria->addSelectColumn(NotificationQueuePeer::DEV_UID);
$criteria->addSelectColumn(NotificationQueuePeer::NOT_MSG);
$criteria->addSelectColumn(NotificationQueuePeer::NOT_DATA);
$criteria->addSelectColumn(NotificationQueuePeer::NOT_STATUS);
$criteria->addSelectColumn(NotificationQueuePeer::NOT_SEND_DATE);
}
const COUNT = 'COUNT(NOTIFICATION_QUEUE.NOT_UID)';
const COUNT_DISTINCT = 'COUNT(DISTINCT NOTIFICATION_QUEUE.NOT_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(NotificationQueuePeer::COUNT_DISTINCT);
} else {
$criteria->addSelectColumn(NotificationQueuePeer::COUNT);
}
// just in case we're grouping: add those columns to the select statement
foreach ($criteria->getGroupByColumns() as $column) {
$criteria->addSelectColumn($column);
}
$rs = NotificationQueuePeer::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 NotificationQueue
* @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 = NotificationQueuePeer::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 NotificationQueuePeer::populateObjects(NotificationQueuePeer::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;
NotificationQueuePeer::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 = NotificationQueuePeer::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 NotificationQueuePeer::CLASS_DEFAULT;
}
/**
* Method perform an INSERT on the database, given a NotificationQueue or Criteria object.
*
* @param mixed $values Criteria or NotificationQueue 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 NotificationQueue 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 NotificationQueue or Criteria object.
*
* @param mixed $values Criteria or NotificationQueue 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(NotificationQueuePeer::NOT_UID);
$selectCriteria->add(NotificationQueuePeer::NOT_UID, $criteria->remove(NotificationQueuePeer::NOT_UID), $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 NOTIFICATION_QUEUE 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(NotificationQueuePeer::TABLE_NAME, $con);
$con->commit();
return $affectedRows;
} catch (PropelException $e) {
$con->rollback();
throw $e;
}
}
/**
* Method perform a DELETE on the database, given a NotificationQueue or Criteria object OR a primary key value.
*
* @param mixed $values Criteria or NotificationQueue 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(NotificationQueuePeer::DATABASE_NAME);
}
if ($values instanceof Criteria) {
$criteria = clone $values; // rename for clarity
} elseif ($values instanceof NotificationQueue) {
$criteria = $values->buildPkeyCriteria();
} else {
// it must be the primary key
$criteria = new Criteria(self::DATABASE_NAME);
$criteria->add(NotificationQueuePeer::NOT_UID, (array) $values, 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 NotificationQueue 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 NotificationQueue $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(NotificationQueue $obj, $cols = null)
{
$columns = array();
if ($cols) {
$dbMap = Propel::getDatabaseMap(NotificationQueuePeer::DATABASE_NAME);
$tableMap = $dbMap->getTable(NotificationQueuePeer::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(NotificationQueuePeer::DATABASE_NAME, NotificationQueuePeer::TABLE_NAME, $columns);
}
/**
* Retrieve a single object by pkey.
*
* @param mixed $pk the primary key.
* @param Connection $con the connection to use
* @return NotificationQueue
*/
public static function retrieveByPK($pk, $con = null)
{
if ($con === null) {
$con = Propel::getConnection(self::DATABASE_NAME);
}
$criteria = new Criteria(NotificationQueuePeer::DATABASE_NAME);
$criteria->add(NotificationQueuePeer::NOT_UID, $pk);
$v = NotificationQueuePeer::doSelect($criteria, $con);
return !empty($v) > 0 ? $v[0] : null;
}
/**
* Retrieve multiple objects by pkey.
*
* @param array $pks List of primary keys
* @param Connection $con the connection to use
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function retrieveByPKs($pks, $con = null)
{
if ($con === null) {
$con = Propel::getConnection(self::DATABASE_NAME);
}
$objs = null;
if (empty($pks)) {
$objs = array();
} else {
$criteria = new Criteria();
$criteria->add(NotificationQueuePeer::NOT_UID, $pks, Criteria::IN);
$objs = NotificationQueuePeer::doSelect($criteria, $con);
}
return $objs;
}
}
// 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 {
BaseNotificationQueuePeer::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/NotificationQueueMapBuilder.php';
Propel::registerMapBuilder('classes.model.map.NotificationQueueMapBuilder');
}

13
workflow/engine/config/schema.xml
View File

@@ -5324,4 +5324,17 @@
<index-column name="STATUS"/>
</index>
</table>
<table name="NOTIFICATION_QUEUE" idMethod="native">
<column name="NOT_UID" type="VARCHAR" size="32" required="true" primaryKey="true"/>
<column name="DEV_TYPE" type="VARCHAR" size="50" required="true" />
<column name="DEV_UID" type="LONGVARCHAR" required="true" />
<column name="NOT_MSG" type="LONGVARCHAR" required="true" />
<column name="NOT_DATA" type="LONGVARCHAR" required="true" />
<column name="NOT_STATUS" type="VARCHAR" size="150" required="true"/>
<column name="NOT_SEND_DATE" type="TIMESTAMP" required="true" />
<index name="indexNotStatus">
<index-column name="NOT_STATUS"/>
</index>
</table>
</database>

15
workflow/engine/data/mysql/schema.sql
View File

@@ -2971,4 +2971,19 @@ CREATE TABLE `GMAIL_RELABELING` (
# This restores the fkey checks, after having unset them earlier
DROP TABLE IF EXISTS `NOTIFICATION_QUEUE`;
CREATE TABLE `NOTIFICATION_QUEUE`
(
`NOT_UID` VARCHAR(32) NOT NULL,
`DEV_TYPE` VARCHAR(50) NOT NULL,
`DEV_UID` MEDIUMTEXT NOT NULL,
`NOT_MSG` MEDIUMTEXT NOT NULL,
`NOT_DATA` MEDIUMTEXT NOT NULL,
`NOT_STATUS` VARCHAR(150) NOT NULL,
`NOT_SEND_DATE` DATETIME NOT NULL,
PRIMARY KEY (`NOT_UID`),
KEY `indexNotStatus`(`NOT_STATUS`)
)ENGINE=InnoDB ;
# This restores the fkey checks, after having unset them earlier
SET FOREIGN_KEY_CHECKS = 1;

26
workflow/engine/src/ProcessMaker/BusinessModel/Light/NotificationDevice.php
View File

@@ -228,16 +228,26 @@ class NotificationDevice
$isExistNextNotifications = $oNoti->isExistNextNotification($appFields['APP_UID'],
$currentDelIndex);
if (count($devicesAppleIds) > 0 && $isExistNextNotifications) {
$oNotification = new PushMessageIOS();
$oNotification->setSettingNotification();
$oNotification->setDevices($devicesAppleIds);
$response['apple'] = $oNotification->send($message, $data);
$arrayData = array();
$arrayData['NOT_FROM'] = $currentUserId;
$arrayData['DEV_TYPE'] = 'apple';
$arrayData['DEV_UID'] = serialize($devicesAppleIds);
$arrayData['NOT_MSG'] = $message;
$arrayData['NOT_DATA'] = serialize($data);
$arrayData['NOT_STATUS'] = "pending";
$notQueue = new \NotificationQueue();
$notQueue->create($arrayData);
}
if (count($devicesAndroidIds) > 0 && $isExistNextNotifications) {
$oNotification = new PushMessageAndroid();
$oNotification->setSettingNotification();
$oNotification->setDevices($devicesAndroidIds);
$response['android'] = $oNotification->send($message, $data);
$arrayData = array();
$arrayData['NOT_FROM'] = $currentUserId;
$arrayData['DEV_TYPE'] = 'android';
$arrayData['DEV_UID'] = serialize($devicesAndroidIds);
$arrayData['NOT_MSG'] = $message;
$arrayData['NOT_DATA'] = serialize($data);
$arrayData['NOT_STATUS'] = "pending";
$notQueue = new \NotificationQueue();
$notQueue->create($arrayData);
}
}
}

49
workflow/engine/src/ProcessMaker/BusinessModel/Light/PushMessageAndroid.php
View File

@@ -15,21 +15,24 @@ namespace ProcessMaker\BusinessModel\Light;
class PushMessageAndroid
{
var $url = 'https://android.googleapis.com/gcm/send';
var $serverApiKey = "AIzaSyBO-VLXGhjf0PPlwmPFTPQEKIBfVDydLAk";
var $devices = array();
private $url = 'https://android.googleapis.com/gcm/send';
private $serverApiKey = "AIzaSyBO-VLXGhjf0PPlwmPFTPQEKIBfVDydLAk";
private $devices = array();
private $numberDevices = 0;
/**
* @param $url string the url server
*/
function setUrl($url){
public function setUrl($url)
{
$this->$url = $url;
}
/**
* @param $apiKeyIn string the server API key
*/
function setKey($apiKeyIn){
public function setKey($apiKeyIn)
{
$this->serverApiKey = $apiKeyIn;
}
@@ -37,9 +40,9 @@ class PushMessageAndroid
* Set the devices to send to
* @param $deviceIds string or array of device tokens to send
*/
function setDevices($deviceIds)
public function setDevices($deviceIds)
{
if(is_array($deviceIds)){
if (is_array($deviceIds)) {
$this->devices = $deviceIds;
} else {
$this->devices = array($deviceIds);
@@ -51,7 +54,7 @@ class PushMessageAndroid
*/
public function setSettingNotification()
{
$conf = \System::getSystemConfiguration( PATH_CONFIG . 'mobile.ini' );
$conf = \System::getSystemConfiguration(PATH_CONFIG . 'mobile.ini');
$this->setUrl($conf['android']['url']);
$this->setKey($conf['android']['serverApiKey']);
}
@@ -62,12 +65,13 @@ class PushMessageAndroid
* @param $data array send extra information for app
* @return mixed
*/
function send($message, $data)
public function send($message, $data)
{
if(!is_array($this->devices) || count($this->devices) == 0){
$this->numberDevices = count($this->devices);
if (!is_array($this->devices) || $this->numberDevices == 0) {
$this->error("No devices set");
}
if(strlen($this->serverApiKey) < 8){
if (strlen($this->serverApiKey) < 8) {
$this->error("Server API Key not set");
}
@@ -82,7 +86,7 @@ class PushMessageAndroid
} else {
$fields = array(
'registration_ids' => $this->devices,
'data' => array( "message" => $message ),
'data' => array("message" => $message),
);
}
@@ -94,17 +98,17 @@ class PushMessageAndroid
$ch = curl_init();
// Set the url, number of POST vars, POST data
curl_setopt( $ch, CURLOPT_URL, $this->url );
curl_setopt($ch, CURLOPT_URL, $this->url);
curl_setopt( $ch, CURLOPT_POST, true );
curl_setopt( $ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt( $ch, CURLOPT_POSTFIELDS, json_encode( $fields ) );
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($fields));
// Avoids problem with https certificate
curl_setopt( $ch, CURLOPT_SSL_VERIFYHOST, false);
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
// Execute post
$result = curl_exec($ch);
@@ -114,7 +118,12 @@ class PushMessageAndroid
return $result;
}
function error($msg)
public function getNumberDevices()
{
return $this->numberDevices;
}
public function error($msg)
{
echo "Android send notification failed with error:";
echo "\t" . $msg;

11
workflow/engine/src/ProcessMaker/BusinessModel/Light/PushMessageIOS.php
View File

@@ -19,6 +19,7 @@ class PushMessageIOS
private $pemFile = 'mobileios.pem';
private $devices = array();
private $response = array();
private $numberDevices = 0;
/**
* Sete server notification Ios
@@ -44,7 +45,7 @@ class PushMessageIOS
*/
public function setPemFile($file)
{
$file = file_exists(PATH_CONFIG . $file)?$file:'mobileios.pem';
$file = file_exists(PATH_CONFIG . $file) ? $file : 'mobileios.pem';
$this->pemFile = $file;
}
@@ -81,7 +82,8 @@ class PushMessageIOS
*/
public function send($message, $data)
{
if (!is_array($this->devices) || count($this->devices) == 0) {
$this->numberDevices = count($this->devices);
if (!is_array($this->devices) || $this->numberDevices == 0) {
$this->error("No devices set");
}
if (strlen($this->passphrase) < 8) {
@@ -154,6 +156,11 @@ class PushMessageIOS
return $this->response;
}
public function getNumberDevices()
{
return $this->numberDevices;
}
public function error($msg)
{
echo "Android send notification failed with error:";