/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $rouUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($rouUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(RoutePeer::ROU_UID);
$criteria->addSelectColumn(RoutePeer::ROU_PARENT);
$criteria->addSelectColumn(RoutePeer::PRO_UID);
$criteria->addSelectColumn(RoutePeer::TAS_UID);
$criteria->addSelectColumn(RoutePeer::ROU_NEXT_TASK);
$criteria->addSelectColumn(RoutePeer::ROU_CASE);
$criteria->addSelectColumn(RoutePeer::ROU_TYPE);
$criteria->addSelectColumn(RoutePeer::ROU_CONDITION);
$criteria->addSelectColumn(RoutePeer::ROU_TO_LAST_USER);
$criteria->addSelectColumn(RoutePeer::ROU_OPTIONAL);
$criteria->addSelectColumn(RoutePeer::ROU_SEND_EMAIL);
$criteria->addSelectColumn(RoutePeer::ROU_SOURCEANCHOR);
$criteria->addSelectColumn(RoutePeer::ROU_TARGETANCHOR);
$criteria->addSelectColumn(RoutePeer::ROU_TO_PORT);
$criteria->addSelectColumn(RoutePeer::ROU_FROM_PORT);
$criteria->addSelectColumn(RoutePeer::ROU_EVN_UID);
$criteria->addSelectColumn(RoutePeer::GAT_UID);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = RoutePeer::retrieveByPK($rouUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table Route ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $appMsgUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($appMsgUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_UID);
$criteria->addSelectColumn(AppMessagePeer::MSG_UID);
$criteria->addSelectColumn(AppMessagePeer::APP_UID);
$criteria->addSelectColumn(AppMessagePeer::DEL_INDEX);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_TYPE);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_SUBJECT);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_FROM);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_TO);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_BODY);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_DATE);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_CC);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_BCC);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_TEMPLATE);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_STATUS);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_ATTACH);
$criteria->addSelectColumn(AppMessagePeer::APP_MSG_SEND_DATE);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = AppMessagePeer::retrieveByPK($appMsgUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table AppMessage ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $appUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($appUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(ApplicationPeer::APP_UID);
$criteria->addSelectColumn(ApplicationPeer::APP_NUMBER);
$criteria->addSelectColumn(ApplicationPeer::APP_PARENT);
$criteria->addSelectColumn(ApplicationPeer::APP_STATUS);
$criteria->addSelectColumn(ApplicationPeer::PRO_UID);
$criteria->addSelectColumn(ApplicationPeer::APP_PROC_STATUS);
$criteria->addSelectColumn(ApplicationPeer::APP_PROC_CODE);
$criteria->addSelectColumn(ApplicationPeer::APP_PARALLEL);
$criteria->addSelectColumn(ApplicationPeer::APP_INIT_USER);
$criteria->addSelectColumn(ApplicationPeer::APP_CUR_USER);
$criteria->addSelectColumn(ApplicationPeer::APP_CREATE_DATE);
$criteria->addSelectColumn(ApplicationPeer::APP_INIT_DATE);
$criteria->addSelectColumn(ApplicationPeer::APP_FINISH_DATE);
$criteria->addSelectColumn(ApplicationPeer::APP_UPDATE_DATE);
$criteria->addSelectColumn(ApplicationPeer::APP_DATA);
$criteria->addSelectColumn(ApplicationPeer::APP_PIN);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = ApplicationPeer::retrieveByPK($appUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table Application ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $addTabUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($addTabUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_UID);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_NAME);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_CLASS_NAME);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_DESCRIPTION);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_SDW_LOG_INSERT);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_SDW_LOG_UPDATE);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_SDW_LOG_DELETE);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_SDW_LOG_SELECT);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_SDW_MAX_LENGTH);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_SDW_AUTO_DELETE);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_PLG_UID);
$criteria->addSelectColumn(AdditionalTablesPeer::DBS_UID);
$criteria->addSelectColumn(AdditionalTablesPeer::PRO_UID);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_TYPE);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_GRID);
$criteria->addSelectColumn(AdditionalTablesPeer::ADD_TAB_TAG);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = AdditionalTablesPeer::retrieveByPK($addTabUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table AdditionalTables ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $fldUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($fldUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(FieldsPeer::FLD_UID);
$criteria->addSelectColumn(FieldsPeer::ADD_TAB_UID);
$criteria->addSelectColumn(FieldsPeer::FLD_INDEX);
$criteria->addSelectColumn(FieldsPeer::FLD_NAME);
$criteria->addSelectColumn(FieldsPeer::FLD_DESCRIPTION);
$criteria->addSelectColumn(FieldsPeer::FLD_TYPE);
$criteria->addSelectColumn(FieldsPeer::FLD_SIZE);
$criteria->addSelectColumn(FieldsPeer::FLD_NULL);
$criteria->addSelectColumn(FieldsPeer::FLD_AUTO_INCREMENT);
$criteria->addSelectColumn(FieldsPeer::FLD_KEY);
$criteria->addSelectColumn(FieldsPeer::FLD_FOREIGN_KEY);
$criteria->addSelectColumn(FieldsPeer::FLD_FOREIGN_KEY_TABLE);
$criteria->addSelectColumn(FieldsPeer::FLD_DYN_NAME);
$criteria->addSelectColumn(FieldsPeer::FLD_DYN_UID);
$criteria->addSelectColumn(FieldsPeer::FLD_FILTER);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = FieldsPeer::retrieveByPK($fldUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table Fields ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $appDocUid, $docVersion Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($appDocUid = null, $docVersion = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(AppDocumentPeer::APP_DOC_UID);
$criteria->addSelectColumn(AppDocumentPeer::DOC_VERSION);
$criteria->addSelectColumn(AppDocumentPeer::APP_UID);
$criteria->addSelectColumn(AppDocumentPeer::DEL_INDEX);
$criteria->addSelectColumn(AppDocumentPeer::DOC_UID);
$criteria->addSelectColumn(AppDocumentPeer::USR_UID);
$criteria->addSelectColumn(AppDocumentPeer::APP_DOC_TYPE);
$criteria->addSelectColumn(AppDocumentPeer::APP_DOC_CREATE_DATE);
$criteria->addSelectColumn(AppDocumentPeer::APP_DOC_INDEX);
$criteria->addSelectColumn(AppDocumentPeer::FOLDER_UID);
$criteria->addSelectColumn(AppDocumentPeer::APP_DOC_PLUGIN);
$criteria->addSelectColumn(AppDocumentPeer::APP_DOC_TAGS);
$criteria->addSelectColumn(AppDocumentPeer::APP_DOC_STATUS);
$criteria->addSelectColumn(AppDocumentPeer::APP_DOC_STATUS_DATE);
$criteria->addSelectColumn(AppDocumentPeer::APP_DOC_FIELDNAME);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = AppDocumentPeer::retrieveByPK($appDocUid, $docVersion);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table AppDocument ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $appDelayUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($appDelayUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(AppDelayPeer::APP_DELAY_UID);
$criteria->addSelectColumn(AppDelayPeer::PRO_UID);
$criteria->addSelectColumn(AppDelayPeer::APP_UID);
$criteria->addSelectColumn(AppDelayPeer::APP_THREAD_INDEX);
$criteria->addSelectColumn(AppDelayPeer::APP_DEL_INDEX);
$criteria->addSelectColumn(AppDelayPeer::APP_TYPE);
$criteria->addSelectColumn(AppDelayPeer::APP_STATUS);
$criteria->addSelectColumn(AppDelayPeer::APP_NEXT_TASK);
$criteria->addSelectColumn(AppDelayPeer::APP_DELEGATION_USER);
$criteria->addSelectColumn(AppDelayPeer::APP_ENABLE_ACTION_USER);
$criteria->addSelectColumn(AppDelayPeer::APP_ENABLE_ACTION_DATE);
$criteria->addSelectColumn(AppDelayPeer::APP_DISABLE_ACTION_USER);
$criteria->addSelectColumn(AppDelayPeer::APP_DISABLE_ACTION_DATE);
$criteria->addSelectColumn(AppDelayPeer::APP_AUTOMATIC_DISABLED_DATE);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = AppDelayPeer::retrieveByPK($appDelayUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table AppDelay ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $spUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($spUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(SubProcessPeer::SP_UID);
$criteria->addSelectColumn(SubProcessPeer::PRO_UID);
$criteria->addSelectColumn(SubProcessPeer::TAS_UID);
$criteria->addSelectColumn(SubProcessPeer::PRO_PARENT);
$criteria->addSelectColumn(SubProcessPeer::TAS_PARENT);
$criteria->addSelectColumn(SubProcessPeer::SP_TYPE);
$criteria->addSelectColumn(SubProcessPeer::SP_SYNCHRONOUS);
$criteria->addSelectColumn(SubProcessPeer::SP_SYNCHRONOUS_TYPE);
$criteria->addSelectColumn(SubProcessPeer::SP_SYNCHRONOUS_WAIT);
$criteria->addSelectColumn(SubProcessPeer::SP_VARIABLES_OUT);
$criteria->addSelectColumn(SubProcessPeer::SP_VARIABLES_IN);
$criteria->addSelectColumn(SubProcessPeer::SP_GRID_IN);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = SubProcessPeer::retrieveByPK($spUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table SubProcess ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $opUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($opUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(ObjectPermissionPeer::OP_UID);
$criteria->addSelectColumn(ObjectPermissionPeer::PRO_UID);
$criteria->addSelectColumn(ObjectPermissionPeer::TAS_UID);
$criteria->addSelectColumn(ObjectPermissionPeer::USR_UID);
$criteria->addSelectColumn(ObjectPermissionPeer::OP_USER_RELATION);
$criteria->addSelectColumn(ObjectPermissionPeer::OP_TASK_SOURCE);
$criteria->addSelectColumn(ObjectPermissionPeer::OP_PARTICIPATE);
$criteria->addSelectColumn(ObjectPermissionPeer::OP_OBJ_TYPE);
$criteria->addSelectColumn(ObjectPermissionPeer::OP_OBJ_UID);
$criteria->addSelectColumn(ObjectPermissionPeer::OP_ACTION);
$criteria->addSelectColumn(ObjectPermissionPeer::OP_CASE_STATUS);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = ObjectPermissionPeer::retrieveByPK($opUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table ObjectPermission ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get()
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(AppNotesPeer::APP_UID);
$criteria->addSelectColumn(AppNotesPeer::USR_UID);
$criteria->addSelectColumn(AppNotesPeer::NOTE_DATE);
$criteria->addSelectColumn(AppNotesPeer::NOTE_CONTENT);
$criteria->addSelectColumn(AppNotesPeer::NOTE_TYPE);
$criteria->addSelectColumn(AppNotesPeer::NOTE_AVAILABILITY);
$criteria->addSelectColumn(AppNotesPeer::NOTE_ORIGIN_OBJ);
$criteria->addSelectColumn(AppNotesPeer::NOTE_AFFECTED_OBJ1);
$criteria->addSelectColumn(AppNotesPeer::NOTE_AFFECTED_OBJ2);
$criteria->addSelectColumn(AppNotesPeer::NOTE_RECIPIENTS);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = AppNotesPeer::retrieveByPK();
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table AppNotes ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $logCaseUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($logCaseUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(LogCasesSchedulerPeer::LOG_CASE_UID);
$criteria->addSelectColumn(LogCasesSchedulerPeer::PRO_UID);
$criteria->addSelectColumn(LogCasesSchedulerPeer::TAS_UID);
$criteria->addSelectColumn(LogCasesSchedulerPeer::USR_NAME);
$criteria->addSelectColumn(LogCasesSchedulerPeer::EXEC_DATE);
$criteria->addSelectColumn(LogCasesSchedulerPeer::EXEC_HOUR);
$criteria->addSelectColumn(LogCasesSchedulerPeer::RESULT);
$criteria->addSelectColumn(LogCasesSchedulerPeer::SCH_UID);
$criteria->addSelectColumn(LogCasesSchedulerPeer::WS_CREATE_CASE_STATUS);
$criteria->addSelectColumn(LogCasesSchedulerPeer::WS_ROUTE_CASE_STATUS);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = LogCasesSchedulerPeer::retrieveByPK($logCaseUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table LogCasesScheduler ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $appUid, $appParent, $delIndexParent, $delThreadParent Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($appUid = null, $appParent = null, $delIndexParent = null, $delThreadParent = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(SubApplicationPeer::APP_UID);
$criteria->addSelectColumn(SubApplicationPeer::APP_PARENT);
$criteria->addSelectColumn(SubApplicationPeer::DEL_INDEX_PARENT);
$criteria->addSelectColumn(SubApplicationPeer::DEL_THREAD_PARENT);
$criteria->addSelectColumn(SubApplicationPeer::SA_STATUS);
$criteria->addSelectColumn(SubApplicationPeer::SA_VALUES_OUT);
$criteria->addSelectColumn(SubApplicationPeer::SA_VALUES_IN);
$criteria->addSelectColumn(SubApplicationPeer::SA_INIT_DATE);
$criteria->addSelectColumn(SubApplicationPeer::SA_FINISH_DATE);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = SubApplicationPeer::retrieveByPK($appUid, $appParent, $delIndexParent, $delThreadParent);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table SubApplication ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $dbsUid, $proUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($dbsUid = null, $proUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(DbSourcePeer::DBS_UID);
$criteria->addSelectColumn(DbSourcePeer::PRO_UID);
$criteria->addSelectColumn(DbSourcePeer::DBS_TYPE);
$criteria->addSelectColumn(DbSourcePeer::DBS_SERVER);
$criteria->addSelectColumn(DbSourcePeer::DBS_DATABASE_NAME);
$criteria->addSelectColumn(DbSourcePeer::DBS_USERNAME);
$criteria->addSelectColumn(DbSourcePeer::DBS_PASSWORD);
$criteria->addSelectColumn(DbSourcePeer::DBS_PORT);
$criteria->addSelectColumn(DbSourcePeer::DBS_ENCODE);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = DbSourcePeer::retrieveByPK($dbsUid, $proUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table DbSource ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $timeId Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($timeId = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(DimTimeCompletePeer::TIME_ID);
$criteria->addSelectColumn(DimTimeCompletePeer::MONTH_ID);
$criteria->addSelectColumn(DimTimeCompletePeer::QTR_ID);
$criteria->addSelectColumn(DimTimeCompletePeer::YEAR_ID);
$criteria->addSelectColumn(DimTimeCompletePeer::MONTH_NAME);
$criteria->addSelectColumn(DimTimeCompletePeer::MONTH_DESC);
$criteria->addSelectColumn(DimTimeCompletePeer::QTR_NAME);
$criteria->addSelectColumn(DimTimeCompletePeer::QTR_DESC);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = DimTimeCompletePeer::retrieveByPK($timeId);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table DimTimeComplete ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $dasUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($dasUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(DashletPeer::DAS_UID);
$criteria->addSelectColumn(DashletPeer::DAS_CLASS);
$criteria->addSelectColumn(DashletPeer::DAS_TITLE);
$criteria->addSelectColumn(DashletPeer::DAS_DESCRIPTION);
$criteria->addSelectColumn(DashletPeer::DAS_VERSION);
$criteria->addSelectColumn(DashletPeer::DAS_CREATE_DATE);
$criteria->addSelectColumn(DashletPeer::DAS_UPDATE_DATE);
$criteria->addSelectColumn(DashletPeer::DAS_STATUS);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = DashletPeer::retrieveByPK($dasUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table Dashlet ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $fcdUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($fcdUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(FieldConditionPeer::FCD_UID);
$criteria->addSelectColumn(FieldConditionPeer::FCD_FUNCTION);
$criteria->addSelectColumn(FieldConditionPeer::FCD_FIELDS);
$criteria->addSelectColumn(FieldConditionPeer::FCD_CONDITION);
$criteria->addSelectColumn(FieldConditionPeer::FCD_EVENTS);
$criteria->addSelectColumn(FieldConditionPeer::FCD_EVENT_OWNERS);
$criteria->addSelectColumn(FieldConditionPeer::FCD_STATUS);
$criteria->addSelectColumn(FieldConditionPeer::FCD_DYN_UID);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = FieldConditionPeer::retrieveByPK($fcdUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table FieldCondition ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $swiUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($swiUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(SwimlanesElementsPeer::SWI_UID);
$criteria->addSelectColumn(SwimlanesElementsPeer::PRO_UID);
$criteria->addSelectColumn(SwimlanesElementsPeer::SWI_TYPE);
$criteria->addSelectColumn(SwimlanesElementsPeer::SWI_X);
$criteria->addSelectColumn(SwimlanesElementsPeer::SWI_Y);
$criteria->addSelectColumn(SwimlanesElementsPeer::SWI_WIDTH);
$criteria->addSelectColumn(SwimlanesElementsPeer::SWI_HEIGHT);
$criteria->addSelectColumn(SwimlanesElementsPeer::SWI_NEXT_UID);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = SwimlanesElementsPeer::retrieveByPK($swiUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table SwimlanesElements ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $inpDocUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($inpDocUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(InputDocumentPeer::INP_DOC_UID);
$criteria->addSelectColumn(InputDocumentPeer::PRO_UID);
$criteria->addSelectColumn(InputDocumentPeer::INP_DOC_FORM_NEEDED);
$criteria->addSelectColumn(InputDocumentPeer::INP_DOC_ORIGINAL);
$criteria->addSelectColumn(InputDocumentPeer::INP_DOC_PUBLISHED);
$criteria->addSelectColumn(InputDocumentPeer::INP_DOC_VERSIONING);
$criteria->addSelectColumn(InputDocumentPeer::INP_DOC_DESTINATION_PATH);
$criteria->addSelectColumn(InputDocumentPeer::INP_DOC_TAGS);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = InputDocumentPeer::retrieveByPK($inpDocUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table InputDocument ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $lanId Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($lanId = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(LanguagePeer::LAN_ID);
$criteria->addSelectColumn(LanguagePeer::LAN_NAME);
$criteria->addSelectColumn(LanguagePeer::LAN_NATIVE_NAME);
$criteria->addSelectColumn(LanguagePeer::LAN_DIRECTION);
$criteria->addSelectColumn(LanguagePeer::LAN_WEIGHT);
$criteria->addSelectColumn(LanguagePeer::LAN_ENABLED);
$criteria->addSelectColumn(LanguagePeer::LAN_CALENDAR);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = LanguagePeer::retrieveByPK($lanId);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table Language ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $stepUid, $tasUid, $triUid, $stType Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($stepUid = null, $tasUid = null, $triUid = null, $stType = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(StepTriggerPeer::STEP_UID);
$criteria->addSelectColumn(StepTriggerPeer::TAS_UID);
$criteria->addSelectColumn(StepTriggerPeer::TRI_UID);
$criteria->addSelectColumn(StepTriggerPeer::ST_TYPE);
$criteria->addSelectColumn(StepTriggerPeer::ST_CONDITION);
$criteria->addSelectColumn(StepTriggerPeer::ST_POSITION);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = StepTriggerPeer::retrieveByPK($stepUid, $tasUid, $triUid, $stType);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table StepTrigger ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $cfgUid, $objUid, $proUid, $usrUid, $appUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($cfgUid = null, $objUid = null, $proUid = null, $usrUid = null, $appUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(ConfigurationPeer::CFG_UID);
$criteria->addSelectColumn(ConfigurationPeer::OBJ_UID);
$criteria->addSelectColumn(ConfigurationPeer::CFG_VALUE);
$criteria->addSelectColumn(ConfigurationPeer::PRO_UID);
$criteria->addSelectColumn(ConfigurationPeer::USR_UID);
$criteria->addSelectColumn(ConfigurationPeer::APP_UID);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = ConfigurationPeer::retrieveByPK($cfgUid, $objUid, $proUid, $usrUid, $appUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table Configuration ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $trnCategory, $trnId, $trnLang Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($trnCategory = null, $trnId = null, $trnLang = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(TranslationPeer::TRN_CATEGORY);
$criteria->addSelectColumn(TranslationPeer::TRN_ID);
$criteria->addSelectColumn(TranslationPeer::TRN_LANG);
$criteria->addSelectColumn(TranslationPeer::TRN_VALUE);
$criteria->addSelectColumn(TranslationPeer::TRN_UPDATE_DATE);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = TranslationPeer::retrieveByPK($trnCategory, $trnId, $trnLang);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table Translation ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $calendarUid, $calendarHolidayName Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($calendarUid = null, $calendarHolidayName = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(CalendarHolidaysPeer::CALENDAR_UID);
$criteria->addSelectColumn(CalendarHolidaysPeer::CALENDAR_HOLIDAY_NAME);
$criteria->addSelectColumn(CalendarHolidaysPeer::CALENDAR_HOLIDAY_START);
$criteria->addSelectColumn(CalendarHolidaysPeer::CALENDAR_HOLIDAY_END);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = CalendarHolidaysPeer::retrieveByPK($calendarUid, $calendarHolidayName);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table CalendarHolidays ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $usrUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($usrUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(UsersPropertiesPeer::USR_UID);
$criteria->addSelectColumn(UsersPropertiesPeer::USR_LAST_UPDATE_DATE);
$criteria->addSelectColumn(UsersPropertiesPeer::USR_LOGGED_NEXT_TIME);
$criteria->addSelectColumn(UsersPropertiesPeer::USR_PASSWORD_HISTORY);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = UsersPropertiesPeer::retrieveByPK($usrUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table UsersProperties ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $lexTopic, $lexKey Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($lexTopic = null, $lexKey = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(LexicoPeer::LEX_TOPIC);
$criteria->addSelectColumn(LexicoPeer::LEX_KEY);
$criteria->addSelectColumn(LexicoPeer::LEX_VALUE);
$criteria->addSelectColumn(LexicoPeer::LEX_CAPTION);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = LexicoPeer::retrieveByPK($lexTopic, $lexKey);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table Lexico ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $tasUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($tasUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(TaskPeer::PRO_UID);
$criteria->addSelectColumn(TaskPeer::TAS_UID);
$criteria->addSelectColumn(TaskPeer::TAS_TYPE);
$criteria->addSelectColumn(TaskPeer::TAS_DURATION);
$criteria->addSelectColumn(TaskPeer::TAS_DELAY_TYPE);
$criteria->addSelectColumn(TaskPeer::TAS_TEMPORIZER);
$criteria->addSelectColumn(TaskPeer::TAS_TYPE_DAY);
$criteria->addSelectColumn(TaskPeer::TAS_TIMEUNIT);
$criteria->addSelectColumn(TaskPeer::TAS_ALERT);
$criteria->addSelectColumn(TaskPeer::TAS_PRIORITY_VARIABLE);
$criteria->addSelectColumn(TaskPeer::TAS_ASSIGN_TYPE);
$criteria->addSelectColumn(TaskPeer::TAS_ASSIGN_VARIABLE);
$criteria->addSelectColumn(TaskPeer::TAS_GROUP_VARIABLE);
$criteria->addSelectColumn(TaskPeer::TAS_MI_INSTANCE_VARIABLE);
$criteria->addSelectColumn(TaskPeer::TAS_MI_COMPLETE_VARIABLE);
$criteria->addSelectColumn(TaskPeer::TAS_ASSIGN_LOCATION);
$criteria->addSelectColumn(TaskPeer::TAS_ASSIGN_LOCATION_ADHOC);
$criteria->addSelectColumn(TaskPeer::TAS_TRANSFER_FLY);
$criteria->addSelectColumn(TaskPeer::TAS_LAST_ASSIGNED);
$criteria->addSelectColumn(TaskPeer::TAS_USER);
$criteria->addSelectColumn(TaskPeer::TAS_CAN_UPLOAD);
$criteria->addSelectColumn(TaskPeer::TAS_VIEW_UPLOAD);
$criteria->addSelectColumn(TaskPeer::TAS_VIEW_ADDITIONAL_DOCUMENTATION);
$criteria->addSelectColumn(TaskPeer::TAS_CAN_CANCEL);
$criteria->addSelectColumn(TaskPeer::TAS_OWNER_APP);
$criteria->addSelectColumn(TaskPeer::STG_UID);
$criteria->addSelectColumn(TaskPeer::TAS_CAN_PAUSE);
$criteria->addSelectColumn(TaskPeer::TAS_CAN_SEND_MESSAGE);
$criteria->addSelectColumn(TaskPeer::TAS_CAN_DELETE_DOCS);
$criteria->addSelectColumn(TaskPeer::TAS_SELF_SERVICE);
$criteria->addSelectColumn(TaskPeer::TAS_START);
$criteria->addSelectColumn(TaskPeer::TAS_TO_LAST_USER);
$criteria->addSelectColumn(TaskPeer::TAS_SEND_LAST_EMAIL);
$criteria->addSelectColumn(TaskPeer::TAS_DERIVATION);
$criteria->addSelectColumn(TaskPeer::TAS_POSX);
$criteria->addSelectColumn(TaskPeer::TAS_POSY);
$criteria->addSelectColumn(TaskPeer::TAS_WIDTH);
$criteria->addSelectColumn(TaskPeer::TAS_HEIGHT);
$criteria->addSelectColumn(TaskPeer::TAS_COLOR);
$criteria->addSelectColumn(TaskPeer::TAS_EVN_UID);
$criteria->addSelectColumn(TaskPeer::TAS_BOUNDARY);
$criteria->addSelectColumn(TaskPeer::TAS_DERIVATION_SCREEN_TPL);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = TaskPeer::retrieveByPK($tasUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table Task ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
public function removeCase($sAppUid)
{
try {
$this->getExecuteTriggerProcess($sAppUid, 'DELETED');
$oAppDelegation = new AppDelegation();
$oAppDocument = new AppDocument();
//Delete the delegations of a application
$oCriteria2 = new Criteria('workflow');
$oCriteria2->add(AppDelegationPeer::APP_UID, $sAppUid);
$oDataset2 = AppDelegationPeer::doSelectRS($oCriteria2);
$oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset2->next();
while ($aRow2 = $oDataset2->getRow()) {
$oAppDelegation->remove($sAppUid, $aRow2['DEL_INDEX']);
$oDataset2->next();
}
//Delete the documents assigned to a application
$oCriteria2 = new Criteria('workflow');
$oCriteria2->add(AppDocumentPeer::APP_UID, $sAppUid);
$oDataset2 = AppDocumentPeer::doSelectRS($oCriteria2);
$oDataset2->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$oDataset2->next();
while ($aRow2 = $oDataset2->getRow()) {
$oAppDocument->remove($aRow2['APP_DOC_UID'], $aRow2['DOC_VERSION']);
$oDataset2->next();
}
//Delete the actions from a application
$oCriteria2 = new Criteria('workflow');
$oCriteria2->add(AppDelayPeer::APP_UID, $sAppUid);
AppDelayPeer::doDelete($oCriteria2);
//Delete the messages from a application
$oCriteria2 = new Criteria('workflow');
$oCriteria2->add(AppMessagePeer::APP_UID, $sAppUid);
AppMessagePeer::doDelete($oCriteria2);
//Delete the threads from a application
$oCriteria2 = new Criteria('workflow');
$oCriteria2->add(AppThreadPeer::APP_UID, $sAppUid);
AppThreadPeer::doDelete($oCriteria2);
//Delete the events from a application
$criteria = new Criteria("workflow");
$criteria->add(AppEventPeer::APP_UID, $sAppUid);
AppEventPeer::doDelete($criteria);
//Delete the histories from a application
$criteria = new Criteria("workflow");
$criteria->add(AppHistoryPeer::APP_UID, $sAppUid);
AppHistoryPeer::doDelete($criteria);
//Delete the notes from a application
$criteria = new Criteria("workflow");
$criteria->add(AppNotesPeer::APP_UID, $sAppUid);
AppNotesPeer::doDelete($criteria);
//Delete the owners from a application
$criteria = new Criteria("workflow");
$criteria->add(AppOwnerPeer::APP_UID, $sAppUid);
AppOwnerPeer::doDelete($criteria);
//Delete the SolrQueue from a application
$criteria = new Criteria("workflow");
$criteria->add(AppSolrQueuePeer::APP_UID, $sAppUid);
AppSolrQueuePeer::doDelete($criteria);
//Before delete verify if is a child case
$oCriteria2 = new Criteria('workflow');
$oCriteria2->add(SubApplicationPeer::APP_UID, $sAppUid);
$oCriteria2->add(SubApplicationPeer::SA_STATUS, 'ACTIVE');
if (SubApplicationPeer::doCount($oCriteria2) > 0) {
G::LoadClass('derivation');
$oDerivation = new Derivation();
$oDerivation->verifyIsCaseChild($sAppUid);
}
//Delete the registries in the table SUB_APPLICATION
$oCriteria2 = new Criteria('workflow');
$oCriteria2->add(SubApplicationPeer::APP_UID, $sAppUid);
SubApplicationPeer::doDelete($oCriteria2);
$oCriteria2 = new Criteria('workflow');
$oCriteria2->add(SubApplicationPeer::APP_PARENT, $sAppUid);
SubApplicationPeer::doDelete($oCriteria2);
//Delete records of the table APP_ASSIGN_SELF_SERVICE_VALUE
$appAssignSelfServiceValue = new AppAssignSelfServiceValue();
$appAssignSelfServiceValue->remove($sAppUid);
//Delete records of the Report Table
$this->reportTableDeleteRecord($sAppUid);
//Delete record of the APPLICATION table (trigger: delete records of the APP_CACHE_VIEW table)
$application = new Application();
$result = $application->remove($sAppUid);
//delete application from index
if ($this->appSolr != null) {
$this->appSolr->deleteApplicationSearchIndex($sAppUid);
}
/*----------------------------------********---------------------------------*/
return $result;
} catch (exception $e) {
throw ($e);
}
}
function getAppEvents($APP_UID, $DEL_INDEX)
{
//for single task event
$oCriteria = new Criteria('workflow');
$oCriteria->addSelectColumn(AppEventPeer::APP_UID);
$oCriteria->addSelectColumn(AppEventPeer::DEL_INDEX);
$oCriteria->addSelectColumn(AppEventPeer::EVN_UID);
$oCriteria->addSelectColumn(AppEventPeer::APP_EVN_ACTION_DATE);
$oCriteria->addSelectColumn(AppEventPeer::APP_EVN_ATTEMPTS);
$oCriteria->addSelectColumn(AppEventPeer::APP_EVN_LAST_EXECUTION_DATE);
$oCriteria->addSelectColumn(AppEventPeer::APP_EVN_STATUS);
$oCriteria->addSelectColumn(EventPeer::EVN_UID);
$oCriteria->addSelectColumn(EventPeer::PRO_UID);
$oCriteria->addSelectColumn(EventPeer::EVN_STATUS);
$oCriteria->addSelectColumn(EventPeer::EVN_WHEN_OCCURS);
$oCriteria->addSelectColumn(EventPeer::EVN_RELATED_TO);
$oCriteria->addSelectColumn(EventPeer::TAS_UID);
$oCriteria->addSelectColumn(EventPeer::EVN_TAS_UID_FROM);
$oCriteria->addSelectColumn(EventPeer::EVN_TAS_UID_TO);
$oCriteria->addSelectColumn(EventPeer::EVN_TAS_ESTIMATED_DURATION);
$oCriteria->addSelectColumn(EventPeer::EVN_WHEN);
$oCriteria->addSelectColumn(EventPeer::EVN_MAX_ATTEMPTS);
$oCriteria->addSelectColumn(EventPeer::EVN_ACTION);
$oCriteria->addSelectColumn(EventPeer::EVN_CONDITIONS);
$oCriteria->addSelectColumn(EventPeer::EVN_ACTION_PARAMETERS);
$oCriteria->addSelectColumn(EventPeer::TRI_UID);
$oCriteria->addJoin(AppEventPeer::EVN_UID, EventPeer::EVN_UID);
$oCriteria->add(AppEventPeer::APP_UID, $APP_UID);
$oCriteria->add(AppEventPeer::DEL_INDEX, $DEL_INDEX);
$oCriteria->add(AppEventPeer::APP_EVN_STATUS, 'OPEN');
$oDataset = AppEventPeer::doSelectRs($oCriteria);
$oDataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
$aRows = array();
while ($oDataset->next()) {
$aRows[] = $oDataset->getRow();
}
return count($aRows) > 0 ? $aRows : false;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $proUid Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($proUid = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(ProcessPeer::PRO_UID);
$criteria->addSelectColumn(ProcessPeer::PRO_PARENT);
$criteria->addSelectColumn(ProcessPeer::PRO_TIME);
$criteria->addSelectColumn(ProcessPeer::PRO_TIMEUNIT);
$criteria->addSelectColumn(ProcessPeer::PRO_STATUS);
$criteria->addSelectColumn(ProcessPeer::PRO_TYPE_DAY);
$criteria->addSelectColumn(ProcessPeer::PRO_TYPE);
$criteria->addSelectColumn(ProcessPeer::PRO_ASSIGNMENT);
$criteria->addSelectColumn(ProcessPeer::PRO_SHOW_MAP);
$criteria->addSelectColumn(ProcessPeer::PRO_SHOW_MESSAGE);
$criteria->addSelectColumn(ProcessPeer::PRO_SUBPROCESS);
$criteria->addSelectColumn(ProcessPeer::PRO_TRI_DELETED);
$criteria->addSelectColumn(ProcessPeer::PRO_TRI_CANCELED);
$criteria->addSelectColumn(ProcessPeer::PRO_TRI_PAUSED);
$criteria->addSelectColumn(ProcessPeer::PRO_TRI_REASSIGNED);
$criteria->addSelectColumn(ProcessPeer::PRO_SHOW_DELEGATE);
$criteria->addSelectColumn(ProcessPeer::PRO_SHOW_DYNAFORM);
$criteria->addSelectColumn(ProcessPeer::PRO_CATEGORY);
$criteria->addSelectColumn(ProcessPeer::PRO_SUB_CATEGORY);
$criteria->addSelectColumn(ProcessPeer::PRO_INDUSTRY);
$criteria->addSelectColumn(ProcessPeer::PRO_UPDATE_DATE);
$criteria->addSelectColumn(ProcessPeer::PRO_CREATE_DATE);
$criteria->addSelectColumn(ProcessPeer::PRO_CREATE_USER);
$criteria->addSelectColumn(ProcessPeer::PRO_HEIGHT);
$criteria->addSelectColumn(ProcessPeer::PRO_WIDTH);
$criteria->addSelectColumn(ProcessPeer::PRO_TITLE_X);
$criteria->addSelectColumn(ProcessPeer::PRO_TITLE_Y);
$criteria->addSelectColumn(ProcessPeer::PRO_DEBUG);
$criteria->addSelectColumn(ProcessPeer::PRO_DYNAFORMS);
$criteria->addSelectColumn(ProcessPeer::PRO_DERIVATION_SCREEN_TPL);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = ProcessPeer::retrieveByPK($proUid);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table Process ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
/**
* Implementation for 'GET' method for Rest API
*
* @param mixed $appUid, $delIndex Primary key
*
* @return array $result Returns array within multiple records or a single record depending if
* a single selection was requested passing id(s) as param
*/
protected function get($appUid = null, $delIndex = null)
{
$result = array();
try {
$noArguments = true;
$argumentList = func_get_args();
foreach ($argumentList as $arg) {
if (!is_null($arg)) {
$noArguments = false;
}
}
if ($noArguments) {
$criteria = new Criteria('workflow');
$criteria->addSelectColumn(AppDelegationPeer::APP_UID);
$criteria->addSelectColumn(AppDelegationPeer::DEL_INDEX);
$criteria->addSelectColumn(AppDelegationPeer::DEL_PREVIOUS);
$criteria->addSelectColumn(AppDelegationPeer::PRO_UID);
$criteria->addSelectColumn(AppDelegationPeer::TAS_UID);
$criteria->addSelectColumn(AppDelegationPeer::USR_UID);
$criteria->addSelectColumn(AppDelegationPeer::DEL_TYPE);
$criteria->addSelectColumn(AppDelegationPeer::DEL_THREAD);
$criteria->addSelectColumn(AppDelegationPeer::DEL_THREAD_STATUS);
$criteria->addSelectColumn(AppDelegationPeer::DEL_PRIORITY);
$criteria->addSelectColumn(AppDelegationPeer::DEL_DELEGATE_DATE);
$criteria->addSelectColumn(AppDelegationPeer::DEL_INIT_DATE);
$criteria->addSelectColumn(AppDelegationPeer::DEL_TASK_DUE_DATE);
$criteria->addSelectColumn(AppDelegationPeer::DEL_FINISH_DATE);
$criteria->addSelectColumn(AppDelegationPeer::DEL_DURATION);
$criteria->addSelectColumn(AppDelegationPeer::DEL_QUEUE_DURATION);
$criteria->addSelectColumn(AppDelegationPeer::DEL_DELAY_DURATION);
$criteria->addSelectColumn(AppDelegationPeer::DEL_STARTED);
$criteria->addSelectColumn(AppDelegationPeer::DEL_FINISHED);
$criteria->addSelectColumn(AppDelegationPeer::DEL_DELAYED);
$criteria->addSelectColumn(AppDelegationPeer::DEL_DATA);
$criteria->addSelectColumn(AppDelegationPeer::APP_OVERDUE_PERCENTAGE);
$dataset = AppEventPeer::doSelectRS($criteria);
$dataset->setFetchmode(ResultSet::FETCHMODE_ASSOC);
while ($dataset->next()) {
$result[] = $dataset->getRow();
}
} else {
$record = AppDelegationPeer::retrieveByPK($appUid, $delIndex);
if ($record) {
$result = $record->toArray(BasePeer::TYPE_FIELDNAME);
} else {
$paramValues = "";
foreach ($argumentList as $arg) {
$paramValues .= strlen($paramValues) ? ', ' : '';
if (!is_null($arg)) {
$paramValues .= "{$arg}";
} else {
$paramValues .= "NULL";
}
}
throw new RestException(417, "table AppDelegation ({$paramValues})");
}
}
} catch (RestException $e) {
throw new RestException($e->getCode(), $e->getMessage());
} catch (Exception $e) {
throw new RestException(412, $e->getMessage());
}
return $result;
}
