diff --git a/workflow/engine/bin/tasks/cliWorkspaces.php b/workflow/engine/bin/tasks/cliWorkspaces.php index 1b1bc3106..cfb4ff39d 100755 --- a/workflow/engine/bin/tasks/cliWorkspaces.php +++ b/workflow/engine/bin/tasks/cliWorkspaces.php @@ -311,6 +311,41 @@ function database_upgrade($command, $args) { echo "> Error: ".CLI::error($e->getMessage()) . "\n"; } } + + //There records in table "EMAIL_SERVER" + $criteria = new Criteria("workflow"); + + $criteria->addSelectColumn(EmailServerPeer::MESS_UID); + $criteria->setOffset(0); + $criteria->setLimit(1); + + $rsCriteria = EmailServerPeer::doSelectRS($criteria); + + if (!$rsCriteria->next()) { + //Insert the first record + $emailConfiguration = System::getEmailConfiguration(); + + if (count($emailConfiguration) > 0) { + $arrayData = array(); + + $arrayData["MESS_ENGINE"] = $emailConfiguration["MESS_ENGINE"]; + $arrayData["MESS_SERVER"] = $emailConfiguration["MESS_SERVER"]; + $arrayData["MESS_PORT"] = (int)($emailConfiguration["MESS_PORT"]); + $arrayData["MESS_RAUTH"] = (int)($emailConfiguration["MESS_RAUTH"]); + $arrayData["MESS_ACCOUNT"] = $emailConfiguration["MESS_ACCOUNT"]; + $arrayData["MESS_PASSWORD"] = $emailConfiguration["MESS_PASSWORD"]; + $arrayData["MESS_FROM_MAIL"] = $emailConfiguration["MESS_FROM_MAIL"]; + $arrayData["MESS_FROM_NAME"] = $emailConfiguration["MESS_FROM_NAME"]; + $arrayData["SMTPSECURE"] = $emailConfiguration["SMTPSecure"]; + $arrayData["MESS_TRY_SEND_INMEDIATLY"] = (int)($emailConfiguration["MESS_TRY_SEND_INMEDIATLY"]); + $arrayData["MAIL_TO"] = $emailConfiguration["MAIL_TO"]; + $arrayData["MESS_DEFAULT"] = (isset($emailConfiguration["MESS_ENABLED"]) && $emailConfiguration["MESS_ENABLED"] . "" == "1")? 1 : 0; + + $emailSever = new ProcessMaker\BusinessModel\EmailServer(); + + $emailSever->create($arrayData); + } + } } function delete_app_from_table($con, $tableName, $appUid, $col="APP_UID") { diff --git a/workflow/engine/classes/class.system.php b/workflow/engine/classes/class.system.php index 4df172100..9306710ec 100755 --- a/workflow/engine/classes/class.system.php +++ b/workflow/engine/classes/class.system.php @@ -968,11 +968,39 @@ class System public function getEmailConfiguration () { - G::LoadClass( 'configuration' ); - $conf = new Configurations(); - $config = $conf->load( 'Emails' ); + $emailServer = new ProcessMaker\BusinessModel\EmailServer(); - return $config; + $arrayEmailServerDefault = $emailServer->getEmailServerDefault(); + + if (count($arrayEmailServerDefault) > 0) { + //Return + return $arrayDataEmailServerConfig = array( + "MESS_ENGINE" => $arrayEmailServerDefault["MESS_ENGINE"], + "MESS_SERVER" => $arrayEmailServerDefault["MESS_SERVER"], + "MESS_PORT" => (int)($arrayEmailServerDefault["MESS_PORT"]), + "MESS_RAUTH" => (int)($arrayEmailServerDefault["MESS_RAUTH"]), + "MESS_ACCOUNT" => $arrayEmailServerDefault["MESS_ACCOUNT"], + "MESS_PASSWORD" => $arrayEmailServerDefault["MESS_PASSWORD"], + "MESS_FROM_MAIL" => $arrayEmailServerDefault["MESS_FROM_MAIL"], + "MESS_FROM_NAME" => $arrayEmailServerDefault["MESS_FROM_NAME"], + "SMTPSecure" => $arrayEmailServerDefault["SMTPSECURE"], + "MESS_TRY_SEND_INMEDIATLY" => (int)($arrayEmailServerDefault["MESS_TRY_SEND_INMEDIATLY"]), + "MAIL_TO" => $arrayEmailServerDefault["MAIL_TO"], + "MESS_DEFAULT" => (int)($arrayEmailServerDefault["MESS_DEFAULT"]), + "MESS_ENABLED" => 1, + "MESS_BACKGROUND" => "", + "MESS_PASSWORD_HIDDEN" => "", + "MESS_EXECUTE_EVERY" => "", + "MESS_SEND_MAX" => "" + ); + } else { + G::LoadClass("configuration"); + + $conf = new Configurations(); + $config = $conf->load("Emails"); + + return $config; + } } public function getSkingList () diff --git a/workflow/engine/classes/model/EmailServer.php b/workflow/engine/classes/model/EmailServer.php new file mode 100644 index 000000000..f961d4f1a --- /dev/null +++ b/workflow/engine/classes/model/EmailServer.php @@ -0,0 +1,5 @@ +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('EMAIL_SERVER'); + $tMap->setPhpName('EmailServer'); + + $tMap->setUseIdGenerator(false); + + $tMap->addPrimaryKey('MESS_UID', 'MessUid', 'string', CreoleTypes::VARCHAR, true, 32); + + $tMap->addColumn('MESS_ENGINE', 'MessEngine', 'string', CreoleTypes::VARCHAR, true, 256); + + $tMap->addColumn('MESS_SERVER', 'MessServer', 'string', CreoleTypes::VARCHAR, true, 256); + + $tMap->addColumn('MESS_PORT', 'MessPort', 'int', CreoleTypes::INTEGER, true, null); + + $tMap->addColumn('MESS_RAUTH', 'MessRauth', 'int', CreoleTypes::INTEGER, true, null); + + $tMap->addColumn('MESS_ACCOUNT', 'MessAccount', 'string', CreoleTypes::VARCHAR, true, 256); + + $tMap->addColumn('MESS_PASSWORD', 'MessPassword', 'string', CreoleTypes::VARCHAR, true, 256); + + $tMap->addColumn('MESS_FROM_MAIL', 'MessFromMail', 'string', CreoleTypes::VARCHAR, true, 256); + + $tMap->addColumn('MESS_FROM_NAME', 'MessFromName', 'string', CreoleTypes::VARCHAR, true, 256); + + $tMap->addColumn('SMTPSECURE', 'Smtpsecure', 'string', CreoleTypes::VARCHAR, true, 3); + + $tMap->addColumn('MESS_TRY_SEND_INMEDIATLY', 'MessTrySendInmediatly', 'int', CreoleTypes::INTEGER, true, null); + + $tMap->addColumn('MAIL_TO', 'MailTo', 'string', CreoleTypes::VARCHAR, true, 256); + + $tMap->addColumn('MESS_DEFAULT', 'MessDefault', 'int', CreoleTypes::INTEGER, true, null); + + } // doBuild() + +} // EmailServerMapBuilder diff --git a/workflow/engine/classes/model/om/BaseEmailServer.php b/workflow/engine/classes/model/om/BaseEmailServer.php new file mode 100644 index 000000000..4239ebbd0 --- /dev/null +++ b/workflow/engine/classes/model/om/BaseEmailServer.php @@ -0,0 +1,1206 @@ +mess_uid; + } + + /** + * Get the [mess_engine] column value. + * + * @return string + */ + public function getMessEngine() + { + + return $this->mess_engine; + } + + /** + * Get the [mess_server] column value. + * + * @return string + */ + public function getMessServer() + { + + return $this->mess_server; + } + + /** + * Get the [mess_port] column value. + * + * @return int + */ + public function getMessPort() + { + + return $this->mess_port; + } + + /** + * Get the [mess_rauth] column value. + * + * @return int + */ + public function getMessRauth() + { + + return $this->mess_rauth; + } + + /** + * Get the [mess_account] column value. + * + * @return string + */ + public function getMessAccount() + { + + return $this->mess_account; + } + + /** + * Get the [mess_password] column value. + * + * @return string + */ + public function getMessPassword() + { + + return $this->mess_password; + } + + /** + * Get the [mess_from_mail] column value. + * + * @return string + */ + public function getMessFromMail() + { + + return $this->mess_from_mail; + } + + /** + * Get the [mess_from_name] column value. + * + * @return string + */ + public function getMessFromName() + { + + return $this->mess_from_name; + } + + /** + * Get the [smtpsecure] column value. + * + * @return string + */ + public function getSmtpsecure() + { + + return $this->smtpsecure; + } + + /** + * Get the [mess_try_send_inmediatly] column value. + * + * @return int + */ + public function getMessTrySendInmediatly() + { + + return $this->mess_try_send_inmediatly; + } + + /** + * Get the [mail_to] column value. + * + * @return string + */ + public function getMailTo() + { + + return $this->mail_to; + } + + /** + * Get the [mess_default] column value. + * + * @return int + */ + public function getMessDefault() + { + + return $this->mess_default; + } + + /** + * Set the value of [mess_uid] column. + * + * @param string $v new value + * @return void + */ + public function setMessUid($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->mess_uid !== $v || $v === '') { + $this->mess_uid = $v; + $this->modifiedColumns[] = EmailServerPeer::MESS_UID; + } + + } // setMessUid() + + /** + * Set the value of [mess_engine] column. + * + * @param string $v new value + * @return void + */ + public function setMessEngine($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->mess_engine !== $v || $v === '') { + $this->mess_engine = $v; + $this->modifiedColumns[] = EmailServerPeer::MESS_ENGINE; + } + + } // setMessEngine() + + /** + * Set the value of [mess_server] column. + * + * @param string $v new value + * @return void + */ + public function setMessServer($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->mess_server !== $v || $v === '') { + $this->mess_server = $v; + $this->modifiedColumns[] = EmailServerPeer::MESS_SERVER; + } + + } // setMessServer() + + /** + * Set the value of [mess_port] column. + * + * @param int $v new value + * @return void + */ + public function setMessPort($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->mess_port !== $v || $v === 0) { + $this->mess_port = $v; + $this->modifiedColumns[] = EmailServerPeer::MESS_PORT; + } + + } // setMessPort() + + /** + * Set the value of [mess_rauth] column. + * + * @param int $v new value + * @return void + */ + public function setMessRauth($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->mess_rauth !== $v || $v === 0) { + $this->mess_rauth = $v; + $this->modifiedColumns[] = EmailServerPeer::MESS_RAUTH; + } + + } // setMessRauth() + + /** + * Set the value of [mess_account] column. + * + * @param string $v new value + * @return void + */ + public function setMessAccount($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->mess_account !== $v || $v === '') { + $this->mess_account = $v; + $this->modifiedColumns[] = EmailServerPeer::MESS_ACCOUNT; + } + + } // setMessAccount() + + /** + * Set the value of [mess_password] column. + * + * @param string $v new value + * @return void + */ + public function setMessPassword($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->mess_password !== $v || $v === '') { + $this->mess_password = $v; + $this->modifiedColumns[] = EmailServerPeer::MESS_PASSWORD; + } + + } // setMessPassword() + + /** + * Set the value of [mess_from_mail] column. + * + * @param string $v new value + * @return void + */ + public function setMessFromMail($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->mess_from_mail !== $v || $v === '') { + $this->mess_from_mail = $v; + $this->modifiedColumns[] = EmailServerPeer::MESS_FROM_MAIL; + } + + } // setMessFromMail() + + /** + * Set the value of [mess_from_name] column. + * + * @param string $v new value + * @return void + */ + public function setMessFromName($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->mess_from_name !== $v || $v === '') { + $this->mess_from_name = $v; + $this->modifiedColumns[] = EmailServerPeer::MESS_FROM_NAME; + } + + } // setMessFromName() + + /** + * Set the value of [smtpsecure] column. + * + * @param string $v new value + * @return void + */ + public function setSmtpsecure($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->smtpsecure !== $v || $v === '') { + $this->smtpsecure = $v; + $this->modifiedColumns[] = EmailServerPeer::SMTPSECURE; + } + + } // setSmtpsecure() + + /** + * Set the value of [mess_try_send_inmediatly] column. + * + * @param int $v new value + * @return void + */ + public function setMessTrySendInmediatly($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->mess_try_send_inmediatly !== $v || $v === 0) { + $this->mess_try_send_inmediatly = $v; + $this->modifiedColumns[] = EmailServerPeer::MESS_TRY_SEND_INMEDIATLY; + } + + } // setMessTrySendInmediatly() + + /** + * Set the value of [mail_to] column. + * + * @param string $v new value + * @return void + */ + public function setMailTo($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->mail_to !== $v || $v === '') { + $this->mail_to = $v; + $this->modifiedColumns[] = EmailServerPeer::MAIL_TO; + } + + } // setMailTo() + + /** + * Set the value of [mess_default] column. + * + * @param int $v new value + * @return void + */ + public function setMessDefault($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->mess_default !== $v || $v === 0) { + $this->mess_default = $v; + $this->modifiedColumns[] = EmailServerPeer::MESS_DEFAULT; + } + + } // setMessDefault() + + /** + * 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->mess_uid = $rs->getString($startcol + 0); + + $this->mess_engine = $rs->getString($startcol + 1); + + $this->mess_server = $rs->getString($startcol + 2); + + $this->mess_port = $rs->getInt($startcol + 3); + + $this->mess_rauth = $rs->getInt($startcol + 4); + + $this->mess_account = $rs->getString($startcol + 5); + + $this->mess_password = $rs->getString($startcol + 6); + + $this->mess_from_mail = $rs->getString($startcol + 7); + + $this->mess_from_name = $rs->getString($startcol + 8); + + $this->smtpsecure = $rs->getString($startcol + 9); + + $this->mess_try_send_inmediatly = $rs->getInt($startcol + 10); + + $this->mail_to = $rs->getString($startcol + 11); + + $this->mess_default = $rs->getInt($startcol + 12); + + $this->resetModified(); + + $this->setNew(false); + + // FIXME - using NUM_COLUMNS may be clearer. + return $startcol + 13; // 13 = EmailServerPeer::NUM_COLUMNS - EmailServerPeer::NUM_LAZY_LOAD_COLUMNS). + + } catch (Exception $e) { + throw new PropelException("Error populating EmailServer 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(EmailServerPeer::DATABASE_NAME); + } + + try { + $con->begin(); + EmailServerPeer::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(EmailServerPeer::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 = EmailServerPeer::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 += EmailServerPeer::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 = EmailServerPeer::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 = EmailServerPeer::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->getMessUid(); + break; + case 1: + return $this->getMessEngine(); + break; + case 2: + return $this->getMessServer(); + break; + case 3: + return $this->getMessPort(); + break; + case 4: + return $this->getMessRauth(); + break; + case 5: + return $this->getMessAccount(); + break; + case 6: + return $this->getMessPassword(); + break; + case 7: + return $this->getMessFromMail(); + break; + case 8: + return $this->getMessFromName(); + break; + case 9: + return $this->getSmtpsecure(); + break; + case 10: + return $this->getMessTrySendInmediatly(); + break; + case 11: + return $this->getMailTo(); + break; + case 12: + return $this->getMessDefault(); + 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 = EmailServerPeer::getFieldNames($keyType); + $result = array( + $keys[0] => $this->getMessUid(), + $keys[1] => $this->getMessEngine(), + $keys[2] => $this->getMessServer(), + $keys[3] => $this->getMessPort(), + $keys[4] => $this->getMessRauth(), + $keys[5] => $this->getMessAccount(), + $keys[6] => $this->getMessPassword(), + $keys[7] => $this->getMessFromMail(), + $keys[8] => $this->getMessFromName(), + $keys[9] => $this->getSmtpsecure(), + $keys[10] => $this->getMessTrySendInmediatly(), + $keys[11] => $this->getMailTo(), + $keys[12] => $this->getMessDefault(), + ); + 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 = EmailServerPeer::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->setMessUid($value); + break; + case 1: + $this->setMessEngine($value); + break; + case 2: + $this->setMessServer($value); + break; + case 3: + $this->setMessPort($value); + break; + case 4: + $this->setMessRauth($value); + break; + case 5: + $this->setMessAccount($value); + break; + case 6: + $this->setMessPassword($value); + break; + case 7: + $this->setMessFromMail($value); + break; + case 8: + $this->setMessFromName($value); + break; + case 9: + $this->setSmtpsecure($value); + break; + case 10: + $this->setMessTrySendInmediatly($value); + break; + case 11: + $this->setMailTo($value); + break; + case 12: + $this->setMessDefault($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 = EmailServerPeer::getFieldNames($keyType); + + if (array_key_exists($keys[0], $arr)) { + $this->setMessUid($arr[$keys[0]]); + } + + if (array_key_exists($keys[1], $arr)) { + $this->setMessEngine($arr[$keys[1]]); + } + + if (array_key_exists($keys[2], $arr)) { + $this->setMessServer($arr[$keys[2]]); + } + + if (array_key_exists($keys[3], $arr)) { + $this->setMessPort($arr[$keys[3]]); + } + + if (array_key_exists($keys[4], $arr)) { + $this->setMessRauth($arr[$keys[4]]); + } + + if (array_key_exists($keys[5], $arr)) { + $this->setMessAccount($arr[$keys[5]]); + } + + if (array_key_exists($keys[6], $arr)) { + $this->setMessPassword($arr[$keys[6]]); + } + + if (array_key_exists($keys[7], $arr)) { + $this->setMessFromMail($arr[$keys[7]]); + } + + if (array_key_exists($keys[8], $arr)) { + $this->setMessFromName($arr[$keys[8]]); + } + + if (array_key_exists($keys[9], $arr)) { + $this->setSmtpsecure($arr[$keys[9]]); + } + + if (array_key_exists($keys[10], $arr)) { + $this->setMessTrySendInmediatly($arr[$keys[10]]); + } + + if (array_key_exists($keys[11], $arr)) { + $this->setMailTo($arr[$keys[11]]); + } + + if (array_key_exists($keys[12], $arr)) { + $this->setMessDefault($arr[$keys[12]]); + } + + } + + /** + * 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(EmailServerPeer::DATABASE_NAME); + + if ($this->isColumnModified(EmailServerPeer::MESS_UID)) { + $criteria->add(EmailServerPeer::MESS_UID, $this->mess_uid); + } + + if ($this->isColumnModified(EmailServerPeer::MESS_ENGINE)) { + $criteria->add(EmailServerPeer::MESS_ENGINE, $this->mess_engine); + } + + if ($this->isColumnModified(EmailServerPeer::MESS_SERVER)) { + $criteria->add(EmailServerPeer::MESS_SERVER, $this->mess_server); + } + + if ($this->isColumnModified(EmailServerPeer::MESS_PORT)) { + $criteria->add(EmailServerPeer::MESS_PORT, $this->mess_port); + } + + if ($this->isColumnModified(EmailServerPeer::MESS_RAUTH)) { + $criteria->add(EmailServerPeer::MESS_RAUTH, $this->mess_rauth); + } + + if ($this->isColumnModified(EmailServerPeer::MESS_ACCOUNT)) { + $criteria->add(EmailServerPeer::MESS_ACCOUNT, $this->mess_account); + } + + if ($this->isColumnModified(EmailServerPeer::MESS_PASSWORD)) { + $criteria->add(EmailServerPeer::MESS_PASSWORD, $this->mess_password); + } + + if ($this->isColumnModified(EmailServerPeer::MESS_FROM_MAIL)) { + $criteria->add(EmailServerPeer::MESS_FROM_MAIL, $this->mess_from_mail); + } + + if ($this->isColumnModified(EmailServerPeer::MESS_FROM_NAME)) { + $criteria->add(EmailServerPeer::MESS_FROM_NAME, $this->mess_from_name); + } + + if ($this->isColumnModified(EmailServerPeer::SMTPSECURE)) { + $criteria->add(EmailServerPeer::SMTPSECURE, $this->smtpsecure); + } + + if ($this->isColumnModified(EmailServerPeer::MESS_TRY_SEND_INMEDIATLY)) { + $criteria->add(EmailServerPeer::MESS_TRY_SEND_INMEDIATLY, $this->mess_try_send_inmediatly); + } + + if ($this->isColumnModified(EmailServerPeer::MAIL_TO)) { + $criteria->add(EmailServerPeer::MAIL_TO, $this->mail_to); + } + + if ($this->isColumnModified(EmailServerPeer::MESS_DEFAULT)) { + $criteria->add(EmailServerPeer::MESS_DEFAULT, $this->mess_default); + } + + + 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(EmailServerPeer::DATABASE_NAME); + + $criteria->add(EmailServerPeer::MESS_UID, $this->mess_uid); + + return $criteria; + } + + /** + * Returns the primary key for this object (row). + * @return string + */ + public function getPrimaryKey() + { + return $this->getMessUid(); + } + + /** + * Generic method to set the primary key (mess_uid column). + * + * @param string $key Primary key. + * @return void + */ + public function setPrimaryKey($key) + { + $this->setMessUid($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 EmailServer (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->setMessEngine($this->mess_engine); + + $copyObj->setMessServer($this->mess_server); + + $copyObj->setMessPort($this->mess_port); + + $copyObj->setMessRauth($this->mess_rauth); + + $copyObj->setMessAccount($this->mess_account); + + $copyObj->setMessPassword($this->mess_password); + + $copyObj->setMessFromMail($this->mess_from_mail); + + $copyObj->setMessFromName($this->mess_from_name); + + $copyObj->setSmtpsecure($this->smtpsecure); + + $copyObj->setMessTrySendInmediatly($this->mess_try_send_inmediatly); + + $copyObj->setMailTo($this->mail_to); + + $copyObj->setMessDefault($this->mess_default); + + + $copyObj->setNew(true); + + $copyObj->setMessUid(''); // 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 EmailServer 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 EmailServerPeer + */ + public function getPeer() + { + if (self::$peer === null) { + self::$peer = new EmailServerPeer(); + } + return self::$peer; + } +} + diff --git a/workflow/engine/classes/model/om/BaseEmailServerPeer.php b/workflow/engine/classes/model/om/BaseEmailServerPeer.php new file mode 100644 index 000000000..c78d96808 --- /dev/null +++ b/workflow/engine/classes/model/om/BaseEmailServerPeer.php @@ -0,0 +1,627 @@ + array ('MessUid', 'MessEngine', 'MessServer', 'MessPort', 'MessRauth', 'MessAccount', 'MessPassword', 'MessFromMail', 'MessFromName', 'Smtpsecure', 'MessTrySendInmediatly', 'MailTo', 'MessDefault', ), + BasePeer::TYPE_COLNAME => array (EmailServerPeer::MESS_UID, EmailServerPeer::MESS_ENGINE, EmailServerPeer::MESS_SERVER, EmailServerPeer::MESS_PORT, EmailServerPeer::MESS_RAUTH, EmailServerPeer::MESS_ACCOUNT, EmailServerPeer::MESS_PASSWORD, EmailServerPeer::MESS_FROM_MAIL, EmailServerPeer::MESS_FROM_NAME, EmailServerPeer::SMTPSECURE, EmailServerPeer::MESS_TRY_SEND_INMEDIATLY, EmailServerPeer::MAIL_TO, EmailServerPeer::MESS_DEFAULT, ), + BasePeer::TYPE_FIELDNAME => array ('MESS_UID', 'MESS_ENGINE', 'MESS_SERVER', 'MESS_PORT', 'MESS_RAUTH', 'MESS_ACCOUNT', 'MESS_PASSWORD', 'MESS_FROM_MAIL', 'MESS_FROM_NAME', 'SMTPSECURE', 'MESS_TRY_SEND_INMEDIATLY', 'MAIL_TO', 'MESS_DEFAULT', ), + BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, ) + ); + + /** + * 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 ('MessUid' => 0, 'MessEngine' => 1, 'MessServer' => 2, 'MessPort' => 3, 'MessRauth' => 4, 'MessAccount' => 5, 'MessPassword' => 6, 'MessFromMail' => 7, 'MessFromName' => 8, 'Smtpsecure' => 9, 'MessTrySendInmediatly' => 10, 'MailTo' => 11, 'MessDefault' => 12, ), + BasePeer::TYPE_COLNAME => array (EmailServerPeer::MESS_UID => 0, EmailServerPeer::MESS_ENGINE => 1, EmailServerPeer::MESS_SERVER => 2, EmailServerPeer::MESS_PORT => 3, EmailServerPeer::MESS_RAUTH => 4, EmailServerPeer::MESS_ACCOUNT => 5, EmailServerPeer::MESS_PASSWORD => 6, EmailServerPeer::MESS_FROM_MAIL => 7, EmailServerPeer::MESS_FROM_NAME => 8, EmailServerPeer::SMTPSECURE => 9, EmailServerPeer::MESS_TRY_SEND_INMEDIATLY => 10, EmailServerPeer::MAIL_TO => 11, EmailServerPeer::MESS_DEFAULT => 12, ), + BasePeer::TYPE_FIELDNAME => array ('MESS_UID' => 0, 'MESS_ENGINE' => 1, 'MESS_SERVER' => 2, 'MESS_PORT' => 3, 'MESS_RAUTH' => 4, 'MESS_ACCOUNT' => 5, 'MESS_PASSWORD' => 6, 'MESS_FROM_MAIL' => 7, 'MESS_FROM_NAME' => 8, 'SMTPSECURE' => 9, 'MESS_TRY_SEND_INMEDIATLY' => 10, 'MAIL_TO' => 11, 'MESS_DEFAULT' => 12, ), + BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, ) + ); + + /** + * @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/EmailServerMapBuilder.php'; + return BasePeer::getMapBuilder('classes.model.map.EmailServerMapBuilder'); + } + /** + * 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 = EmailServerPeer::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. EmailServerPeer::COLUMN_NAME). + * @return string + */ + public static function alias($alias, $column) + { + return str_replace(EmailServerPeer::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(EmailServerPeer::MESS_UID); + + $criteria->addSelectColumn(EmailServerPeer::MESS_ENGINE); + + $criteria->addSelectColumn(EmailServerPeer::MESS_SERVER); + + $criteria->addSelectColumn(EmailServerPeer::MESS_PORT); + + $criteria->addSelectColumn(EmailServerPeer::MESS_RAUTH); + + $criteria->addSelectColumn(EmailServerPeer::MESS_ACCOUNT); + + $criteria->addSelectColumn(EmailServerPeer::MESS_PASSWORD); + + $criteria->addSelectColumn(EmailServerPeer::MESS_FROM_MAIL); + + $criteria->addSelectColumn(EmailServerPeer::MESS_FROM_NAME); + + $criteria->addSelectColumn(EmailServerPeer::SMTPSECURE); + + $criteria->addSelectColumn(EmailServerPeer::MESS_TRY_SEND_INMEDIATLY); + + $criteria->addSelectColumn(EmailServerPeer::MAIL_TO); + + $criteria->addSelectColumn(EmailServerPeer::MESS_DEFAULT); + + } + + const COUNT = 'COUNT(EMAIL_SERVER.MESS_UID)'; + const COUNT_DISTINCT = 'COUNT(DISTINCT EMAIL_SERVER.MESS_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(EmailServerPeer::COUNT_DISTINCT); + } else { + $criteria->addSelectColumn(EmailServerPeer::COUNT); + } + + // just in case we're grouping: add those columns to the select statement + foreach ($criteria->getGroupByColumns() as $column) { + $criteria->addSelectColumn($column); + } + + $rs = EmailServerPeer::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 EmailServer + * @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 = EmailServerPeer::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 EmailServerPeer::populateObjects(EmailServerPeer::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; + EmailServerPeer::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 = EmailServerPeer::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 EmailServerPeer::CLASS_DEFAULT; + } + + /** + * Method perform an INSERT on the database, given a EmailServer or Criteria object. + * + * @param mixed $values Criteria or EmailServer 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 EmailServer 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 EmailServer or Criteria object. + * + * @param mixed $values Criteria or EmailServer 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(EmailServerPeer::MESS_UID); + $selectCriteria->add(EmailServerPeer::MESS_UID, $criteria->remove(EmailServerPeer::MESS_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 EMAIL_SERVER 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(EmailServerPeer::TABLE_NAME, $con); + $con->commit(); + return $affectedRows; + } catch (PropelException $e) { + $con->rollback(); + throw $e; + } + } + + /** + * Method perform a DELETE on the database, given a EmailServer or Criteria object OR a primary key value. + * + * @param mixed $values Criteria or EmailServer 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(EmailServerPeer::DATABASE_NAME); + } + + if ($values instanceof Criteria) { + $criteria = clone $values; // rename for clarity + } elseif ($values instanceof EmailServer) { + + $criteria = $values->buildPkeyCriteria(); + } else { + // it must be the primary key + $criteria = new Criteria(self::DATABASE_NAME); + $criteria->add(EmailServerPeer::MESS_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 EmailServer 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 EmailServer $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(EmailServer $obj, $cols = null) + { + $columns = array(); + + if ($cols) { + $dbMap = Propel::getDatabaseMap(EmailServerPeer::DATABASE_NAME); + $tableMap = $dbMap->getTable(EmailServerPeer::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(EmailServerPeer::DATABASE_NAME, EmailServerPeer::TABLE_NAME, $columns); + } + + /** + * Retrieve a single object by pkey. + * + * @param mixed $pk the primary key. + * @param Connection $con the connection to use + * @return EmailServer + */ + public static function retrieveByPK($pk, $con = null) + { + if ($con === null) { + $con = Propel::getConnection(self::DATABASE_NAME); + } + + $criteria = new Criteria(EmailServerPeer::DATABASE_NAME); + + $criteria->add(EmailServerPeer::MESS_UID, $pk); + + + $v = EmailServerPeer::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(EmailServerPeer::MESS_UID, $pks, Criteria::IN); + $objs = EmailServerPeer::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 { + BaseEmailServerPeer::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/EmailServerMapBuilder.php'; + Propel::registerMapBuilder('classes.model.map.EmailServerMapBuilder'); +} + diff --git a/workflow/engine/config/schema.xml b/workflow/engine/config/schema.xml index c19f8ba8d..5e5a94a26 100755 --- a/workflow/engine/config/schema.xml +++ b/workflow/engine/config/schema.xml @@ -4176,5 +4176,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
diff --git a/workflow/engine/data/mysql/schema.sql b/workflow/engine/data/mysql/schema.sql index 96f6c3314..bad2c1239 100755 --- a/workflow/engine/data/mysql/schema.sql +++ b/workflow/engine/data/mysql/schema.sql @@ -2383,3 +2383,26 @@ CREATE TABLE `LIST_UNASSIGNED_GROUP` # This restores the fkey checks, after having unset them earlier SET FOREIGN_KEY_CHECKS = 1; +#----------------------------------------------------------------------------- +#-- TABLE: EMAIL_SERVER +#----------------------------------------------------------------------------- + +DROP TABLE IF EXISTS `EMAIL_SERVER`; +CREATE TABLE `EMAIL_SERVER` +( + `MESS_UID` VARCHAR(32) default '' NOT NULL, + `MESS_ENGINE` VARCHAR(256) default '' NOT NULL, + `MESS_SERVER` VARCHAR(256) default '' NOT NULL, + `MESS_PORT` INTEGER default 0 NOT NULL, + `MESS_RAUTH` INTEGER default 0 NOT NULL, + `MESS_ACCOUNT` VARCHAR(256) default '' NOT NULL, + `MESS_PASSWORD` VARCHAR(256) default '' NOT NULL, + `MESS_FROM_MAIL` VARCHAR(256) default '' NOT NULL, + `MESS_FROM_NAME` VARCHAR(256) default '' NOT NULL, + `SMTPSECURE` VARCHAR(3) default 'NO' NOT NULL, + `MESS_TRY_SEND_INMEDIATLY` INTEGER default 0 NOT NULL, + `MAIL_TO` VARCHAR(256) default '' NOT NULL, + `MESS_DEFAULT` INTEGER default 0 NOT NULL, + PRIMARY KEY (`MESS_UID`) +)ENGINE=InnoDB DEFAULT CHARSET='utf8'; + diff --git a/workflow/engine/src/ProcessMaker/BusinessModel/EmailServer.php b/workflow/engine/src/ProcessMaker/BusinessModel/EmailServer.php new file mode 100644 index 000000000..0a6689359 --- /dev/null +++ b/workflow/engine/src/ProcessMaker/BusinessModel/EmailServer.php @@ -0,0 +1,1114 @@ + array("type" => "string", "required" => false, "empty" => false, "defaultValues" => array(), "fieldNameAux" => "emailServerUid"), + + "MESS_ENGINE" => array("type" => "string", "required" => true, "empty" => false, "defaultValues" => array("PHPMAILER", "MAIL"), "fieldNameAux" => "emailServerEngine"), + "MESS_SERVER" => array("type" => "string", "required" => false, "empty" => true, "defaultValues" => array(), "fieldNameAux" => "emailServerServer"), + "MESS_PORT" => array("type" => "int", "required" => false, "empty" => true, "defaultValues" => array(), "fieldNameAux" => "emailServerPort"), + + "MESS_RAUTH" => array("type" => "int", "required" => false, "empty" => false, "defaultValues" => array(0, 1), "fieldNameAux" => "emailServerRauth"), + + "MESS_ACCOUNT" => array("type" => "string", "required" => false, "empty" => true, "defaultValues" => array(), "fieldNameAux" => "emailServerUserName"), + "MESS_PASSWORD" => array("type" => "string", "required" => false, "empty" => true, "defaultValues" => array(), "fieldNameAux" => "emailServerPassword"), + "MESS_FROM_MAIL" => array("type" => "string", "required" => false, "empty" => true, "defaultValues" => array(), "fieldNameAux" => "emailServerFromMail"), + "MESS_FROM_NAME" => array("type" => "string", "required" => false, "empty" => true, "defaultValues" => array(), "fieldNameAux" => "emailServerFromName"), + "SMTPSECURE" => array("type" => "string", "required" => false, "empty" => false, "defaultValues" => array("No", "tls", "ssl"), "fieldNameAux" => "emailServerSecureConnection"), + + "MESS_TRY_SEND_INMEDIATLY" => array("type" => "int", "required" => false, "empty" => false, "defaultValues" => array(0, 1), "fieldNameAux" => "emailServerSendTestMail"), + + "MAIL_TO" => array("type" => "string", "required" => false, "empty" => true, "defaultValues" => array(), "fieldNameAux" => "emailServerMailTo"), + "MESS_DEFAULT" => array("type" => "int", "required" => false, "empty" => false, "defaultValues" => array(0, 1), "fieldNameAux" => "emailServerDefault") + ); + + private $formatFieldNameInUppercase = true; + + private $arrayFieldNameForException = array( + "start" => "START", + "limit" => "LIMIT" + ); + + /** + * Constructor of the class + * + * return void + */ + public function __construct() + { + try { + foreach ($this->arrayFieldDefinition as $key => $value) { + $this->arrayFieldNameForException[$value["fieldNameAux"]] = $key; + } + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Set the format of the fields name (uppercase, lowercase) + * + * @param bool $flag Value that set the format + * + * return void + */ + public function setFormatFieldNameInUppercase($flag) + { + try { + $this->formatFieldNameInUppercase = $flag; + + $this->setArrayFieldNameForException($this->arrayFieldNameForException); + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Set exception messages for fields + * + * @param array $arrayData Data with the fields + * + * return void + */ + public function setArrayFieldNameForException(array $arrayData) + { + try { + foreach ($arrayData as $key => $value) { + $this->arrayFieldNameForException[$key] = $this->getFieldNameByFormatFieldName($value); + } + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Get the name of the field according to the format + * + * @param string $fieldName Field name + * + * return string Return the field name according the format + */ + public function getFieldNameByFormatFieldName($fieldName) + { + try { + return ($this->formatFieldNameInUppercase)? strtoupper($fieldName) : strtolower($fieldName); + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Send a test email + * + * @param array $arrayData Data + * + * return array Return array with result of send test mail + */ + public function sendTestMail(array $arrayData) + { + try { + \G::LoadClass("system"); + \G::LoadClass("spool"); + + $aConfiguration = array( + "MESS_ENGINE" => $arrayData["MESS_ENGINE"], + "MESS_SERVER" => $arrayData["MESS_SERVER"], + "MESS_PORT" => (int)($arrayData["MESS_PORT"]), + "MESS_ACCOUNT" => $arrayData["MESS_ACCOUNT"], + "MESS_PASSWORD" => $arrayData["MESS_PASSWORD"], + "MESS_FROM_NAME" => $arrayData["FROM_NAME"], + "MESS_FROM_MAIL" => $arrayData["FROM_EMAIL"], + "MESS_RAUTH" => (int)($arrayData["MESS_RAUTH"]), + "SMTPSecure" => (isset($arrayData["SMTPSecure"]))? $arrayData["SMTPSecure"] : "none" + ); + + $sFrom = \G::buildFrom($aConfiguration); + + $sSubject = \G::LoadTranslation("ID_MESS_TEST_SUBJECT"); + $msg = \G::LoadTranslation("ID_MESS_TEST_BODY"); + + switch ($arrayData["MESS_ENGINE"]) { + case "MAIL": + $engine = \G::LoadTranslation("ID_MESS_ENGINE_TYPE_1"); + break; + case "PHPMAILER": + $engine = \G::LoadTranslation("ID_MESS_ENGINE_TYPE_2"); + break; + case "OPENMAIL": + $engine = \G::LoadTranslation("ID_MESS_ENGINE_TYPE_3"); + break; + } + + $sBodyPre = new \TemplatePower(PATH_TPL . "admin" . PATH_SEP . "email.tpl"); + + $sBodyPre->prepare(); + $sBodyPre->assign("server", $_SERVER["SERVER_NAME"]); + $sBodyPre->assign("date", date("H:i:s")); + $sBodyPre->assign("ver", \System::getVersion()); + $sBodyPre->assign("engine", $engine); + $sBodyPre->assign("msg", $msg); + $sBody = $sBodyPre->getOutputContent(); + + $oSpool = new \spoolRun(); + + $oSpool->setConfig($aConfiguration); + + $oSpool->create( + array( + "msg_uid" => "", + "app_uid" => "", + "del_index" => 0, + "app_msg_type" => "TEST", + "app_msg_subject" => $sSubject, + "app_msg_from" => $sFrom, + "app_msg_to" => $arrayData["TO"], + "app_msg_body" => $sBody, + "app_msg_cc" => "", + "app_msg_bcc" => "", + "app_msg_attach" => "", + "app_msg_template" => "", + "app_msg_status" => "pending", + "app_msg_attach" => "" + ) + ); + + $oSpool->sendMail(); + + //Return + $arrayTestMailResult = array(); + + if ($oSpool->status == "sent") { + $arrayTestMailResult["status"] = true; + $arrayTestMailResult["success"] = true; + $arrayTestMailResult["msg"] = \G::LoadTranslation("ID_MAIL_TEST_SUCCESS"); + } else { + $arrayTestMailResult["status"] = false; + $arrayTestMailResult["success"] = false; + $arrayTestMailResult["msg"] = $oSpool->error; + } + + return $arrayTestMailResult; + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Test connection by step + * + * @param array $arrayData Data + * @param int $step Step + * + * return array Return array with result of test connection by step + */ + public function testConnectionByStep(array $arrayData, $step = 0) + { + try { + \G::LoadClass("net"); + \G::LoadThirdParty("phpmailer", "class.smtp"); + + //MAIL + if ($arrayData["MESS_ENGINE"] == "MAIL") { + + $arrayDataMail = array(); + + $eregMail = "/^[0-9a-zA-Z]+(?:[._][0-9a-zA-Z]+)*@[0-9a-zA-Z]+(?:[._-][0-9a-zA-Z]+)*\.[0-9a-zA-Z]{2,3}$/"; + + $arrayDataMail["FROM_EMAIL"] = ($arrayData["MESS_FROM_MAIL"] != "" && preg_match($eregMail, $arrayData["MESS_FROM_MAIL"]))? $arrayData["MESS_FROM_MAIL"] : ""; + $arrayDataMail["FROM_NAME"] = ($arrayData["MESS_FROM_NAME"] != "")? $arrayData["MESS_FROM_NAME"] : \G::LoadTranslation("ID_MESS_TEST_BODY"); + $arrayDataMail["MESS_ENGINE"] = "MAIL"; + $arrayDataMail["MESS_SERVER"] = "localhost"; + $arrayDataMail["MESS_PORT"] = 25; + $arrayDataMail["MESS_ACCOUNT"] = $arrayData["MAIL_TO"]; + $arrayDataMail["MESS_PASSWORD"] = ""; + $arrayDataMail["TO"] = $arrayData["MAIL_TO"]; + $arrayDataMail["MESS_RAUTH"] = true; + + $arrayTestMailResult = array(); + + try { + $arrayTestMailResult = $this->sendTestMail($arrayDataMail); + } catch (Exception $error) { + $arrayTestMailResult["status"] = false; + $arrayTestMailResult["message"] = $e->getMessage(); + + } + + $arrayResult = array( + "result" => $arrayTestMailResult["status"], + "message" => "" + ); + + if ($arrayTestMailResult["status"] == false) { + $arrayResult["message"] = \G::LoadTranslation("ID_SENDMAIL_NOT_INSTALLED"); + } + + //Return + return $arrayResult; + } + + //PHPMAILER + $server = $arrayData["MESS_SERVER"]; + $user = $arrayData["MESS_ACCOUNT"]; + $passwd = $arrayData["MESS_PASSWORD"]; + $fromMail = $arrayData["MESS_FROM_MAIL"]; + $passwdHide = $arrayData["MESS_PASSWORD"]; + + if (trim($passwdHide) != "") { + $passwd = $passwdHide; + $passwdHide = ""; + } + + $passwdDec = \G::decrypt($passwd,"EMAILENCRYPT"); + $auxPass = explode("hash:", $passwdDec); + + if (count($auxPass) > 1) { + if (count($auxPass) == 2) { + $passwd = $auxPass[1]; + } else { + array_shift($auxPass); + $passwd = implode("", $auxPass); + } + } + + $arrayData["MESS_PASSWORD"] = $passwd; + + $port = (int)($arrayData["MESS_PORT"]); + $auth_required = (int)($arrayData["MESS_RAUTH"]); + $useSecureCon = $arrayData["SMTPSECURE"]; + $sendTestMail = (int)($arrayData["MESS_TRY_SEND_INMEDIATLY"]); + $mailTo = $arrayData["MAIL_TO"]; + $smtpSecure = $arrayData["SMTPSECURE"]; + + $serverNet = new \NET($server); + $smtp = new \SMTP(); + + $timeout = 10; + $hostinfo = array(); + $srv = $arrayData["MESS_SERVER"]; + + $arrayResult = array(); + + switch ($step) { + case 1: + $arrayResult["result"] = $serverNet->getErrno() == 0; + $arrayResult["message"] = $serverNet->error; + break; + case 2: + $serverNet->scannPort($port); + + $arrayResult["result"] = $serverNet->getErrno() == 0; + $arrayResult["message"] = $serverNet->error; + break; + case 3: + //Try to connect to host + if (preg_match("/^(.+):([0-9]+)$/", $srv, $hostinfo)) { + $server = $hostinfo[1]; + $port = $hostinfo[2]; + } else { + $host = $srv; + } + + $tls = (strtoupper($smtpSecure) == "tls"); + $ssl = (strtoupper($smtpSecure) == "ssl"); + + $arrayResult["result"] = $smtp->Connect(($ssl ? "ssl://" : "") . $server, $port, $timeout); + $arrayResult["message"] = $serverNet->error; + break; + case 4: + //Try login to host + if ($auth_required == 1) { + try { + if (preg_match("/^(.+):([0-9]+)$/", $srv, $hostinfo)) { + $server = $hostinfo[1]; + $port = $hostinfo[2]; + } else { + $server = $srv; + } + if (strtoupper($useSecureCon)=="TLS") { + $tls = "tls"; + } + + if (strtoupper($useSecureCon)=="SSL") { + $tls = "ssl"; + } + + $tls = (strtoupper($useSecureCon) == "tls"); + $ssl = (strtoupper($useSecureCon) == "ssl"); + + $server = $arrayData["MESS_SERVER"]; + + if (strtoupper($useSecureCon) == "SSL") { + $resp = $smtp->Connect(("ssl://") . $server, $port, $timeout); + } else { + $resp = $smtp->Connect($server, $port, $timeout); + } + + if ($resp) { + $hello = $_SERVER["SERVER_NAME"]; + $smtp->Hello($hello); + + if (strtoupper($useSecureCon) == "TLS") { + $smtp->Hello($hello); + } + + if ($smtp->Authenticate($user, $passwd) ) { + $arrayResult["result"] = true; + } else { + if (strtoupper($useSecureCon) == "TLS") { + $arrayResult["result"] = true; + } else { + $arrayResult["result"] = false; + $smtpError = $smtp->getError(); + $arrayResult["message"] = $smtpError["error"]; + } + } + } else { + $arrayResult["result"] = false; + $smtpError = $smtp->getError(); + $arrayResult["message"] = $smtpError["error"]; + } + } catch (Exception $e) { + $arrayResult["result"] = false; + $arrayResult["message"] = $e->getMessage(); + } + } else { + $arrayResult["result"] = true; + $arrayResult["message"] = "No authentication required!"; + } + break; + case 5: + if ($sendTestMail == 1) { + try { + $arrayDataPhpMailer = array(); + + $eregMail = "/^[0-9a-zA-Z]+(?:[._][0-9a-zA-Z]+)*@[0-9a-zA-Z]+(?:[._-][0-9a-zA-Z]+)*\.[0-9a-zA-Z]{2,3}$/"; + + $arrayDataPhpMailer["FROM_EMAIL"] = ($fromMail != "" && preg_match($eregMail, $fromMail))? $fromMail : ""; + $arrayDataPhpMailer["FROM_NAME"] = $arrayData["MESS_FROM_NAME"] != "" ? $arrayData["MESS_FROM_NAME"] : \G::LoadTranslation("ID_MESS_TEST_BODY"); + $arrayDataPhpMailer["MESS_ENGINE"] = "PHPMAILER"; + $arrayDataPhpMailer["MESS_SERVER"] = $server; + $arrayDataPhpMailer["MESS_PORT"] = $port; + $arrayDataPhpMailer["MESS_ACCOUNT"] = $user; + $arrayDataPhpMailer["MESS_PASSWORD"] = $passwd; + $arrayDataPhpMailer["TO"] = $mailTo; + + if ($auth_required == 1) { + $arrayDataPhpMailer["MESS_RAUTH"] = true; + } else { + $arrayDataPhpMailer["MESS_RAUTH"] = false; + } + if (strtolower($arrayData["SMTPSECURE"]) != "no") { + $arrayDataPhpMailer["SMTPSecure"] = $arrayData["SMTPSECURE"]; + } + + $arrayTestMailResult = $this->sendTestMail($arrayDataPhpMailer); + + if ($arrayTestMailResult["status"] . "" == "1") { + $arrayResult["result"] = true; + } else { + $arrayResult["result"] = false; + $smtpError = $smtp->getError(); + $arrayResult["message"] = $smtpError["error"]; + } + } catch (Exception $e) { + $arrayResult["result"] = false; + $arrayResult["message"] = $e->getMessage(); + } + } else { + $arrayResult["result"] = true; + $arrayResult["message"] = "Jump this step"; + } + break; + } + + if (!isset($arrayResult["message"])) { + $arrayResult["message"] = ""; + } + + //Return + return $arrayResult; + } catch (\Exception $e) { + $arrayResult = array(); + + $arrayResult["result"] = false; + $arrayResult["message"] = $e->getMessage(); + + //Return + return $arrayResult; + } + } + + /** + * Test connection + * + * @param array $arrayData Data + * + * return array Return array with result of test connection + */ + public function testConnection(array $arrayData) + { + try { + $arrayData = array_change_key_case($arrayData, CASE_UPPER); + + $arrayMailTestName = array( + 1 => "verifying_mail", + 2 => "sending_email" + ); + + $arrayPhpMailerTestName = array( + 1 => "resolving_name", + 2 => "check_port", + 3 => "establishing_connection_host", + 4 => "login", + 5 => "sending_email" + ); + + $arrayResult = array(); + + switch ($arrayData["MESS_ENGINE"]) { + case "MAIL": + $arrayDataAux = $arrayData; + + $arrayDataAux["MESS_TRY_SEND_INMEDIATLY"] = 1; + $arrayDataAux["MAIL_TO"] = "admin@processmaker.com"; + + $arrayResult[$arrayMailTestName[1]] = $this->testConnectionByStep($arrayDataAux); + $arrayResult[$arrayMailTestName[1]]["title"] = \G::LoadTranslation("ID_EMAIL_SERVER_TEST_CONNECTION_VERIFYING_MAIL"); + + if ((int)($arrayData["MESS_TRY_SEND_INMEDIATLY"]) == 1) { + $arrayResult[$arrayMailTestName[2]] = $this->testConnectionByStep($arrayData); + $arrayResult[$arrayMailTestName[2]]["title"] = \G::LoadTranslation("ID_EMAIL_SERVER_TEST_CONNECTION_SENDING_EMAIL", array($arrayData["MAIL_TO"])); + } + break; + case "PHPMAILER": + for ($step = 1; $step <= 5; $step++) { + $arrayResult[$arrayPhpMailerTestName[$step]] = $this->testConnectionByStep($arrayData, $step); + + switch ($step) { + case 1: + $arrayResult[$arrayPhpMailerTestName[$step]]["title"] = \G::LoadTranslation("ID_EMAIL_SERVER_TEST_CONNECTION_RESOLVING_NAME", array($arrayData["MESS_SERVER"])); + break; + case 2: + $arrayResult[$arrayPhpMailerTestName[$step]]["title"] = \G::LoadTranslation("ID_EMAIL_SERVER_TEST_CONNECTION_CHECK_PORT", array($arrayData["MESS_PORT"])); + break; + case 3: + $arrayResult[$arrayPhpMailerTestName[$step]]["title"] = \G::LoadTranslation("ID_EMAIL_SERVER_TEST_CONNECTION_ESTABLISHING_CON_HOST", array($arrayData["MESS_SERVER"] . ":" . $arrayData["MESS_PORT"])); + break; + case 4: + $arrayResult[$arrayPhpMailerTestName[$step]]["title"] = \G::LoadTranslation("ID_EMAIL_SERVER_TEST_CONNECTION_LOGIN", array($arrayData["MESS_ACCOUNT"], $arrayData["MESS_SERVER"])); + break; + case 5: + $arrayResult[$arrayPhpMailerTestName[$step]]["title"] = \G::LoadTranslation("ID_EMAIL_SERVER_TEST_CONNECTION_SENDING_EMAIL", array($arrayData["MAIL_TO"])); + break; + } + } + break; + } + + //Result + return $arrayResult; + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Check if is default Email Server + * + * @param string $emailServerUid Unique id of Email Server + * + * return bool Return true if is default Email Server, false otherwise + */ + public function checkIfIsDefault($emailServerUid) + { + try { + $criteria = $this->getEmailServerCriteria(); + + $criteria->add(\EmailServerPeer::MESS_UID, $emailServerUid, \Criteria::EQUAL); + $criteria->add(\EmailServerPeer::MESS_DEFAULT, 1, \Criteria::EQUAL); + + $rsCriteria = \EmailServerPeer::doSelectRS($criteria); + + if ($rsCriteria->next()) { + return true; + } else { + return false; + } + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Validate the data if they are invalid (INSERT and UPDATE) + * + * @param string $emailServerUid Unique id of Email Server + * @param array $arrayData Data + * + * return void Throw exception if data has an invalid value + */ + public function throwExceptionIfDataIsInvalid($emailServerUid, array $arrayData) + { + try { + //Set variables + $arrayEmailServerData = ($emailServerUid == "")? array() : $this->getEmailServer($emailServerUid, true); + $flagInsert = ($emailServerUid == "")? true : false; + + $arrayFinalData = array_merge($arrayEmailServerData, $arrayData); + + //Verify data + $process = new \ProcessMaker\BusinessModel\Process(); + + $arrayFieldDefinition = $this->arrayFieldDefinition; + + switch ($arrayFinalData["MESS_ENGINE"]) { + case "PHPMAILER": + $arrayFieldDefinition["MESS_SERVER"]["required"] = true; + $arrayFieldDefinition["MESS_SERVER"]["empty"] = false; + + $arrayFieldDefinition["MESS_PORT"]["required"] = true; + $arrayFieldDefinition["MESS_PORT"]["empty"] = false; + + $arrayFieldDefinition["MESS_ACCOUNT"]["required"] = true; + $arrayFieldDefinition["MESS_ACCOUNT"]["empty"] = false; + + $arrayFieldDefinition["SMTPSECURE"]["required"] = true; + $arrayFieldDefinition["SMTPSECURE"]["empty"] = false; + + if ((int)($arrayFinalData["MESS_RAUTH"]) == 1) { + $arrayFieldDefinition["MESS_PASSWORD"]["required"] = true; + $arrayFieldDefinition["MESS_PASSWORD"]["empty"] = false; + } + break; + case "MAIL": + $arrayFieldDefinition["SMTPSECURE"]["empty"] = true; + $arrayFieldDefinition["SMTPSECURE"]["defaultValues"] = array(); + break; + } + + if ((int)($arrayFinalData["MESS_TRY_SEND_INMEDIATLY"]) == 1) { + $arrayFieldDefinition["MAIL_TO"]["required"] = true; + $arrayFieldDefinition["MAIL_TO"]["empty"] = false; + } + + $process->throwExceptionIfDataNotMetFieldDefinition($arrayData, $arrayFieldDefinition, $this->arrayFieldNameForException, $flagInsert); + + if ($flagInsert == false) { + //Update + $process->throwExceptionIfDataNotMetFieldDefinition($arrayFinalData, $arrayFieldDefinition, $this->arrayFieldNameForException, true); + } + + //Verify data Test Connection + if (isset($_SERVER["SERVER_NAME"])) { + $arrayTestConnectionResult = $this->testConnection($arrayFinalData); + + $msg = ""; + + foreach ($arrayTestConnectionResult as $key => $value) { + $arrayTest = $value; + + if (!$arrayTest["result"]) { + $msg = $msg . (($msg != "")? ", " : "") . $arrayTest["title"] . " (Error: " . $arrayTest["message"] . ")"; + } + } + + if ($msg != "") { + throw new \Exception($msg); + } + } + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Verify if does not exist the Email Server in table EMAIL_SERVER + * + * @param string $emailServerUid Unique id of Email Server + * @param string $fieldNameForException Field name for the exception + * + * return void Throw exception if does not exist the Email Server in table EMAIL_SERVER + */ + public function throwExceptionIfNotExistsEmailServer($emailServerUid, $fieldNameForException) + { + try { + $obj = \EmailServerPeer::retrieveByPK($emailServerUid); + + if (is_null($obj)) { + throw new \Exception(\G::LoadTranslation("ID_EMAIL_SERVER_DOES_NOT_EXIST", array($fieldNameForException, $emailServerUid))); + } + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Check if is default Email Server + * + * @param string $emailServerUid Unique id of Email Server + * @param string $fieldNameForException Field name for the exception + * + * return void Throw exception if is default Email Server + */ + public function throwExceptionIfIsDefault($emailServerUid, $fieldNameForException) + { + try { + if ($this->checkIfIsDefault($emailServerUid)) { + throw new \Exception(\G::LoadTranslation("ID_EMAIL_SERVER_IS_DEFAULT", array($fieldNameForException, $emailServerUid))); + } + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Set default Email Server by Unique id of Email Server + * + * @param string $emailServerUid Unique id of Email Server + * + * return void + */ + public function setEmailServerDefaultByUid($emailServerUid) + { + try { + + $arrayEmailServerData = $this->getEmailServer($emailServerUid, true); + + //Update + //Update - WHERE + $criteriaWhere = new \Criteria("workflow"); + $criteriaWhere->add(\EmailServerPeer::MESS_UID, $emailServerUid, \Criteria::NOT_EQUAL); + + //Update + $criteriaSet = new \Criteria("workflow"); + $criteriaSet->add(\EmailServerPeer::MESS_DEFAULT, 0); + + \BasePeer::doUpdate($criteriaWhere, $criteriaSet, \Propel::getConnection("workflow")); + + if ((int)($arrayEmailServerData["MESS_DEFAULT"]) == 0) { + //Update + //Update - WHERE + $criteriaWhere = new \Criteria("workflow"); + $criteriaWhere->add(\EmailServerPeer::MESS_UID, $emailServerUid, \Criteria::NOT_EQUAL); + + //Update + $criteriaSet = new \Criteria("workflow"); + $criteriaSet->add(\EmailServerPeer::MESS_DEFAULT, 1); + + \BasePeer::doUpdate($criteriaWhere, $criteriaSet, \Propel::getConnection("workflow")); + } + } catch (Exception $e) { + throw $e; + } + } + + /** + * Create Email Server + * + * @param array $arrayData Data + * + * return array Return data of the new Email Server created + */ + public function create(array $arrayData) + { + try { + //Verify data + $process = new \ProcessMaker\BusinessModel\Process(); + $validator = new \ProcessMaker\BusinessModel\Validator(); + + $validator->throwExceptionIfDataIsNotArray($arrayData, "\$arrayData"); + $validator->throwExceptionIfDataIsEmpty($arrayData, "\$arrayData"); + + //Set data + $arrayData = array_change_key_case($arrayData, CASE_UPPER); + + unset($arrayData["MESS_UID"]); + + $this->throwExceptionIfDataIsInvalid("", $arrayData); + + //Create + $cnn = \Propel::getConnection("workflow"); + + try { + $emailServer = new \EmailServer(); + + $emailServer->fromArray($arrayData, \BasePeer::TYPE_FIELDNAME); + + $emailServerUid = \ProcessMaker\Util\Common::generateUID(); + + $emailServer->setMessUid($emailServerUid); + + if ($emailServer->validate()) { + $cnn->begin(); + + $result = $emailServer->save(); + + $cnn->commit(); + + if (isset($arrayData["MESS_DEFAULT"]) && (int)($arrayData["MESS_DEFAULT"]) == 1) { + $this->setEmailServerDefaultByUid($emailServerUid); + } + + //Return + return $this->getEmailServer($emailServerUid); + } else { + $msg = ""; + + foreach ($emailServer->getValidationFailures() as $validationFailure) { + $msg = $msg . (($msg != "")? "\n" : "") . $validationFailure->getMessage(); + } + + throw new \Exception(\G::LoadTranslation("ID_RECORD_CANNOT_BE_CREATED") . (($msg != "")? "\n" . $msg : "")); + } + } catch (\Exception $e) { + $cnn->rollback(); + + throw $e; + } + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Update Email Server + * + * @param string $emailServerUid Unique id of Group + * @param array $arrayData Data + * + * return array Return data of the Email Server updated + */ + public function update($emailServerUid, $arrayData) + { + try { + //Verify data + $process = new \ProcessMaker\BusinessModel\Process(); + $validator = new \ProcessMaker\BusinessModel\Validator(); + + $validator->throwExceptionIfDataIsNotArray($arrayData, "\$arrayData"); + $validator->throwExceptionIfDataIsEmpty($arrayData, "\$arrayData"); + + //Set data + $arrayData = array_change_key_case($arrayData, CASE_UPPER); + + //Verify data + $this->throwExceptionIfNotExistsEmailServer($emailServerUid, $this->arrayFieldNameForException["emailServerUid"]); + + $this->throwExceptionIfDataIsInvalid($emailServerUid, $arrayData); + + //Update + $cnn = \Propel::getConnection("workflow"); + + try { + $emailServer = \EmailServerPeer::retrieveByPK($emailServerUid); + $emailServer->fromArray($arrayData, \BasePeer::TYPE_FIELDNAME); + + if ($emailServer->validate()) { + $cnn->begin(); + + $result = $emailServer->save(); + + $cnn->commit(); + + if (isset($arrayData["MESS_DEFAULT"]) && (int)($arrayData["MESS_DEFAULT"]) == 1) { + $this->setEmailServerDefaultByUid($emailServerUid); + } + + //Return + if (!$this->formatFieldNameInUppercase) { + $arrayData = array_change_key_case($arrayData, CASE_LOWER); + } + + return $arrayData; + } else { + $msg = ""; + + foreach ($emailServer->getValidationFailures() as $validationFailure) { + $msg = $msg . (($msg != "")? "\n" : "") . $validationFailure->getMessage(); + } + + throw new \Exception(\G::LoadTranslation("ID_RECORD_CANNOT_BE_CREATED") . (($msg != "")? "\n" . $msg : "")); + } + } catch (\Exception $e) { + $cnn->rollback(); + + throw $e; + } + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Delete Email Server + * + * @param string $emailServerUid Unique id of Email Server + * + * return void + */ + public function delete($emailServerUid) + { + try { + //Verify data + $this->throwExceptionIfNotExistsEmailServer($emailServerUid, $this->arrayFieldNameForException["emailServerUid"]); + + $this->throwExceptionIfIsDefault($emailServerUid, $this->arrayFieldNameForException["emailServerUid"]); + + $criteria = $this->getEmailServerCriteria(); + + $criteria->add(\EmailServerPeer::MESS_UID, $emailServerUid, \Criteria::EQUAL); + + \EmailServerPeer::doDelete($criteria); + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Get criteria for Email Server + * + * return object + */ + public function getEmailServerCriteria() + { + try { + $criteria = new \Criteria("workflow"); + + $criteria->addSelectColumn(\EmailServerPeer::MESS_UID); + $criteria->addSelectColumn(\EmailServerPeer::MESS_ENGINE); + $criteria->addSelectColumn(\EmailServerPeer::MESS_SERVER); + $criteria->addSelectColumn(\EmailServerPeer::MESS_PORT); + $criteria->addSelectColumn(\EmailServerPeer::MESS_RAUTH); + $criteria->addSelectColumn(\EmailServerPeer::MESS_ACCOUNT); + $criteria->addSelectColumn(\EmailServerPeer::MESS_PASSWORD); + $criteria->addSelectColumn(\EmailServerPeer::MESS_FROM_MAIL); + $criteria->addSelectColumn(\EmailServerPeer::MESS_FROM_NAME); + $criteria->addSelectColumn(\EmailServerPeer::SMTPSECURE); + $criteria->addSelectColumn(\EmailServerPeer::MESS_TRY_SEND_INMEDIATLY); + $criteria->addSelectColumn(\EmailServerPeer::MAIL_TO); + $criteria->addSelectColumn(\EmailServerPeer::MESS_DEFAULT); + + return $criteria; + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Get data of a from a record + * + * @param array $record Record + * + * return array Return an array with data Email Server + */ + public function getEmailServerDataFromRecord(array $record) + { + try { + return array( + $this->getFieldNameByFormatFieldName("MESS_UID") => $record["MESS_UID"], + $this->getFieldNameByFormatFieldName("MESS_ENGINE") => $record["MESS_ENGINE"], + $this->getFieldNameByFormatFieldName("MESS_SERVER") => $record["MESS_SERVER"], + $this->getFieldNameByFormatFieldName("MESS_PORT") => $record["MESS_PORT"], + $this->getFieldNameByFormatFieldName("MESS_RAUTH") => $record["MESS_RAUTH"], + $this->getFieldNameByFormatFieldName("MESS_ACCOUNT") => $record["MESS_ACCOUNT"], + $this->getFieldNameByFormatFieldName("MESS_PASSWORD") => $record["MESS_PASSWORD"], + $this->getFieldNameByFormatFieldName("MESS_FROM_MAIL") => $record["MESS_FROM_MAIL"], + $this->getFieldNameByFormatFieldName("MESS_FROM_NAME") => $record["MESS_FROM_NAME"], + $this->getFieldNameByFormatFieldName("SMTPSECURE") => $record["SMTPSECURE"], + $this->getFieldNameByFormatFieldName("MESS_TRY_SEND_INMEDIATLY") => $record["MESS_TRY_SEND_INMEDIATLY"], + $this->getFieldNameByFormatFieldName("MAIL_TO") => $record["MAIL_TO"], + $this->getFieldNameByFormatFieldName("MESS_DEFAULT") => $record["MESS_DEFAULT"] + ); + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Get Default Email Server + * + * return array Return an array with Email Server default + */ + public function getEmailServerDefault() + { + try { + $arrayData = array(); + + //SQL + $criteria = $this->getEmailServerCriteria(); + + $criteria->add(EmailServerPeer::MESS_DEFAULT, 1, Criteria::EQUAL); + + //QUERY + $rsCriteria = EmailServerPeer::doSelectRS($criteria); + $rsCriteria->setFetchmode(ResultSet::FETCHMODE_ASSOC); + + while ($rsCriteria->next()) { + $row = $rsCriteria->getRow(); + + $arrayData["MESS_ENGINE"] = $row["MESS_ENGINE"]; + $arrayData["MESS_SERVER"] = $row["MESS_SERVER"]; + $arrayData["MESS_PORT"] = (int)($row["MESS_PORT"]); + $arrayData["MESS_RAUTH"] = (int)($row["MESS_RAUTH"]); + $arrayData["MESS_ACCOUNT"] = $row["MESS_ACCOUNT"]; + $arrayData["MESS_PASSWORD"] = $row["MESS_PASSWORD"]; + $arrayData["MESS_FROM_MAIL"] = $row["MESS_FROM_MAIL"]; + $arrayData["MESS_FROM_NAME"] = $row["MESS_FROM_NAME"]; + $arrayData["SMTPSECURE"] = $row["SMTPSECURE"]; + $arrayData["MESS_TRY_SEND_INMEDIATLY"] = (int)($row["MESS_TRY_SEND_INMEDIATLY"]); + $arrayData["MAIL_TO"] = $row["MAIL_TO"]; + $arrayData["MESS_DEFAULT"] = (int)($row["MESS_DEFAULT"]); + } + + //Return + return $arrayData; + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Get all Email Servers + * + * @param array $arrayFilterData Data of the filters + * @param string $sortField Field name to sort + * @param string $sortDir Direction of sorting (ASC, DESC) + * @param int $start Start + * @param int $limit Limit + * + * return array Return an array with all Email Servers + */ + public function getEmailServers($arrayFilterData = null, $sortField = null, $sortDir = null, $start = null, $limit = null) + { + try { + $arrayEmailServer = array(); + + //Verify data + $process = new \ProcessMaker\BusinessModel\Process(); + + $process->throwExceptionIfDataNotMetPagerVarDefinition(array("start" => $start, "limit" => $limit), $this->arrayFieldNameForException); + + //Get data + if (!is_null($limit) && $limit . "" == "0") { + return $arrayEmailServer; + } + + //SQL + $criteria = $this->getEmailServerCriteria(); + + if (!is_null($arrayFilterData) && is_array($arrayFilterData) && isset($arrayFilterData["filter"]) && trim($arrayFilterData["filter"]) != "") { + $criteria->add( + $criteria->getNewCriterion(\EmailServerPeer::MESS_ENGINE, "%" . $arrayFilterData["filter"] . "%", \Criteria::LIKE)->addOr( + $criteria->getNewCriterion(\EmailServerPeer::MESS_SERVER, "%" . $arrayFilterData["filter"] . "%", \Criteria::LIKE))->addOr( + $criteria->getNewCriterion(\EmailServerPeer::MESS_ACCOUNT, "%" . $arrayFilterData["filter"] . "%", \Criteria::LIKE))->addOr( + $criteria->getNewCriterion(\EmailServerPeer::MESS_FROM_NAME, "%" . $arrayFilterData["filter"] . "%", \Criteria::LIKE))->addOr( + $criteria->getNewCriterion(\EmailServerPeer::SMTPSECURE, "%" . $arrayFilterData["filter"] . "%", \Criteria::LIKE)) + ); + } + + //Number records total + $criteriaCount = clone $criteria; + + $criteriaCount->clearSelectColumns(); + $criteriaCount->addSelectColumn("COUNT(" . \EmailServerPeer::MESS_UID . ") AS NUM_REC"); + + $rsCriteriaCount = \EmailServerPeer::doSelectRS($criteriaCount); + $rsCriteriaCount->setFetchmode(\ResultSet::FETCHMODE_ASSOC); + + $rsCriteriaCount->next(); + $row = $rsCriteriaCount->getRow(); + + $numRecTotal = $row["NUM_REC"]; + + //SQL + if (!is_null($sortField) && trim($sortField) != "") { + $sortField = strtoupper($sortField); + + if (in_array($sortField, array("MESS_ENGINE", "MESS_SERVER", "MESS_ACCOUNT", "MESS_FROM_NAME", "SMTPSECURE"))) { + $sortField = \EmailServerPeer::TABLE_NAME . "." . $sortField; + } else { + $sortField = \EmailServerPeer::MESS_ENGINE; + } + } else { + $sortField = \EmailServerPeer::MESS_ENGINE; + } + + if (!is_null($sortDir) && trim($sortDir) != "" && strtoupper($sortDir) == "DESC") { + $criteria->addDescendingOrderByColumn($sortField); + } else { + $criteria->addAscendingOrderByColumn($sortField); + } + + if (!is_null($start)) { + $criteria->setOffset((int)($start)); + } + + if (!is_null($limit)) { + $criteria->setLimit((int)($limit)); + } + + $rsCriteria = \EmailServerPeer::doSelectRS($criteria); + $rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC); + + while ($rsCriteria->next()) { + $row = $rsCriteria->getRow(); + + $arrayEmailServer[] = $this->getEmailServerDataFromRecord($row); + } + + //Return + return array( + "total" => $numRecTotal, + "start" => (int)((!is_null($start))? $start : 0), + "limit" => (int)((!is_null($limit))? $limit : 0), + "filter" => (!is_null($arrayFilterData) && is_array($arrayFilterData) && isset($arrayFilterData["filter"]))? $arrayFilterData["filter"] : "", + "data" => $arrayEmailServer + ); + } catch (\Exception $e) { + throw $e; + } + } + + /** + * Get data of a Email Server + * + * @param string $emailServerUid Unique id of Email Server + * @param bool $flagGetRecord Value that set the getting + * + * return array Return an array with data of a Email Server + */ + public function getEmailServer($emailServerUid, $flagGetRecord = false) + { + try { + //Verify data + $this->throwExceptionIfNotExistsEmailServer($emailServerUid, $this->arrayFieldNameForException["emailServerUid"]); + + //Get data + //SQL + $criteria = $this->getEmailServerCriteria(); + + $criteria->add(\EmailServerPeer::MESS_UID, $emailServerUid, \Criteria::EQUAL); + + $rsCriteria = \EmailServerPeer::doSelectRS($criteria); + $rsCriteria->setFetchmode(\ResultSet::FETCHMODE_ASSOC); + + $rsCriteria->next(); + + $row = $rsCriteria->getRow(); + + $row["MESS_PORT"] = (int)($row["MESS_PORT"]); + $row["MESS_RAUTH"] = (int)($row["MESS_RAUTH"]); + $row["MESS_TRY_SEND_INMEDIATLY"] = (int)($row["MESS_TRY_SEND_INMEDIATLY"]); + $row["MESS_DEFAULT"] = (int)($row["MESS_DEFAULT"]); + + //Return + return (!$flagGetRecord)? $this->getEmailServerDataFromRecord($row) : $row; + } catch (\Exception $e) { + throw $e; + } + } +} + diff --git a/workflow/engine/src/ProcessMaker/Services/Api/EmailServer.php b/workflow/engine/src/ProcessMaker/Services/Api/EmailServer.php new file mode 100644 index 000000000..3e401eb1c --- /dev/null +++ b/workflow/engine/src/ProcessMaker/Services/Api/EmailServer.php @@ -0,0 +1,158 @@ +emailServer = new \ProcessMaker\BusinessModel\EmailServer(); + + $this->emailServer->setFormatFieldNameInUppercase(false); + } catch (\Exception $e) { + throw (new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage())); + } + } + + /** + * @url GET + * + * @param string $filter + * @param int $start + * @param int $limit + * + */ + public function index($filter = null, $start = null, $limit = null) + { + try { + $arrayAux = $this->emailServer->getEmailServers(array("filter" => $filter), null, null, $start, $limit); + + $response = $arrayAux["data"]; + + return $response; + } catch (\Exception $e) { + throw (new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage())); + } + } + + /** + * @url GET /:mess_uid + * + * @param string $mess_uid {@min 32}{@max 32} + */ + public function doGet($mess_uid) + { + try { + $response = $this->emailServer->getEmailServer($mess_uid); + + return $response; + } catch (\Exception $e) { + throw (new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage())); + } + } + + /** + * @url GET /paged + * + * @param string $filter + * @param int $start + * @param int $limit + */ + public function doGetPaged($filter = null, $start = null, $limit = null) + { + try { + $response = $this->emailServer->getEmailServers(array("filter" => $filter), null, null, $start, $limit); + + return $response; + } catch (\Exception $e) { + throw (new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage())); + } + } + + /** + * @url POST /test-connection + * + * @param array $request_data + */ + public function doPostTestConnection(array $request_data) + { + try { + $arrayData = $this->emailServer->testConnection($request_data); + + $response = $arrayData; + + return $response; + } catch (\Exception $e) { + throw (new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage())); + } + } + + /** + * @url POST + * + * @param array $request_data + * + * @status 201 + */ + public function doPost(array $request_data) + { + try { + $arrayData = $this->emailServer->create($request_data); + + $response = $arrayData; + + return $response; + } catch (\Exception $e) { + throw (new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage())); + } + } + + /** + * @url PUT /:mess_uid + * + * @param string $mess_uid {@min 32}{@max 32} + * @param array $request_data + * + * @status 200 + */ + public function doPut($mess_uid, array $request_data) + { + try { + $arrayData = $this->emailServer->update($mess_uid, $request_data); + } catch (\Exception $e) { + throw (new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage())); + } + } + + /** + * @url DELETE /:mess_uid + * + * @param string $mess_uid {@min 32}{@max 32} + * + * @status 200 + */ + public function doDelete($mess_uid) + { + try { + $this->emailServer->delete($mess_uid); + } catch (\Exception $e) { + throw (new RestException(Api::STAT_APP_EXCEPTION, $e->getMessage())); + } + } +} + diff --git a/workflow/engine/src/ProcessMaker/Services/api.ini b/workflow/engine/src/ProcessMaker/Services/api.ini index a4cf14240..54225a990 100644 --- a/workflow/engine/src/ProcessMaker/Services/api.ini +++ b/workflow/engine/src/ProcessMaker/Services/api.ini @@ -86,4 +86,10 @@ debug = 1 file = "ProcessMaker\Services\Api\File" [alias: files] - file = "ProcessMaker\Services\Api\Files" \ No newline at end of file + file = "ProcessMaker\Services\Api\Files" + +[alias: email] + email = "ProcessMaker\Services\Api\EmailServer" + +[alias: emails] + email = "ProcessMaker\Services\Api\EmailServer" \ No newline at end of file