initial commit from rev. 632

workflow/engine/classes/model/map/AdditionalTablesMapBuilder.php

@@ -0,0 +1,93 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'ADDITIONAL_TABLES' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AdditionalTablesMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AdditionalTablesMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('ADDITIONAL_TABLES');
+		$tMap->setPhpName('AdditionalTables');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('ADD_TAB_UID', 'AddTabUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('ADD_TAB_NAME', 'AddTabName', 'string', CreoleTypes::VARCHAR, true, 60);
+
+		$tMap->addColumn('ADD_TAB_CLASS_NAME', 'AddTabClassName', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('ADD_TAB_DESCRIPTION', 'AddTabDescription', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('ADD_TAB_SDW_LOG_INSERT', 'AddTabSdwLogInsert', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('ADD_TAB_SDW_LOG_UPDATE', 'AddTabSdwLogUpdate', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('ADD_TAB_SDW_LOG_DELETE', 'AddTabSdwLogDelete', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('ADD_TAB_SDW_LOG_SELECT', 'AddTabSdwLogSelect', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('ADD_TAB_SDW_MAX_LENGTH', 'AddTabSdwMaxLength', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('ADD_TAB_SDW_AUTO_DELETE', 'AddTabSdwAutoDelete', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('ADD_TAB_PLG_UID', 'AddTabPlgUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DBS_UID', 'DbsUid', 'string', CreoleTypes::VARCHAR, false, 32);
+
+	} // doBuild()
+
+} // AdditionalTablesMapBuilder

workflow/engine/classes/model/map/AppCacheViewMapBuilder.php

@@ -0,0 +1,129 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APP_CACHE_VIEW' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AppCacheViewMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AppCacheViewMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APP_CACHE_VIEW');
+		$tMap->setPhpName('AppCacheView');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('DEL_INDEX', 'DelIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('APP_NUMBER', 'AppNumber', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('APP_STATUS', 'AppStatus', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PREVIOUS_USR_UID', 'PreviousUsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEL_DELEGATE_DATE', 'DelDelegateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('DEL_INIT_DATE', 'DelInitDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('DEL_TASK_DUE_DATE', 'DelTaskDueDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('DEL_FINISH_DATE', 'DelFinishDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('DEL_THREAD_STATUS', 'DelThreadStatus', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_THREAD_STATUS', 'AppThreadStatus', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_TITLE', 'AppTitle', 'string', CreoleTypes::VARCHAR, true, 255);
+
+		$tMap->addColumn('APP_PRO_TITLE', 'AppProTitle', 'string', CreoleTypes::VARCHAR, true, 255);
+
+		$tMap->addColumn('APP_TAS_TITLE', 'AppTasTitle', 'string', CreoleTypes::VARCHAR, true, 255);
+
+		$tMap->addColumn('APP_CURRENT_USER', 'AppCurrentUser', 'string', CreoleTypes::VARCHAR, true, 128);
+
+		$tMap->addColumn('APP_DEL_PREVIOUS_USER', 'AppDelPreviousUser', 'string', CreoleTypes::VARCHAR, true, 128);
+
+		$tMap->addColumn('DEL_PRIORITY', 'DelPriority', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEL_DURATION', 'DelDuration', 'double', CreoleTypes::DOUBLE, false, null);
+
+		$tMap->addColumn('DEL_QUEUE_DURATION', 'DelQueueDuration', 'double', CreoleTypes::DOUBLE, false, null);
+
+		$tMap->addColumn('DEL_DELAY_DURATION', 'DelDelayDuration', 'double', CreoleTypes::DOUBLE, false, null);
+
+		$tMap->addColumn('DEL_STARTED', 'DelStarted', 'int', CreoleTypes::TINYINT, false, null);
+
+		$tMap->addColumn('DEL_FINISHED', 'DelFinished', 'int', CreoleTypes::TINYINT, false, null);
+
+		$tMap->addColumn('DEL_DELAYED', 'DelDelayed', 'int', CreoleTypes::TINYINT, false, null);
+
+		$tMap->addColumn('APP_CREATE_DATE', 'AppCreateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('APP_FINISH_DATE', 'AppFinishDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('APP_UPDATE_DATE', 'AppUpdateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('APP_OVERDUE_PERCENTAGE', 'AppOverduePercentage', 'double', CreoleTypes::DOUBLE, true, null);
+
+	} // doBuild()
+
+} // AppCacheViewMapBuilder

workflow/engine/classes/model/map/AppDelayMapBuilder.php

@@ -0,0 +1,97 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APP_DELAY' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AppDelayMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AppDelayMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APP_DELAY');
+		$tMap->setPhpName('AppDelay');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('APP_DELAY_UID', 'AppDelayUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_THREAD_INDEX', 'AppThreadIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('APP_DEL_INDEX', 'AppDelIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('APP_TYPE', 'AppType', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('APP_STATUS', 'AppStatus', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('APP_NEXT_TASK', 'AppNextTask', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('APP_DELEGATION_USER', 'AppDelegationUser', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('APP_ENABLE_ACTION_USER', 'AppEnableActionUser', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_ENABLE_ACTION_DATE', 'AppEnableActionDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('APP_DISABLE_ACTION_USER', 'AppDisableActionUser', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('APP_DISABLE_ACTION_DATE', 'AppDisableActionDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('APP_AUTOMATIC_DISABLED_DATE', 'AppAutomaticDisabledDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+	} // doBuild()
+
+} // AppDelayMapBuilder

workflow/engine/classes/model/map/AppDelegationMapBuilder.php

@@ -0,0 +1,119 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APP_DELEGATION' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AppDelegationMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AppDelegationMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APP_DELEGATION');
+		$tMap->setPhpName('AppDelegation');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('DEL_INDEX', 'DelIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('DEL_PREVIOUS', 'DelPrevious', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEL_TYPE', 'DelType', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEL_THREAD', 'DelThread', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('DEL_THREAD_STATUS', 'DelThreadStatus', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEL_PRIORITY', 'DelPriority', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEL_DELEGATE_DATE', 'DelDelegateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('DEL_INIT_DATE', 'DelInitDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('DEL_TASK_DUE_DATE', 'DelTaskDueDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('DEL_FINISH_DATE', 'DelFinishDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('DEL_DURATION', 'DelDuration', 'double', CreoleTypes::DOUBLE, false, null);
+
+		$tMap->addColumn('DEL_QUEUE_DURATION', 'DelQueueDuration', 'double', CreoleTypes::DOUBLE, false, null);
+
+		$tMap->addColumn('DEL_DELAY_DURATION', 'DelDelayDuration', 'double', CreoleTypes::DOUBLE, false, null);
+
+		$tMap->addColumn('DEL_STARTED', 'DelStarted', 'int', CreoleTypes::TINYINT, false, null);
+
+		$tMap->addColumn('DEL_FINISHED', 'DelFinished', 'int', CreoleTypes::TINYINT, false, null);
+
+		$tMap->addColumn('DEL_DELAYED', 'DelDelayed', 'int', CreoleTypes::TINYINT, false, null);
+
+		$tMap->addColumn('DEL_DATA', 'DelData', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('APP_OVERDUE_PERCENTAGE', 'AppOverduePercentage', 'double', CreoleTypes::DOUBLE, true, null);
+
+		$tMap->addValidator('DEL_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'NORMAL|PARALLEL', 'Please select a valid status.');
+
+		$tMap->addValidator('DEL_PRIORITY', 'validValues', 'propel.validator.ValidValuesValidator', '1|2|3|4|5', 'Please select a valid Priority.');
+
+		$tMap->addValidator('DEL_THREAD_STATUS', 'validValues', 'propel.validator.ValidValuesValidator', 'CLOSED|OPEN|PAUSED', 'Please select a valid status.');
+
+	} // doBuild()
+
+} // AppDelegationMapBuilder

workflow/engine/classes/model/map/AppDocumentMapBuilder.php

@@ -0,0 +1,127 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APP_DOCUMENT' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AppDocumentMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AppDocumentMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APP_DOCUMENT');
+		$tMap->setPhpName('AppDocument');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('APP_DOC_UID', 'AppDocUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('DOC_VERSION', 'DocVersion', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEL_INDEX', 'DelIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('DOC_UID', 'DocUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_DOC_TYPE', 'AppDocType', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_DOC_CREATE_DATE', 'AppDocCreateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('APP_DOC_INDEX', 'AppDocIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('FOLDER_UID', 'FolderUid', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('APP_DOC_PLUGIN', 'AppDocPlugin', 'string', CreoleTypes::VARCHAR, false, 150);
+
+		$tMap->addColumn('APP_DOC_TAGS', 'AppDocTags', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('APP_DOC_STATUS', 'AppDocStatus', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_DOC_STATUS_DATE', 'AppDocStatusDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addValidator('APP_DOC_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Application Document UID can be no larger than 32 in size');
+
+		$tMap->addValidator('APP_DOC_UID', 'required', 'propel.validator.RequiredValidator', '', 'Application Document UID is required.');
+
+		$tMap->addValidator('APP_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Application UID can be no larger than 32 in size');
+
+		$tMap->addValidator('APP_UID', 'required', 'propel.validator.RequiredValidator', '', 'Application UID is required.');
+
+		$tMap->addValidator('DEL_INDEX', 'minValue', 'propel.validator.MinValueValidator', '1', 'Delegation Index can be major than 0');
+
+		$tMap->addValidator('DEL_INDEX', 'required', 'propel.validator.RequiredValidator', '', 'Delegation Index is required.');
+
+		$tMap->addValidator('DOC_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Document UID can be no larger than 32 in size');
+
+		$tMap->addValidator('DOC_UID', 'required', 'propel.validator.RequiredValidator', '', 'Document UID (building block) is required.');
+
+		$tMap->addValidator('USR_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'User UID can be no larger than 32 in size');
+
+		$tMap->addValidator('USR_UID', 'required', 'propel.validator.RequiredValidator', '', 'User UID is required.');
+
+		$tMap->addValidator('APP_DOC_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'INPUT|OUTPUT|ATTACHED', 'Please select a valid document type.');
+
+		$tMap->addValidator('APP_DOC_TYPE', 'required', 'propel.validator.RequiredValidator', '', 'Application Document Type is required.');
+
+		$tMap->addValidator('APP_DOC_CREATE_DATE', 'required', 'propel.validator.RequiredValidator', '', 'Application Document Creation Date is required.');
+
+		$tMap->addValidator('APP_DOC_STATUS', 'validValues', 'propel.validator.ValidValuesValidator', 'ACTIVE|DELETED', 'Please select a valid document status (ACTIVE|DELETED).');
+
+		$tMap->addValidator('APP_DOC_STATUS', 'required', 'propel.validator.RequiredValidator', '', 'Application Document Status is required.');
+
+	} // doBuild()
+
+} // AppDocumentMapBuilder

workflow/engine/classes/model/map/AppEventMapBuilder.php

@@ -0,0 +1,83 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APP_EVENT' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AppEventMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AppEventMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APP_EVENT');
+		$tMap->setPhpName('AppEvent');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('DEL_INDEX', 'DelIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addPrimaryKey('EVN_UID', 'EvnUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_EVN_ACTION_DATE', 'AppEvnActionDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('APP_EVN_ATTEMPTS', 'AppEvnAttempts', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('APP_EVN_LAST_EXECUTION_DATE', 'AppEvnLastExecutionDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('APP_EVN_STATUS', 'AppEvnStatus', 'string', CreoleTypes::VARCHAR, true, 32);
+
+	} // doBuild()
+
+} // AppEventMapBuilder

workflow/engine/classes/model/map/AppFolderMapBuilder.php

@@ -0,0 +1,79 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APP_FOLDER' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AppFolderMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AppFolderMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APP_FOLDER');
+		$tMap->setPhpName('AppFolder');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('FOLDER_UID', 'FolderUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('FOLDER_PARENT_UID', 'FolderParentUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('FOLDER_NAME', 'FolderName', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('FOLDER_CREATE_DATE', 'FolderCreateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('FOLDER_UPDATE_DATE', 'FolderUpdateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+	} // doBuild()
+
+} // AppFolderMapBuilder

workflow/engine/classes/model/map/AppHistoryMapBuilder.php

@@ -0,0 +1,87 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APP_HISTORY' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AppHistoryMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AppHistoryMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APP_HISTORY');
+		$tMap->setPhpName('AppHistory');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addColumn('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEL_INDEX', 'DelIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DYN_UID', 'DynUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_STATUS', 'AppStatus', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('HISTORY_DATE', 'HistoryDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('HISTORY_DATA', 'HistoryData', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+	} // doBuild()
+
+} // AppHistoryMapBuilder

workflow/engine/classes/model/map/AppMessageMapBuilder.php

@@ -0,0 +1,101 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APP_MESSAGE' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AppMessageMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AppMessageMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APP_MESSAGE');
+		$tMap->setPhpName('AppMessage');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('APP_MSG_UID', 'AppMsgUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('MSG_UID', 'MsgUid', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEL_INDEX', 'DelIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('APP_MSG_TYPE', 'AppMsgType', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('APP_MSG_SUBJECT', 'AppMsgSubject', 'string', CreoleTypes::VARCHAR, true, 150);
+
+		$tMap->addColumn('APP_MSG_FROM', 'AppMsgFrom', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('APP_MSG_TO', 'AppMsgTo', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('APP_MSG_BODY', 'AppMsgBody', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('APP_MSG_DATE', 'AppMsgDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('APP_MSG_CC', 'AppMsgCc', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('APP_MSG_BCC', 'AppMsgBcc', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('APP_MSG_TEMPLATE', 'AppMsgTemplate', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('APP_MSG_STATUS', 'AppMsgStatus', 'string', CreoleTypes::VARCHAR, false, 20);
+
+		$tMap->addColumn('APP_MSG_ATTACH', 'AppMsgAttach', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('APP_MSG_SEND_DATE', 'AppMsgSendDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+	} // doBuild()
+
+} // AppMessageMapBuilder

workflow/engine/classes/model/map/AppOwnerMapBuilder.php

@@ -0,0 +1,75 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APP_OWNER' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AppOwnerMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AppOwnerMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APP_OWNER');
+		$tMap->setPhpName('AppOwner');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('OWN_UID', 'OwnUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+	} // doBuild()
+
+} // AppOwnerMapBuilder

workflow/engine/classes/model/map/AppSpoolMapBuilder.php

@@ -0,0 +1,79 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APP_SPOOL' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AppSpoolMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AppSpoolMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APP_SPOOL');
+		$tMap->setPhpName('AppSpool');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('ID', 'Id', 'int', CreoleTypes::SMALLINT, true, 6);
+
+		$tMap->addColumn('SENDER', 'Sender', 'string', CreoleTypes::VARCHAR, true, 96);
+
+		$tMap->addColumn('FILE', 'File', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('NOW', 'Now', 'string', CreoleTypes::VARCHAR, true, 16);
+
+		$tMap->addColumn('STATUS', 'Status', 'string', CreoleTypes::VARCHAR, true, 16);
+
+	} // doBuild()
+
+} // AppSpoolMapBuilder

workflow/engine/classes/model/map/AppThreadMapBuilder.php

@@ -0,0 +1,81 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APP_THREAD' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class AppThreadMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.AppThreadMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APP_THREAD');
+		$tMap->setPhpName('AppThread');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('APP_THREAD_INDEX', 'AppThreadIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('APP_THREAD_PARENT', 'AppThreadParent', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('APP_THREAD_STATUS', 'AppThreadStatus', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEL_INDEX', 'DelIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addValidator('APP_THREAD_STATUS', 'validValues', 'propel.validator.ValidValuesValidator', 'CLOSED|OPEN', 'Please select a valid status.');
+
+	} // doBuild()
+
+} // AppThreadMapBuilder

workflow/engine/classes/model/map/ApplicationMapBuilder.php

@@ -0,0 +1,103 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'APPLICATION' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class ApplicationMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.ApplicationMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('APPLICATION');
+		$tMap->setPhpName('Application');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_NUMBER', 'AppNumber', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('APP_PARENT', 'AppParent', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_STATUS', 'AppStatus', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_PROC_STATUS', 'AppProcStatus', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('APP_PROC_CODE', 'AppProcCode', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('APP_PARALLEL', 'AppParallel', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_INIT_USER', 'AppInitUser', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_CUR_USER', 'AppCurUser', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_CREATE_DATE', 'AppCreateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('APP_INIT_DATE', 'AppInitDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('APP_FINISH_DATE', 'AppFinishDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('APP_UPDATE_DATE', 'AppUpdateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('APP_DATA', 'AppData', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('APP_PIN', 'AppPin', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addValidator('APP_STATUS', 'validValues', 'propel.validator.ValidValuesValidator', 'DRAFT|TO_DO|PAUSED|COMPLETED|CANCELLED', 'Please select a valid status.');
+
+	} // doBuild()
+
+} // ApplicationMapBuilder

workflow/engine/classes/model/map/CalendarAssignmentsMapBuilder.php

@@ -0,0 +1,75 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'CALENDAR_ASSIGNMENTS' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class CalendarAssignmentsMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.CalendarAssignmentsMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('CALENDAR_ASSIGNMENTS');
+		$tMap->setPhpName('CalendarAssignments');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('OBJECT_UID', 'ObjectUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('CALENDAR_UID', 'CalendarUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('OBJECT_TYPE', 'ObjectType', 'string', CreoleTypes::VARCHAR, true, 100);
+
+	} // doBuild()
+
+} // CalendarAssignmentsMapBuilder

workflow/engine/classes/model/map/CalendarBusinessHoursMapBuilder.php

@@ -0,0 +1,79 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'CALENDAR_BUSINESS_HOURS' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class CalendarBusinessHoursMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.CalendarBusinessHoursMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('CALENDAR_BUSINESS_HOURS');
+		$tMap->setPhpName('CalendarBusinessHours');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('CALENDAR_UID', 'CalendarUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('CALENDAR_BUSINESS_DAY', 'CalendarBusinessDay', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addPrimaryKey('CALENDAR_BUSINESS_START', 'CalendarBusinessStart', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addPrimaryKey('CALENDAR_BUSINESS_END', 'CalendarBusinessEnd', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addValidator('CALENDAR_BUSINESS_DAY', 'validValues', 'propel.validator.ValidValuesValidator', '0|1|2|3|4|5|6|7', 'Please select a valid Day.');
+
+	} // doBuild()
+
+} // CalendarBusinessHoursMapBuilder

workflow/engine/classes/model/map/CalendarDefinitionMapBuilder.php

@@ -0,0 +1,85 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'CALENDAR_DEFINITION' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class CalendarDefinitionMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.CalendarDefinitionMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('CALENDAR_DEFINITION');
+		$tMap->setPhpName('CalendarDefinition');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('CALENDAR_UID', 'CalendarUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('CALENDAR_NAME', 'CalendarName', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('CALENDAR_CREATE_DATE', 'CalendarCreateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('CALENDAR_UPDATE_DATE', 'CalendarUpdateDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('CALENDAR_WORK_DAYS', 'CalendarWorkDays', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('CALENDAR_DESCRIPTION', 'CalendarDescription', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('CALENDAR_STATUS', 'CalendarStatus', 'string', CreoleTypes::VARCHAR, true, 8);
+
+		$tMap->addValidator('CALENDAR_STATUS', 'validValues', 'propel.validator.ValidValuesValidator', 'ACTIVE|INACTIVE|DELETED', 'Please select a valid Calendar Status.');
+
+	} // doBuild()
+
+} // CalendarDefinitionMapBuilder

workflow/engine/classes/model/map/CalendarHolidaysMapBuilder.php

@@ -0,0 +1,77 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'CALENDAR_HOLIDAYS' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class CalendarHolidaysMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.CalendarHolidaysMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('CALENDAR_HOLIDAYS');
+		$tMap->setPhpName('CalendarHolidays');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('CALENDAR_UID', 'CalendarUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('CALENDAR_HOLIDAY_NAME', 'CalendarHolidayName', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('CALENDAR_HOLIDAY_START', 'CalendarHolidayStart', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('CALENDAR_HOLIDAY_END', 'CalendarHolidayEnd', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+	} // doBuild()
+
+} // CalendarHolidaysMapBuilder

workflow/engine/classes/model/map/CaseSchedulerMapBuilder.php

@@ -0,0 +1,119 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'CASE_SCHEDULER' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class CaseSchedulerMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.CaseSchedulerMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('CASE_SCHEDULER');
+		$tMap->setPhpName('CaseScheduler');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('SCH_UID', 'SchUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SCH_DEL_USER_NAME', 'SchDelUserName', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('SCH_DEL_USER_PASS', 'SchDelUserPass', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('SCH_DEL_USER_UID', 'SchDelUserUid', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('SCH_NAME', 'SchName', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SCH_TIME_NEXT_RUN', 'SchTimeNextRun', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('SCH_LAST_RUN_TIME', 'SchLastRunTime', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('SCH_STATE', 'SchState', 'string', CreoleTypes::VARCHAR, true, 15);
+
+		$tMap->addColumn('SCH_LAST_STATE', 'SchLastState', 'string', CreoleTypes::VARCHAR, true, 60);
+
+		$tMap->addColumn('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SCH_OPTION', 'SchOption', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('SCH_START_TIME', 'SchStartTime', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('SCH_START_DATE', 'SchStartDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('SCH_DAYS_PERFORM_TASK', 'SchDaysPerformTask', 'string', CreoleTypes::CHAR, true, 5);
+
+		$tMap->addColumn('SCH_EVERY_DAYS', 'SchEveryDays', 'int', CreoleTypes::TINYINT, false, null);
+
+		$tMap->addColumn('SCH_WEEK_DAYS', 'SchWeekDays', 'string', CreoleTypes::CHAR, true, 14);
+
+		$tMap->addColumn('SCH_START_DAY', 'SchStartDay', 'string', CreoleTypes::CHAR, true, 6);
+
+		$tMap->addColumn('SCH_MONTHS', 'SchMonths', 'string', CreoleTypes::CHAR, true, 24);
+
+		$tMap->addColumn('SCH_END_DATE', 'SchEndDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('SCH_REPEAT_EVERY', 'SchRepeatEvery', 'string', CreoleTypes::VARCHAR, true, 15);
+
+		$tMap->addColumn('SCH_REPEAT_UNTIL', 'SchRepeatUntil', 'string', CreoleTypes::VARCHAR, true, 15);
+
+		$tMap->addColumn('SCH_REPEAT_STOP_IF_RUNNING', 'SchRepeatStopIfRunning', 'int', CreoleTypes::TINYINT, false, null);
+
+		$tMap->addColumn('CASE_SH_PLUGIN_UID', 'CaseShPluginUid', 'string', CreoleTypes::VARCHAR, false, 100);
+
+	} // doBuild()
+
+} // CaseSchedulerMapBuilder

workflow/engine/classes/model/map/CaseTrackerMapBuilder.php

@@ -0,0 +1,93 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'CASE_TRACKER' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class CaseTrackerMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.CaseTrackerMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('CASE_TRACKER');
+		$tMap->setPhpName('CaseTracker');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('CT_MAP_TYPE', 'CtMapType', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('CT_DERIVATION_HISTORY', 'CtDerivationHistory', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('CT_MESSAGE_HISTORY', 'CtMessageHistory', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addValidator('PRO_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Process UID can be no larger than 32 in size');
+
+		$tMap->addValidator('PRO_UID', 'required', 'propel.validator.RequiredValidator', '', 'Process UID is required.');
+
+		$tMap->addValidator('CT_MAP_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'NONE|PROCESSMAP|STAGES', 'Please select a valid map type.');
+
+		$tMap->addValidator('CT_MAP_TYPE', 'required', 'propel.validator.RequiredValidator', '', 'Map type is required.');
+
+		$tMap->addValidator('CT_DERIVATION_HISTORY', 'validValues', 'propel.validator.ValidValuesValidator', '0|1', 'Please select a valid derivation history status.');
+
+		$tMap->addValidator('CT_DERIVATION_HISTORY', 'required', 'propel.validator.RequiredValidator', '', 'Derivation history status is required.');
+
+		$tMap->addValidator('CT_MESSAGE_HISTORY', 'validValues', 'propel.validator.ValidValuesValidator', '0|1', 'Please select a valid message history status.');
+
+		$tMap->addValidator('CT_MESSAGE_HISTORY', 'required', 'propel.validator.RequiredValidator', '', 'Message history status is required.');
+
+	} // doBuild()
+
+} // CaseTrackerMapBuilder

workflow/engine/classes/model/map/CaseTrackerObjectMapBuilder.php

@@ -0,0 +1,83 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'CASE_TRACKER_OBJECT' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class CaseTrackerObjectMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.CaseTrackerObjectMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('CASE_TRACKER_OBJECT');
+		$tMap->setPhpName('CaseTrackerObject');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('CTO_UID', 'CtoUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('CTO_TYPE_OBJ', 'CtoTypeObj', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('CTO_UID_OBJ', 'CtoUidObj', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('CTO_CONDITION', 'CtoCondition', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('CTO_POSITION', 'CtoPosition', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addValidator('CTO_TYPE_OBJ', 'validValues', 'propel.validator.ValidValuesValidator', 'DYNAFORM|INPUT_DOCUMENT|OUTPUT_DOCUMENT|MESSAGE|EXTERNAL', 'Please select a valid value for CTO_TYPE_OBJ.');
+
+	} // doBuild()
+
+} // CaseTrackerObjectMapBuilder

workflow/engine/classes/model/map/ConfigurationMapBuilder.php

@@ -0,0 +1,81 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'CONFIGURATION' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class ConfigurationMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.ConfigurationMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('CONFIGURATION');
+		$tMap->setPhpName('Configuration');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('CFG_UID', 'CfgUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('OBJ_UID', 'ObjUid', 'string', CreoleTypes::VARCHAR, true, 128);
+
+		$tMap->addColumn('CFG_VALUE', 'CfgValue', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addPrimaryKey('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+	} // doBuild()
+
+} // ConfigurationMapBuilder

workflow/engine/classes/model/map/ContentMapBuilder.php

@@ -0,0 +1,83 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'CONTENT' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class ContentMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.ContentMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('CONTENT');
+		$tMap->setPhpName('Content');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('CON_CATEGORY', 'ConCategory', 'string', CreoleTypes::VARCHAR, true, 30);
+
+		$tMap->addPrimaryKey('CON_PARENT', 'ConParent', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('CON_ID', 'ConId', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addPrimaryKey('CON_LANG', 'ConLang', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('CON_VALUE', 'ConValue', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addValidator('CON_LANG', 'maxLength', 'propel.validator.MaxLengthValidator', '5', 'Language can be no larger than 5 in size');
+
+		$tMap->addValidator('CON_LANG', 'required', 'propel.validator.RequiredValidator', '', 'Language is required.');
+
+	} // doBuild()
+
+} // ContentMapBuilder

workflow/engine/classes/model/map/DbSourceMapBuilder.php

@@ -0,0 +1,87 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'DB_SOURCE' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class DbSourceMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.DbSourceMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('DB_SOURCE');
+		$tMap->setPhpName('DbSource');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('DBS_UID', 'DbsUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DBS_TYPE', 'DbsType', 'string', CreoleTypes::VARCHAR, true, 8);
+
+		$tMap->addColumn('DBS_SERVER', 'DbsServer', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('DBS_DATABASE_NAME', 'DbsDatabaseName', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('DBS_USERNAME', 'DbsUsername', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DBS_PASSWORD', 'DbsPassword', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('DBS_PORT', 'DbsPort', 'int', CreoleTypes::INTEGER, false, null);
+
+		$tMap->addColumn('DBS_ENCODE', 'DbsEncode', 'string', CreoleTypes::VARCHAR, false, 32);
+
+	} // doBuild()
+
+} // DbSourceMapBuilder

workflow/engine/classes/model/map/DepartmentMapBuilder.php

@@ -0,0 +1,83 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'DEPARTMENT' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class DepartmentMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.DepartmentMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('DEPARTMENT');
+		$tMap->setPhpName('Department');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('DEP_UID', 'DepUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEP_PARENT', 'DepParent', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEP_MANAGER', 'DepManager', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DEP_LOCATION', 'DepLocation', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('DEP_STATUS', 'DepStatus', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('DEP_REF_CODE', 'DepRefCode', 'string', CreoleTypes::VARCHAR, true, 50);
+
+		$tMap->addColumn('DEP_LDAP_DN', 'DepLdapDn', 'string', CreoleTypes::VARCHAR, true, 255);
+
+	} // doBuild()
+
+} // DepartmentMapBuilder

workflow/engine/classes/model/map/DimTimeCompleteMapBuilder.php

@@ -0,0 +1,85 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'DIM_TIME_COMPLETE' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class DimTimeCompleteMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.DimTimeCompleteMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('DIM_TIME_COMPLETE');
+		$tMap->setPhpName('DimTimeComplete');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('TIME_ID', 'TimeId', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('MONTH_ID', 'MonthId', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('QTR_ID', 'QtrId', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('YEAR_ID', 'YearId', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('MONTH_NAME', 'MonthName', 'string', CreoleTypes::VARCHAR, true, 3);
+
+		$tMap->addColumn('MONTH_DESC', 'MonthDesc', 'string', CreoleTypes::VARCHAR, true, 9);
+
+		$tMap->addColumn('QTR_NAME', 'QtrName', 'string', CreoleTypes::VARCHAR, true, 4);
+
+		$tMap->addColumn('QTR_DESC', 'QtrDesc', 'string', CreoleTypes::VARCHAR, true, 9);
+
+	} // doBuild()
+
+} // DimTimeCompleteMapBuilder

workflow/engine/classes/model/map/DimTimeDelegateMapBuilder.php

@@ -0,0 +1,85 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'DIM_TIME_DELEGATE' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class DimTimeDelegateMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.DimTimeDelegateMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('DIM_TIME_DELEGATE');
+		$tMap->setPhpName('DimTimeDelegate');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('TIME_ID', 'TimeId', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('MONTH_ID', 'MonthId', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('QTR_ID', 'QtrId', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('YEAR_ID', 'YearId', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('MONTH_NAME', 'MonthName', 'string', CreoleTypes::VARCHAR, true, 3);
+
+		$tMap->addColumn('MONTH_DESC', 'MonthDesc', 'string', CreoleTypes::VARCHAR, true, 9);
+
+		$tMap->addColumn('QTR_NAME', 'QtrName', 'string', CreoleTypes::VARCHAR, true, 4);
+
+		$tMap->addColumn('QTR_DESC', 'QtrDesc', 'string', CreoleTypes::VARCHAR, true, 9);
+
+	} // doBuild()
+
+} // DimTimeDelegateMapBuilder

workflow/engine/classes/model/map/DynaformMapBuilder.php

@@ -0,0 +1,79 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'DYNAFORM' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class DynaformMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.DynaformMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('DYNAFORM');
+		$tMap->setPhpName('Dynaform');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('DYN_UID', 'DynUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('DYN_TYPE', 'DynType', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('DYN_FILENAME', 'DynFilename', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addValidator('DYN_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'xmlform|grid', 'Please select a valid dynaform type.');
+
+	} // doBuild()
+
+} // DynaformMapBuilder

workflow/engine/classes/model/map/EventMapBuilder.php

@@ -0,0 +1,99 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'EVENT' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class EventMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.EventMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('EVENT');
+		$tMap->setPhpName('Event');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('EVN_UID', 'EvnUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('EVN_STATUS', 'EvnStatus', 'string', CreoleTypes::VARCHAR, true, 16);
+
+		$tMap->addColumn('EVN_WHEN_OCCURS', 'EvnWhenOccurs', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('EVN_RELATED_TO', 'EvnRelatedTo', 'string', CreoleTypes::VARCHAR, false, 16);
+
+		$tMap->addColumn('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('EVN_TAS_UID_FROM', 'EvnTasUidFrom', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('EVN_TAS_UID_TO', 'EvnTasUidTo', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('EVN_TAS_ESTIMATED_DURATION', 'EvnTasEstimatedDuration', 'double', CreoleTypes::DOUBLE, false, null);
+
+		$tMap->addColumn('EVN_WHEN', 'EvnWhen', 'double', CreoleTypes::DOUBLE, true, null);
+
+		$tMap->addColumn('EVN_MAX_ATTEMPTS', 'EvnMaxAttempts', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('EVN_ACTION', 'EvnAction', 'string', CreoleTypes::VARCHAR, true, 50);
+
+		$tMap->addColumn('EVN_CONDITIONS', 'EvnConditions', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('EVN_ACTION_PARAMETERS', 'EvnActionParameters', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('TRI_UID', 'TriUid', 'string', CreoleTypes::VARCHAR, false, 32);
+
+	} // doBuild()
+
+} // EventMapBuilder

workflow/engine/classes/model/map/FieldConditionMapBuilder.php

@@ -0,0 +1,85 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'FIELD_CONDITION' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class FieldConditionMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.FieldConditionMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('FIELD_CONDITION');
+		$tMap->setPhpName('FieldCondition');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('FCD_UID', 'FcdUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('FCD_FUNCTION', 'FcdFunction', 'string', CreoleTypes::VARCHAR, true, 50);
+
+		$tMap->addColumn('FCD_FIELDS', 'FcdFields', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('FCD_CONDITION', 'FcdCondition', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('FCD_EVENTS', 'FcdEvents', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('FCD_EVENT_OWNERS', 'FcdEventOwners', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('FCD_STATUS', 'FcdStatus', 'string', CreoleTypes::VARCHAR, false, 10);
+
+		$tMap->addColumn('FCD_DYN_UID', 'FcdDynUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+	} // doBuild()
+
+} // FieldConditionMapBuilder

workflow/engine/classes/model/map/FieldsMapBuilder.php

@@ -0,0 +1,93 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'FIELDS' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class FieldsMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.FieldsMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('FIELDS');
+		$tMap->setPhpName('Fields');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('FLD_UID', 'FldUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('ADD_TAB_UID', 'AddTabUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('FLD_INDEX', 'FldIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('FLD_NAME', 'FldName', 'string', CreoleTypes::VARCHAR, true, 60);
+
+		$tMap->addColumn('FLD_DESCRIPTION', 'FldDescription', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('FLD_TYPE', 'FldType', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('FLD_SIZE', 'FldSize', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('FLD_NULL', 'FldNull', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('FLD_AUTO_INCREMENT', 'FldAutoIncrement', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('FLD_KEY', 'FldKey', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('FLD_FOREIGN_KEY', 'FldForeignKey', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('FLD_FOREIGN_KEY_TABLE', 'FldForeignKeyTable', 'string', CreoleTypes::VARCHAR, true, 32);
+
+	} // doBuild()
+
+} // FieldsMapBuilder

workflow/engine/classes/model/map/GroupUserMapBuilder.php

@@ -0,0 +1,81 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'GROUP_USER' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class GroupUserMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.GroupUserMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('GROUP_USER');
+		$tMap->setPhpName('GroupUser');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('GRP_UID', 'GrpUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addValidator('GRP_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Group UID can be no larger than 32 in size');
+
+		$tMap->addValidator('GRP_UID', 'required', 'propel.validator.RequiredValidator', '', 'Group UID is required.');
+
+		$tMap->addValidator('USR_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'User UID can be no larger than 32 in size');
+
+		$tMap->addValidator('USR_UID', 'required', 'propel.validator.RequiredValidator', '', 'User UID is required.');
+
+	} // doBuild()
+
+} // GroupUserMapBuilder

workflow/engine/classes/model/map/GroupwfMapBuilder.php

@@ -0,0 +1,77 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'GROUPWF' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class GroupwfMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.GroupwfMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('GROUPWF');
+		$tMap->setPhpName('Groupwf');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('GRP_UID', 'GrpUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('GRP_STATUS', 'GrpStatus', 'string', CreoleTypes::CHAR, true, 8);
+
+		$tMap->addValidator('GRP_STATUS', 'validValues', 'propel.validator.ValidValuesValidator', 'ACTIVE|INACTIVE', 'Please select a valid status.');
+
+		$tMap->addValidator('GRP_STATUS', 'required', 'propel.validator.RequiredValidator', '', 'Application Document UID is required.');
+
+	} // doBuild()
+
+} // GroupwfMapBuilder

workflow/engine/classes/model/map/HolidayMapBuilder.php

@@ -0,0 +1,75 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'HOLIDAY' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class HolidayMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.HolidayMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('HOLIDAY');
+		$tMap->setPhpName('Holiday');
+
+		$tMap->setUseIdGenerator(true);
+
+		$tMap->addPrimaryKey('HLD_UID', 'HldUid', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('HLD_DATE', 'HldDate', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('HLD_DESCRIPTION', 'HldDescription', 'string', CreoleTypes::VARCHAR, true, 200);
+
+	} // doBuild()
+
+} // HolidayMapBuilder

workflow/engine/classes/model/map/InputDocumentMapBuilder.php

@@ -0,0 +1,105 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'INPUT_DOCUMENT' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class InputDocumentMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.InputDocumentMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('INPUT_DOCUMENT');
+		$tMap->setPhpName('InputDocument');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('INP_DOC_UID', 'InpDocUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('INP_DOC_FORM_NEEDED', 'InpDocFormNeeded', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('INP_DOC_ORIGINAL', 'InpDocOriginal', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('INP_DOC_PUBLISHED', 'InpDocPublished', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('INP_DOC_VERSIONING', 'InpDocVersioning', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('INP_DOC_DESTINATION_PATH', 'InpDocDestinationPath', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('INP_DOC_TAGS', 'InpDocTags', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addValidator('INP_DOC_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Input Document UID can be no larger than 32 in size');
+
+		$tMap->addValidator('INP_DOC_UID', 'required', 'propel.validator.RequiredValidator', '', 'Input Document UID is required.');
+
+		$tMap->addValidator('PRO_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Process UID can be no larger than 32 in size');
+
+		$tMap->addValidator('PRO_UID', 'required', 'propel.validator.RequiredValidator', '', 'Process UID is required.');
+
+		$tMap->addValidator('INP_DOC_FORM_NEEDED', 'validValues', 'propel.validator.ValidValuesValidator', 'VIRTUAL|REAL|VREAL', 'Please select a valid document format.');
+
+		$tMap->addValidator('INP_DOC_FORM_NEEDED', 'required', 'propel.validator.RequiredValidator', '', 'Document format is required.');
+
+		$tMap->addValidator('INP_DOC_ORIGINAL', 'validValues', 'propel.validator.ValidValuesValidator', 'COPY|ORIGINAL|COPYLEGAL|FINAL', 'Please select a valid document format type.');
+
+		$tMap->addValidator('INP_DOC_ORIGINAL', 'required', 'propel.validator.RequiredValidator', '', 'Document format type is required.');
+
+		$tMap->addValidator('INP_DOC_PUBLISHED', 'validValues', 'propel.validator.ValidValuesValidator', 'PUBLIC|PRIVATE', 'Please select a valid document access.');
+
+		$tMap->addValidator('INP_DOC_PUBLISHED', 'required', 'propel.validator.RequiredValidator', '', 'Document access is required.');
+
+	} // doBuild()
+
+} // InputDocumentMapBuilder

workflow/engine/classes/model/map/IsoCountryMapBuilder.php

@@ -0,0 +1,75 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'ISO_COUNTRY' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class IsoCountryMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.IsoCountryMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('ISO_COUNTRY');
+		$tMap->setPhpName('IsoCountry');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('IC_UID', 'IcUid', 'string', CreoleTypes::VARCHAR, true, 2);
+
+		$tMap->addColumn('IC_NAME', 'IcName', 'string', CreoleTypes::VARCHAR, false, 255);
+
+		$tMap->addColumn('IC_SORT_ORDER', 'IcSortOrder', 'string', CreoleTypes::VARCHAR, false, 255);
+
+	} // doBuild()
+
+} // IsoCountryMapBuilder

workflow/engine/classes/model/map/IsoLocationMapBuilder.php

@@ -0,0 +1,79 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'ISO_LOCATION' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class IsoLocationMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.IsoLocationMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('ISO_LOCATION');
+		$tMap->setPhpName('IsoLocation');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('IC_UID', 'IcUid', 'string', CreoleTypes::VARCHAR, true, 2);
+
+		$tMap->addPrimaryKey('IL_UID', 'IlUid', 'string', CreoleTypes::VARCHAR, true, 5);
+
+		$tMap->addColumn('IL_NAME', 'IlName', 'string', CreoleTypes::VARCHAR, false, 255);
+
+		$tMap->addColumn('IL_NORMAL_NAME', 'IlNormalName', 'string', CreoleTypes::VARCHAR, false, 255);
+
+		$tMap->addColumn('IS_UID', 'IsUid', 'string', CreoleTypes::VARCHAR, false, 4);
+
+	} // doBuild()
+
+} // IsoLocationMapBuilder

workflow/engine/classes/model/map/IsoSubdivisionMapBuilder.php

@@ -0,0 +1,75 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'ISO_SUBDIVISION' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class IsoSubdivisionMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.IsoSubdivisionMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('ISO_SUBDIVISION');
+		$tMap->setPhpName('IsoSubdivision');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('IC_UID', 'IcUid', 'string', CreoleTypes::VARCHAR, true, 2);
+
+		$tMap->addPrimaryKey('IS_UID', 'IsUid', 'string', CreoleTypes::VARCHAR, true, 4);
+
+		$tMap->addColumn('IS_NAME', 'IsName', 'string', CreoleTypes::VARCHAR, true, 255);
+
+	} // doBuild()
+
+} // IsoSubdivisionMapBuilder

workflow/engine/classes/model/map/LanguageMapBuilder.php

@@ -0,0 +1,91 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'LANGUAGE' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class LanguageMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.LanguageMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('LANGUAGE');
+		$tMap->setPhpName('Language');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('LAN_ID', 'LanId', 'string', CreoleTypes::VARCHAR, true, 4);
+
+		$tMap->addColumn('LAN_NAME', 'LanName', 'string', CreoleTypes::VARCHAR, true, 30);
+
+		$tMap->addColumn('LAN_NATIVE_NAME', 'LanNativeName', 'string', CreoleTypes::VARCHAR, true, 30);
+
+		$tMap->addColumn('LAN_DIRECTION', 'LanDirection', 'string', CreoleTypes::CHAR, true, 1);
+
+		$tMap->addColumn('LAN_WEIGHT', 'LanWeight', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('LAN_ENABLED', 'LanEnabled', 'string', CreoleTypes::CHAR, true, 1);
+
+		$tMap->addColumn('LAN_CALENDAR', 'LanCalendar', 'string', CreoleTypes::VARCHAR, true, 30);
+
+		$tMap->addValidator('LAN_DIRECTION', 'validValues', 'propel.validator.ValidValuesValidator', 'L|R', 'Please select a valid Language Direccion.');
+
+		$tMap->addValidator('LAN_DIRECTION', 'required', 'propel.validator.RequiredValidator', '', 'Document access is required.');
+
+		$tMap->addValidator('LAN_ENABLED', 'validValues', 'propel.validator.ValidValuesValidator', '1|0', 'Please select a valid Language Direccion.');
+
+		$tMap->addValidator('LAN_ENABLED', 'required', 'propel.validator.RequiredValidator', '', 'Document access is required.');
+
+	} // doBuild()
+
+} // LanguageMapBuilder

workflow/engine/classes/model/map/LexicoMapBuilder.php

@@ -0,0 +1,77 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'LEXICO' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class LexicoMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.LexicoMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('LEXICO');
+		$tMap->setPhpName('Lexico');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('LEX_TOPIC', 'LexTopic', 'string', CreoleTypes::VARCHAR, true, 64);
+
+		$tMap->addPrimaryKey('LEX_KEY', 'LexKey', 'string', CreoleTypes::VARCHAR, true, 128);
+
+		$tMap->addColumn('LEX_VALUE', 'LexValue', 'string', CreoleTypes::VARCHAR, true, 128);
+
+		$tMap->addColumn('LEX_CAPTION', 'LexCaption', 'string', CreoleTypes::VARCHAR, true, 128);
+
+	} // doBuild()
+
+} // LexicoMapBuilder

workflow/engine/classes/model/map/LogCasesSchedulerMapBuilder.php

@@ -0,0 +1,89 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'LOG_CASES_SCHEDULER' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class LogCasesSchedulerMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.LogCasesSchedulerMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('LOG_CASES_SCHEDULER');
+		$tMap->setPhpName('LogCasesScheduler');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('LOG_CASE_UID', 'LogCaseUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_NAME', 'UsrName', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('EXEC_DATE', 'ExecDate', 'int', CreoleTypes::DATE, true, null);
+
+		$tMap->addColumn('EXEC_HOUR', 'ExecHour', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('RESULT', 'Result', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SCH_UID', 'SchUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('WS_CREATE_CASE_STATUS', 'WsCreateCaseStatus', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('WS_ROUTE_CASE_STATUS', 'WsRouteCaseStatus', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+	} // doBuild()
+
+} // LogCasesSchedulerMapBuilder

workflow/engine/classes/model/map/LoginLogMapBuilder.php

@@ -0,0 +1,85 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'LOGIN_LOG' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class LoginLogMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.LoginLogMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('LOGIN_LOG');
+		$tMap->setPhpName('LoginLog');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('LOG_UID', 'LogUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('LOG_STATUS', 'LogStatus', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('LOG_IP', 'LogIp', 'string', CreoleTypes::VARCHAR, true, 15);
+
+		$tMap->addColumn('LOG_SID', 'LogSid', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('LOG_INIT_DATE', 'LogInitDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('LOG_END_DATE', 'LogEndDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('LOG_CLIENT_HOSTNAME', 'LogClientHostname', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+	} // doBuild()
+
+} // LoginLogMapBuilder

workflow/engine/classes/model/map/ObjectPermissionMapBuilder.php

@@ -0,0 +1,131 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'OBJECT_PERMISSION' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class ObjectPermissionMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.ObjectPermissionMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('OBJECT_PERMISSION');
+		$tMap->setPhpName('ObjectPermission');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('OP_UID', 'OpUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('OP_USER_RELATION', 'OpUserRelation', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('OP_TASK_SOURCE', 'OpTaskSource', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('OP_PARTICIPATE', 'OpParticipate', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('OP_OBJ_TYPE', 'OpObjType', 'string', CreoleTypes::VARCHAR, true, 15);
+
+		$tMap->addColumn('OP_OBJ_UID', 'OpObjUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('OP_ACTION', 'OpAction', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('OP_CASE_STATUS', 'OpCaseStatus', 'string', CreoleTypes::VARCHAR, false, 10);
+
+		$tMap->addValidator('OP_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Object permission UID can be no larger than 32 in size');
+
+		$tMap->addValidator('OP_UID', 'required', 'propel.validator.RequiredValidator', '', 'Object permission UID is required.');
+
+		$tMap->addValidator('PRO_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Process UID can be no larger than 32 in size');
+
+		$tMap->addValidator('PRO_UID', 'required', 'propel.validator.RequiredValidator', '', 'Process UID is required.');
+
+		$tMap->addValidator('TAS_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Task UID can be no larger than 32 in size');
+
+		$tMap->addValidator('TAS_UID', 'required', 'propel.validator.RequiredValidator', '', 'Task UID is required.');
+
+		$tMap->addValidator('USR_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'User or Group UID can be no larger than 32 in size');
+
+		$tMap->addValidator('USR_UID', 'required', 'propel.validator.RequiredValidator', '', 'User or Group UID is required.');
+
+		$tMap->addValidator('OP_USER_RELATION', 'validValues', 'propel.validator.ValidValuesValidator', '1|2', 'Please select a valid relation.');
+
+		$tMap->addValidator('OP_USER_RELATION', 'required', 'propel.validator.RequiredValidator', '', 'Relation is required.');
+
+		$tMap->addValidator('OP_TASK_SOURCE', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Source task UID can be no larger than 32 in size');
+
+		$tMap->addValidator('OP_TASK_SOURCE', 'required', 'propel.validator.RequiredValidator', '', 'Source task is required.');
+
+		$tMap->addValidator('OP_PARTICIPATE', 'validValues', 'propel.validator.ValidValuesValidator', '0|1', 'Please select a valid participation value.');
+
+		$tMap->addValidator('OP_PARTICIPATE', 'required', 'propel.validator.RequiredValidator', '', 'Participation is required.');
+
+		$tMap->addValidator('OP_OBJ_TYPE', 'maxLength', 'propel.validator.MaxLengthValidator', '15', 'Object type can be no larger than 15 in size');
+
+		$tMap->addValidator('OP_OBJ_TYPE', 'required', 'propel.validator.RequiredValidator', '', 'Object type is required.');
+
+		$tMap->addValidator('OP_OBJ_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Object UID can be no larger than 32 in size');
+
+		$tMap->addValidator('OP_OBJ_UID', 'required', 'propel.validator.RequiredValidator', '', 'Object UID is required.');
+
+		$tMap->addValidator('OP_ACTION', 'maxLength', 'propel.validator.MaxLengthValidator', '15', 'Action can be no larger than 15 in size');
+
+		$tMap->addValidator('OP_ACTION', 'required', 'propel.validator.RequiredValidator', '', 'Action is required.');
+
+	} // doBuild()
+
+} // ObjectPermissionMapBuilder

workflow/engine/classes/model/map/OutputDocumentMapBuilder.php

@@ -0,0 +1,111 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'OUTPUT_DOCUMENT' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class OutputDocumentMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.OutputDocumentMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('OUTPUT_DOCUMENT');
+		$tMap->setPhpName('OutputDocument');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('OUT_DOC_UID', 'OutDocUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('OUT_DOC_LANDSCAPE', 'OutDocLandscape', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('OUT_DOC_MEDIA', 'OutDocMedia', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('OUT_DOC_LEFT_MARGIN', 'OutDocLeftMargin', 'int', CreoleTypes::INTEGER, false, null);
+
+		$tMap->addColumn('OUT_DOC_RIGHT_MARGIN', 'OutDocRightMargin', 'int', CreoleTypes::INTEGER, false, null);
+
+		$tMap->addColumn('OUT_DOC_TOP_MARGIN', 'OutDocTopMargin', 'int', CreoleTypes::INTEGER, false, null);
+
+		$tMap->addColumn('OUT_DOC_BOTTOM_MARGIN', 'OutDocBottomMargin', 'int', CreoleTypes::INTEGER, false, null);
+
+		$tMap->addColumn('OUT_DOC_GENERATE', 'OutDocGenerate', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('OUT_DOC_TYPE', 'OutDocType', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('OUT_DOC_CURRENT_REVISION', 'OutDocCurrentRevision', 'int', CreoleTypes::INTEGER, false, null);
+
+		$tMap->addColumn('OUT_DOC_FIELD_MAPPING', 'OutDocFieldMapping', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('OUT_DOC_VERSIONING', 'OutDocVersioning', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('OUT_DOC_DESTINATION_PATH', 'OutDocDestinationPath', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addColumn('OUT_DOC_TAGS', 'OutDocTags', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addValidator('OUT_DOC_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Output Document UID can be no larger than 32 in size');
+
+		$tMap->addValidator('OUT_DOC_UID', 'required', 'propel.validator.RequiredValidator', '', 'Output Document UID is required.');
+
+		$tMap->addValidator('PRO_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Process UID can be no larger than 32 in size');
+
+		$tMap->addValidator('PRO_UID', 'required', 'propel.validator.RequiredValidator', '', 'Process UID is required.');
+
+		$tMap->addValidator('OUT_DOC_GENERATE', 'validValues', 'propel.validator.ValidValuesValidator', 'BOTH|DOC|PDF', 'Please select a outputdocument.');
+
+		$tMap->addValidator('OUT_DOC_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'HTML|ITEXT|JRXML|ACROFORM', 'Please select a valid Output Document Type.');
+
+	} // doBuild()
+
+} // OutputDocumentMapBuilder

workflow/engine/classes/model/map/ProcessCategoryMapBuilder.php

@@ -0,0 +1,77 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'PROCESS_CATEGORY' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class ProcessCategoryMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.ProcessCategoryMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('PROCESS_CATEGORY');
+		$tMap->setPhpName('ProcessCategory');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('CATEGORY_UID', 'CategoryUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('CATEGORY_PARENT', 'CategoryParent', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('CATEGORY_NAME', 'CategoryName', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('CATEGORY_ICON', 'CategoryIcon', 'string', CreoleTypes::VARCHAR, false, 100);
+
+	} // doBuild()
+
+} // ProcessCategoryMapBuilder

workflow/engine/classes/model/map/ProcessMapBuilder.php

@@ -0,0 +1,123 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'PROCESS' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class ProcessMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.ProcessMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('PROCESS');
+		$tMap->setPhpName('Process');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_PARENT', 'ProParent', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_TIME', 'ProTime', 'double', CreoleTypes::DOUBLE, true, null);
+
+		$tMap->addColumn('PRO_TIMEUNIT', 'ProTimeunit', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('PRO_STATUS', 'ProStatus', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('PRO_TYPE_DAY', 'ProTypeDay', 'string', CreoleTypes::CHAR, true, 1);
+
+		$tMap->addColumn('PRO_TYPE', 'ProType', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('PRO_ASSIGNMENT', 'ProAssignment', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('PRO_SHOW_MAP', 'ProShowMap', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('PRO_SHOW_MESSAGE', 'ProShowMessage', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('PRO_SHOW_DELEGATE', 'ProShowDelegate', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('PRO_SHOW_DYNAFORM', 'ProShowDynaform', 'int', CreoleTypes::TINYINT, true, null);
+
+		$tMap->addColumn('PRO_CATEGORY', 'ProCategory', 'string', CreoleTypes::VARCHAR, true, 48);
+
+		$tMap->addColumn('PRO_SUB_CATEGORY', 'ProSubCategory', 'string', CreoleTypes::VARCHAR, true, 48);
+
+		$tMap->addColumn('PRO_INDUSTRY', 'ProIndustry', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('PRO_UPDATE_DATE', 'ProUpdateDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('PRO_CREATE_DATE', 'ProCreateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('PRO_CREATE_USER', 'ProCreateUser', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_HEIGHT', 'ProHeight', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('PRO_WIDTH', 'ProWidth', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('PRO_TITLE_X', 'ProTitleX', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('PRO_TITLE_Y', 'ProTitleY', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('PRO_DEBUG', 'ProDebug', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addValidator('PRO_TIMEUNIT', 'validValues', 'propel.validator.ValidValuesValidator', 'WEEKS|MONTHS|DAYS|HOURS|MINUTES', 'Please select a valid Time Unit.');
+
+		$tMap->addValidator('PRO_STATUS', 'validValues', 'propel.validator.ValidValuesValidator', 'ACTIVE|INACTIVE|DISABLED', 'Please select a valid Process Status.');
+
+		$tMap->addValidator('PRO_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'NORMAL', 'Please select a valid Process Type.');
+
+		$tMap->addValidator('PRO_ASSIGNMENT', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid Process Assignment');
+
+	} // doBuild()
+
+} // ProcessMapBuilder

workflow/engine/classes/model/map/ProcessOwnerMapBuilder.php

@@ -0,0 +1,73 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'PROCESS_OWNER' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class ProcessOwnerMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.ProcessOwnerMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('PROCESS_OWNER');
+		$tMap->setPhpName('ProcessOwner');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('OWN_UID', 'OwnUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+	} // doBuild()
+
+} // ProcessOwnerMapBuilder

workflow/engine/classes/model/map/ProcessUserMapBuilder.php

@@ -0,0 +1,93 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'PROCESS_USER' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class ProcessUserMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.ProcessUserMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('PROCESS_USER');
+		$tMap->setPhpName('ProcessUser');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('PU_UID', 'PuUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PU_TYPE', 'PuType', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addValidator('PU_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Process User UID can be no larger than 32 in size');
+
+		$tMap->addValidator('PU_UID', 'required', 'propel.validator.RequiredValidator', '', 'Process User UID is required.');
+
+		$tMap->addValidator('PRO_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Process UID can be no larger than 32 in size');
+
+		$tMap->addValidator('PRO_UID', 'required', 'propel.validator.RequiredValidator', '', 'Process UID is required.');
+
+		$tMap->addValidator('USR_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'User UID can be no larger than 32 in size');
+
+		$tMap->addValidator('USR_UID', 'required', 'propel.validator.RequiredValidator', '', 'User UID is required.');
+
+		$tMap->addValidator('PU_TYPE', 'maxLength', 'propel.validator.MaxLengthValidator', '20', 'Value can be no larger than 20 in size');
+
+		$tMap->addValidator('PU_TYPE', 'required', 'propel.validator.RequiredValidator', '', 'Value is required.');
+
+	} // doBuild()
+
+} // ProcessUserMapBuilder

workflow/engine/classes/model/map/ReportTableMapBuilder.php

@@ -0,0 +1,109 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'REPORT_TABLE' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class ReportTableMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.ReportTableMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('REPORT_TABLE');
+		$tMap->setPhpName('ReportTable');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('REP_TAB_UID', 'RepTabUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('REP_TAB_NAME', 'RepTabName', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('REP_TAB_TYPE', 'RepTabType', 'string', CreoleTypes::VARCHAR, true, 6);
+
+		$tMap->addColumn('REP_TAB_GRID', 'RepTabGrid', 'string', CreoleTypes::VARCHAR, false, 150);
+
+		$tMap->addColumn('REP_TAB_CONNECTION', 'RepTabConnection', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('REP_TAB_CREATE_DATE', 'RepTabCreateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('REP_TAB_STATUS', 'RepTabStatus', 'string', CreoleTypes::CHAR, true, 8);
+
+		$tMap->addValidator('REP_TAB_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Report table UID can be no larger than 32 in size');
+
+		$tMap->addValidator('REP_TAB_UID', 'required', 'propel.validator.RequiredValidator', '', 'Report table UID is required.');
+
+		$tMap->addValidator('PRO_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Process UID can be no larger than 32 in size');
+
+		$tMap->addValidator('PRO_UID', 'required', 'propel.validator.RequiredValidator', '', 'Process UID is required.');
+
+		$tMap->addValidator('REP_TAB_NAME', 'maxLength', 'propel.validator.MaxLengthValidator', '100', 'Report table name can be no larger than 100 in size');
+
+		$tMap->addValidator('REP_TAB_NAME', 'required', 'propel.validator.RequiredValidator', '', 'Report table name is required.');
+
+		$tMap->addValidator('REP_TAB_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'NORMAL|GRID', 'Please select a valid type.');
+
+		$tMap->addValidator('REP_TAB_TYPE', 'required', 'propel.validator.RequiredValidator', '', 'Report table type is required.');
+
+		$tMap->addValidator('REP_TAB_CONNECTION', 'maxLength', 'propel.validator.MaxLengthValidator', '10', 'Report table connection can be no larger than 10 in size');
+
+		$tMap->addValidator('REP_TAB_CONNECTION', 'required', 'propel.validator.RequiredValidator', '', 'Report table connection is required.');
+
+		$tMap->addValidator('REP_TAB_STATUS', 'validValues', 'propel.validator.ValidValuesValidator', 'ACTIVE|INACTIVE', 'Please select a valid status.');
+
+		$tMap->addValidator('REP_TAB_STATUS', 'required', 'propel.validator.RequiredValidator', '', 'Report table status is required.');
+
+	} // doBuild()
+
+} // ReportTableMapBuilder

workflow/engine/classes/model/map/ReportVarMapBuilder.php

@@ -0,0 +1,95 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'REPORT_VAR' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class ReportVarMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.ReportVarMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('REPORT_VAR');
+		$tMap->setPhpName('ReportVar');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('REP_VAR_UID', 'RepVarUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('REP_TAB_UID', 'RepTabUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('REP_VAR_NAME', 'RepVarName', 'string', CreoleTypes::VARCHAR, true, 255);
+
+		$tMap->addColumn('REP_VAR_TYPE', 'RepVarType', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addValidator('REP_VAR_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Report variable UID can be no larger than 32 in size');
+
+		$tMap->addValidator('REP_VAR_UID', 'required', 'propel.validator.RequiredValidator', '', 'Report variable UID is required.');
+
+		$tMap->addValidator('REP_TAB_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Report table UID can be no larger than 32 in size');
+
+		$tMap->addValidator('REP_TAB_UID', 'required', 'propel.validator.RequiredValidator', '', 'Report variable UID is required.');
+
+		$tMap->addValidator('REP_VAR_NAME', 'maxLength', 'propel.validator.MaxLengthValidator', '255', 'Report variable name can be no larger than 255 in size');
+
+		$tMap->addValidator('REP_VAR_NAME', 'required', 'propel.validator.RequiredValidator', '', 'Report variable name is required.');
+
+		$tMap->addValidator('REP_VAR_TYPE', 'maxLength', 'propel.validator.MaxLengthValidator', '20', 'Report variable type can be no larger than 20 in size');
+
+		$tMap->addValidator('REP_VAR_TYPE', 'required', 'propel.validator.RequiredValidator', '', 'Report variable type is required.');
+
+	} // doBuild()
+
+} // ReportVarMapBuilder

workflow/engine/classes/model/map/RouteMapBuilder.php

@@ -0,0 +1,119 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'ROUTE' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class RouteMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.RouteMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('ROUTE');
+		$tMap->setPhpName('Route');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('ROU_UID', 'RouUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('ROU_PARENT', 'RouParent', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('ROU_NEXT_TASK', 'RouNextTask', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('ROU_CASE', 'RouCase', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('ROU_TYPE', 'RouType', 'string', CreoleTypes::VARCHAR, true, 25);
+
+		$tMap->addColumn('ROU_CONDITION', 'RouCondition', 'string', CreoleTypes::VARCHAR, true, 255);
+
+		$tMap->addColumn('ROU_TO_LAST_USER', 'RouToLastUser', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('ROU_OPTIONAL', 'RouOptional', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('ROU_SEND_EMAIL', 'RouSendEmail', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('ROU_SOURCEANCHOR', 'RouSourceanchor', 'int', CreoleTypes::INTEGER, false, null);
+
+		$tMap->addColumn('ROU_TARGETANCHOR', 'RouTargetanchor', 'int', CreoleTypes::INTEGER, false, null);
+
+		$tMap->addValidator('ROU_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Route UID can be no larger than 32 in size');
+
+		$tMap->addValidator('ROU_UID', 'required', 'propel.validator.RequiredValidator', '', 'Route UID is required.');
+
+		$tMap->addValidator('PRO_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Process UID can be no larger than 32 in size');
+
+		$tMap->addValidator('PRO_UID', 'required', 'propel.validator.RequiredValidator', '', 'Process UID is required.');
+
+		$tMap->addValidator('TAS_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Task UID can be no larger than 32 in size');
+
+		$tMap->addValidator('TAS_UID', 'required', 'propel.validator.RequiredValidator', '', 'Task UID is required.');
+
+		$tMap->addValidator('ROU_NEXT_TASK', 'required', 'propel.validator.RequiredValidator', '', 'Next Task UID is required.');
+
+		$tMap->addValidator('ROU_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'SEQUENTIAL|EVALUATE|SELECT|PARALLEL|PARALLEL-BY-EVALUATION|SEC-JOIN', 'Please select a valid Route Type.');
+
+		$tMap->addValidator('ROU_TYPE', 'required', 'propel.validator.RequiredValidator', '', 'Route type is required.');
+
+		$tMap->addValidator('ROU_TO_LAST_USER', 'validValues', 'propel.validator.ValidValuesValidator', 'FALSE|TRUE', 'Please select a valid value for ROU_TO_LAST_USER .');
+
+		$tMap->addValidator('ROU_OPTIONAL', 'validValues', 'propel.validator.ValidValuesValidator', 'FALSE|TRUE', 'Please select a valid value for ROU_OPTIONAL .');
+
+		$tMap->addValidator('ROU_SEND_EMAIL', 'validValues', 'propel.validator.ValidValuesValidator', 'FALSE|TRUE', 'Please select a valid value for ROU_SEND_EMAIL.');
+
+	} // doBuild()
+
+} // RouteMapBuilder

workflow/engine/classes/model/map/SessionMapBuilder.php

@@ -0,0 +1,83 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'SESSION' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class SessionMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.SessionMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('SESSION');
+		$tMap->setPhpName('Session');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('SES_UID', 'SesUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SES_STATUS', 'SesStatus', 'string', CreoleTypes::VARCHAR, true, 16);
+
+		$tMap->addColumn('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SES_REMOTE_IP', 'SesRemoteIp', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SES_INIT_DATE', 'SesInitDate', 'string', CreoleTypes::VARCHAR, true, 19);
+
+		$tMap->addColumn('SES_DUE_DATE', 'SesDueDate', 'string', CreoleTypes::VARCHAR, true, 19);
+
+		$tMap->addColumn('SES_END_DATE', 'SesEndDate', 'string', CreoleTypes::VARCHAR, true, 19);
+
+	} // doBuild()
+
+} // SessionMapBuilder

workflow/engine/classes/model/map/ShadowTableMapBuilder.php

@@ -0,0 +1,83 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'SHADOW_TABLE' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class ShadowTableMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.ShadowTableMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('SHADOW_TABLE');
+		$tMap->setPhpName('ShadowTable');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('SHD_UID', 'ShdUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('ADD_TAB_UID', 'AddTabUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SHD_ACTION', 'ShdAction', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('SHD_DETAILS', 'ShdDetails', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SHD_DATE', 'ShdDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+	} // doBuild()
+
+} // ShadowTableMapBuilder

workflow/engine/classes/model/map/StageMapBuilder.php

@@ -0,0 +1,79 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'STAGE' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class StageMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.StageMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('STAGE');
+		$tMap->setPhpName('Stage');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('STG_UID', 'StgUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('STG_POSX', 'StgPosx', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('STG_POSY', 'StgPosy', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('STG_INDEX', 'StgIndex', 'int', CreoleTypes::INTEGER, true, null);
+
+	} // doBuild()
+
+} // StageMapBuilder

workflow/engine/classes/model/map/StepMapBuilder.php

@@ -0,0 +1,87 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'STEP' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class StepMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.StepMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('STEP');
+		$tMap->setPhpName('Step');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('STEP_UID', 'StepUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('STEP_TYPE_OBJ', 'StepTypeObj', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('STEP_UID_OBJ', 'StepUidObj', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('STEP_CONDITION', 'StepCondition', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('STEP_POSITION', 'StepPosition', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('STEP_MODE', 'StepMode', 'string', CreoleTypes::VARCHAR, false, 10);
+
+		$tMap->addValidator('STEP_TYPE_OBJ', 'validValues', 'propel.validator.ValidValuesValidator', 'DYNAFORM|INPUT_DOCUMENT|MESSAGE|OUTPUT_DOCUMENT|EXTERNAL', 'Please select a valid value for STEP_TYPE_OBJ.');
+
+	} // doBuild()
+
+} // StepMapBuilder

workflow/engine/classes/model/map/StepSupervisorMapBuilder.php

@@ -0,0 +1,81 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'STEP_SUPERVISOR' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class StepSupervisorMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.StepSupervisorMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('STEP_SUPERVISOR');
+		$tMap->setPhpName('StepSupervisor');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('STEP_UID', 'StepUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('STEP_TYPE_OBJ', 'StepTypeObj', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('STEP_UID_OBJ', 'StepUidObj', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('STEP_POSITION', 'StepPosition', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addValidator('STEP_TYPE_OBJ', 'validValues', 'propel.validator.ValidValuesValidator', 'DYNAFORM|INPUT_DOCUMENT|OUTPUT_DOCUMENT', 'Please select a valid value for STEP_TYPE_OBJ.');
+
+	} // doBuild()
+
+} // StepSupervisorMapBuilder

workflow/engine/classes/model/map/StepTriggerMapBuilder.php

@@ -0,0 +1,83 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'STEP_TRIGGER' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class StepTriggerMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.StepTriggerMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('STEP_TRIGGER');
+		$tMap->setPhpName('StepTrigger');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('STEP_UID', 'StepUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('TRI_UID', 'TriUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('ST_TYPE', 'StType', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('ST_CONDITION', 'StCondition', 'string', CreoleTypes::VARCHAR, true, 255);
+
+		$tMap->addColumn('ST_POSITION', 'StPosition', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addValidator('ST_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'BEFORE|AFTER', 'Please select a valid value for Trigger Type ST_TYPE.');
+
+	} // doBuild()
+
+} // StepTriggerMapBuilder

workflow/engine/classes/model/map/SubApplicationMapBuilder.php

@@ -0,0 +1,89 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'SUB_APPLICATION' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class SubApplicationMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.SubApplicationMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('SUB_APPLICATION');
+		$tMap->setPhpName('SubApplication');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('APP_UID', 'AppUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('APP_PARENT', 'AppParent', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('DEL_INDEX_PARENT', 'DelIndexParent', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addPrimaryKey('DEL_THREAD_PARENT', 'DelThreadParent', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('SA_STATUS', 'SaStatus', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SA_VALUES_OUT', 'SaValuesOut', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('SA_VALUES_IN', 'SaValuesIn', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('SA_INIT_DATE', 'SaInitDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('SA_FINISH_DATE', 'SaFinishDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addValidator('SA_STATUS', 'validValues', 'propel.validator.ValidValuesValidator', 'ACTIVE|FINISHED|CANCELLED', 'Please select a valid value for SA_STATUS.');
+
+	} // doBuild()
+
+} // SubApplicationMapBuilder

workflow/engine/classes/model/map/SubProcessMapBuilder.php

@@ -0,0 +1,99 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'SUB_PROCESS' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class SubProcessMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.SubProcessMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('SUB_PROCESS');
+		$tMap->setPhpName('SubProcess');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('SP_UID', 'SpUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_PARENT', 'ProParent', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_PARENT', 'TasParent', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SP_TYPE', 'SpType', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('SP_SYNCHRONOUS', 'SpSynchronous', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('SP_SYNCHRONOUS_TYPE', 'SpSynchronousType', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('SP_SYNCHRONOUS_WAIT', 'SpSynchronousWait', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('SP_VARIABLES_OUT', 'SpVariablesOut', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('SP_VARIABLES_IN', 'SpVariablesIn', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('SP_GRID_IN', 'SpGridIn', 'string', CreoleTypes::VARCHAR, true, 50);
+
+		$tMap->addValidator('SP_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'SIMPLE|MULTIPLE', 'Please select a valid value for SP_TYPE.');
+
+		$tMap->addValidator('SP_SYNCHRONOUS', 'validValues', 'propel.validator.ValidValuesValidator', '1|0', 'Please select a valid value for SP_SYNCHRONOUS.');
+
+		$tMap->addValidator('SP_SYNCHRONOUS_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'ALL|INSTANCES|TIME', 'Please select a valid value for SP_SYNCHRONOUS_TYPE.');
+
+	} // doBuild()
+
+} // SubProcessMapBuilder

workflow/engine/classes/model/map/SwimlanesElementsMapBuilder.php

@@ -0,0 +1,91 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'SWIMLANES_ELEMENTS' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class SwimlanesElementsMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.SwimlanesElementsMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('SWIMLANES_ELEMENTS');
+		$tMap->setPhpName('SwimlanesElements');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('SWI_UID', 'SwiUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('SWI_TYPE', 'SwiType', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('SWI_X', 'SwiX', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('SWI_Y', 'SwiY', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addValidator('SWI_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Swimlane Element UID can be no larger than 32 in size');
+
+		$tMap->addValidator('SWI_UID', 'required', 'propel.validator.RequiredValidator', '', 'Swimlane Element UID is required.');
+
+		$tMap->addValidator('PRO_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Process UID can be no larger than 32 in size');
+
+		$tMap->addValidator('PRO_UID', 'required', 'propel.validator.RequiredValidator', '', 'Process UID is required.');
+
+		$tMap->addValidator('SWI_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'LINE|TEXT', 'Please select a valid Swimlane Element type.');
+
+		$tMap->addValidator('SWI_TYPE', 'required', 'propel.validator.RequiredValidator', '', 'Swimlane Element type is required.');
+
+	} // doBuild()
+
+} // SwimlanesElementsMapBuilder

workflow/engine/classes/model/map/TaskMapBuilder.php

@@ -0,0 +1,175 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'TASK' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class TaskMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.TaskMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('TASK');
+		$tMap->setPhpName('Task');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_TYPE', 'TasType', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_DURATION', 'TasDuration', 'double', CreoleTypes::DOUBLE, true, null);
+
+		$tMap->addColumn('TAS_DELAY_TYPE', 'TasDelayType', 'string', CreoleTypes::VARCHAR, true, 30);
+
+		$tMap->addColumn('TAS_TEMPORIZER', 'TasTemporizer', 'double', CreoleTypes::DOUBLE, true, null);
+
+		$tMap->addColumn('TAS_TYPE_DAY', 'TasTypeDay', 'string', CreoleTypes::CHAR, true, 1);
+
+		$tMap->addColumn('TAS_TIMEUNIT', 'TasTimeunit', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_ALERT', 'TasAlert', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_PRIORITY_VARIABLE', 'TasPriorityVariable', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('TAS_ASSIGN_TYPE', 'TasAssignType', 'string', CreoleTypes::VARCHAR, true, 30);
+
+		$tMap->addColumn('TAS_ASSIGN_VARIABLE', 'TasAssignVariable', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('TAS_ASSIGN_LOCATION', 'TasAssignLocation', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_ASSIGN_LOCATION_ADHOC', 'TasAssignLocationAdhoc', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_TRANSFER_FLY', 'TasTransferFly', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_LAST_ASSIGNED', 'TasLastAssigned', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_USER', 'TasUser', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_CAN_UPLOAD', 'TasCanUpload', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_VIEW_UPLOAD', 'TasViewUpload', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_VIEW_ADDITIONAL_DOCUMENTATION', 'TasViewAdditionalDocumentation', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_CAN_CANCEL', 'TasCanCancel', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_OWNER_APP', 'TasOwnerApp', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('STG_UID', 'StgUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TAS_CAN_PAUSE', 'TasCanPause', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_CAN_SEND_MESSAGE', 'TasCanSendMessage', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_CAN_DELETE_DOCS', 'TasCanDeleteDocs', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_SELF_SERVICE', 'TasSelfService', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_START', 'TasStart', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_TO_LAST_USER', 'TasToLastUser', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_SEND_LAST_EMAIL', 'TasSendLastEmail', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TAS_DERIVATION', 'TasDerivation', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('TAS_POSX', 'TasPosx', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('TAS_POSY', 'TasPosy', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addColumn('TAS_COLOR', 'TasColor', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addValidator('TAS_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'NORMAL|ADHOC|SUBPROCESS', 'Please select a valid value for TAS_TYPE.');
+
+		$tMap->addValidator('TAS_TIMEUNIT', 'validValues', 'propel.validator.ValidValuesValidator', 'MINUTES|HOURS|DAYS|WEEKS|MONTHS', 'Please select a valid value for TAS_TIMEUNIT.');
+
+		$tMap->addValidator('TAS_ALERT', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_ALERT.');
+
+		$tMap->addValidator('TAS_ASSIGN_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'BALANCED|MANUAL|EVALUATE|REPORT_TO|SELF_SERVICE', 'Please select a valid value for TAS_ASSIGN_TYPE.');
+
+		$tMap->addValidator('TAS_ASSIGN_LOCATION', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_ASSIGN_LOCATION.');
+
+		$tMap->addValidator('TAS_ASSIGN_LOCATION_ADHOC', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_ASSIGN_LOCATION_ADHOC.');
+
+		$tMap->addValidator('TAS_TRANSFER_FLY', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_TRANSFER_FLY.');
+
+		$tMap->addValidator('TAS_CAN_UPLOAD', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_CAN_UPLOAD.');
+
+		$tMap->addValidator('TAS_VIEW_UPLOAD', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_VIEW_UPLOAD.');
+
+		$tMap->addValidator('TAS_VIEW_ADDITIONAL_DOCUMENTATION', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_VIEW_ADDITIONAL_DOCUMENTATION.');
+
+		$tMap->addValidator('TAS_CAN_CANCEL', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_CAN_CANCEL.');
+
+		$tMap->addValidator('TAS_CAN_PAUSE', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_CAN_PAUSE.');
+
+		$tMap->addValidator('TAS_CAN_SEND_MESSAGE', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_CAN_SEND_MESSAGE.');
+
+		$tMap->addValidator('TAS_CAN_DELETE_DOCS', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|VIEW|FALSE', 'Please select a valid value for TAS_CAN_DELETE_DOCS.');
+
+		$tMap->addValidator('TAS_SELF_SERVICE', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_SELF_SERVICE.');
+
+		$tMap->addValidator('TAS_START', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_START.');
+
+		$tMap->addValidator('TAS_TO_LAST_USER', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_TO_LAST_USER.');
+
+		$tMap->addValidator('TAS_SEND_LAST_EMAIL', 'validValues', 'propel.validator.ValidValuesValidator', 'TRUE|FALSE', 'Please select a valid value for TAS_SEND_LAST_EMAIL.');
+
+		$tMap->addValidator('TAS_DERIVATION', 'validValues', 'propel.validator.ValidValuesValidator', 'NORMAL|FAST|AUTOMATIC', 'Please select a valid value for TAS_DERIVATION.');
+
+	} // doBuild()
+
+} // TaskMapBuilder

workflow/engine/classes/model/map/TaskUserMapBuilder.php

@@ -0,0 +1,93 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'TASK_USER' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class TaskUserMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.TaskUserMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('TASK_USER');
+		$tMap->setPhpName('TaskUser');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('TAS_UID', 'TasUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addPrimaryKey('TU_TYPE', 'TuType', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addPrimaryKey('TU_RELATION', 'TuRelation', 'int', CreoleTypes::INTEGER, true, null);
+
+		$tMap->addValidator('TAS_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'Task UID can be no larger than 32 in size');
+
+		$tMap->addValidator('TAS_UID', 'required', 'propel.validator.RequiredValidator', '', 'Task UID is required.');
+
+		$tMap->addValidator('USR_UID', 'maxLength', 'propel.validator.MaxLengthValidator', '32', 'User UID can be no larger than 32 in size');
+
+		$tMap->addValidator('USR_UID', 'required', 'propel.validator.RequiredValidator', '', 'User UID is required.');
+
+		$tMap->addValidator('TU_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', '1|2', 'Please select a valid type.');
+
+		$tMap->addValidator('TU_TYPE', 'required', 'propel.validator.RequiredValidator', '', 'Type is required.');
+
+		$tMap->addValidator('TU_RELATION', 'validValues', 'propel.validator.ValidValuesValidator', '1|2', 'Please select a valid relation.');
+
+		$tMap->addValidator('TU_RELATION', 'required', 'propel.validator.RequiredValidator', '', 'Relation is required.');
+
+	} // doBuild()
+
+} // TaskUserMapBuilder

workflow/engine/classes/model/map/TranslationMapBuilder.php

@@ -0,0 +1,93 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'TRANSLATION' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class TranslationMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.TranslationMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('TRANSLATION');
+		$tMap->setPhpName('Translation');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('TRN_CATEGORY', 'TrnCategory', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addPrimaryKey('TRN_ID', 'TrnId', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addPrimaryKey('TRN_LANG', 'TrnLang', 'string', CreoleTypes::VARCHAR, true, 10);
+
+		$tMap->addColumn('TRN_VALUE', 'TrnValue', 'string', CreoleTypes::VARCHAR, true, 200);
+
+		$tMap->addValidator('TRN_CATEGORY', 'maxLength', 'propel.validator.MaxLengthValidator', '100', 'Category can be no larger than 100 in size');
+
+		$tMap->addValidator('TRN_CATEGORY', 'required', 'propel.validator.RequiredValidator', '', 'Category is required.');
+
+		$tMap->addValidator('TRN_ID', 'maxLength', 'propel.validator.MaxLengthValidator', '100', 'ID can be no larger than 100 in size');
+
+		$tMap->addValidator('TRN_ID', 'required', 'propel.validator.RequiredValidator', '', 'ID is required.');
+
+		$tMap->addValidator('TRN_LANG', 'maxLength', 'propel.validator.MaxLengthValidator', '5', 'Language can be no larger than 5 in size');
+
+		$tMap->addValidator('TRN_LANG', 'required', 'propel.validator.RequiredValidator', '', 'Language is required.');
+
+		$tMap->addValidator('TRN_VALUE', 'maxLength', 'propel.validator.MaxLengthValidator', '200', 'Value can be no larger than 200 in size');
+
+		$tMap->addValidator('TRN_VALUE', 'required', 'propel.validator.RequiredValidator', '', 'Value is required.');
+
+	} // doBuild()
+
+} // TranslationMapBuilder

workflow/engine/classes/model/map/TriggersMapBuilder.php

@@ -0,0 +1,83 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'TRIGGERS' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class TriggersMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.TriggersMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('TRIGGERS');
+		$tMap->setPhpName('Triggers');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('TRI_UID', 'TriUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('PRO_UID', 'ProUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('TRI_TYPE', 'TriType', 'string', CreoleTypes::VARCHAR, true, 20);
+
+		$tMap->addColumn('TRI_WEBBOT', 'TriWebbot', 'string', CreoleTypes::LONGVARCHAR, true, null);
+
+		$tMap->addColumn('TRI_PARAM', 'TriParam', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+		$tMap->addValidator('TRI_TYPE', 'validValues', 'propel.validator.ValidValuesValidator', 'WEBBOT|SCRIPT', 'Please select a valid type.');
+
+		$tMap->addValidator('TRI_TYPE', 'required', 'propel.validator.RequiredValidator', '', 'Type is required.');
+
+	} // doBuild()
+
+} // TriggersMapBuilder

workflow/engine/classes/model/map/UsersMapBuilder.php

@@ -0,0 +1,123 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'USERS' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class UsersMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.UsersMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('USERS');
+		$tMap->setPhpName('Users');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_USERNAME', 'UsrUsername', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('USR_PASSWORD', 'UsrPassword', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_FIRSTNAME', 'UsrFirstname', 'string', CreoleTypes::VARCHAR, true, 50);
+
+		$tMap->addColumn('USR_LASTNAME', 'UsrLastname', 'string', CreoleTypes::VARCHAR, true, 50);
+
+		$tMap->addColumn('USR_EMAIL', 'UsrEmail', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('USR_DUE_DATE', 'UsrDueDate', 'int', CreoleTypes::DATE, true, null);
+
+		$tMap->addColumn('USR_CREATE_DATE', 'UsrCreateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('USR_UPDATE_DATE', 'UsrUpdateDate', 'int', CreoleTypes::TIMESTAMP, true, null);
+
+		$tMap->addColumn('USR_STATUS', 'UsrStatus', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_COUNTRY', 'UsrCountry', 'string', CreoleTypes::VARCHAR, true, 3);
+
+		$tMap->addColumn('USR_CITY', 'UsrCity', 'string', CreoleTypes::VARCHAR, true, 3);
+
+		$tMap->addColumn('USR_LOCATION', 'UsrLocation', 'string', CreoleTypes::VARCHAR, true, 3);
+
+		$tMap->addColumn('USR_ADDRESS', 'UsrAddress', 'string', CreoleTypes::VARCHAR, true, 255);
+
+		$tMap->addColumn('USR_PHONE', 'UsrPhone', 'string', CreoleTypes::VARCHAR, true, 24);
+
+		$tMap->addColumn('USR_FAX', 'UsrFax', 'string', CreoleTypes::VARCHAR, true, 24);
+
+		$tMap->addColumn('USR_CELLULAR', 'UsrCellular', 'string', CreoleTypes::VARCHAR, true, 24);
+
+		$tMap->addColumn('USR_ZIP_CODE', 'UsrZipCode', 'string', CreoleTypes::VARCHAR, true, 16);
+
+		$tMap->addColumn('DEP_UID', 'DepUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_POSITION', 'UsrPosition', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('USR_RESUME', 'UsrResume', 'string', CreoleTypes::VARCHAR, true, 100);
+
+		$tMap->addColumn('USR_BIRTHDAY', 'UsrBirthday', 'int', CreoleTypes::DATE, true, null);
+
+		$tMap->addColumn('USR_ROLE', 'UsrRole', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('USR_REPORTS_TO', 'UsrReportsTo', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addColumn('USR_REPLACED_BY', 'UsrReplacedBy', 'string', CreoleTypes::VARCHAR, false, 32);
+
+		$tMap->addValidator('USR_STATUS', 'validValues', 'propel.validator.ValidValuesValidator', 'ACTIVE|INACTIVE|VACATION|CLOSED', 'Please select a valid type.');
+
+		$tMap->addValidator('USR_STATUS', 'required', 'propel.validator.RequiredValidator', '', 'Type is required.');
+
+	} // doBuild()
+
+} // UsersMapBuilder

workflow/engine/classes/model/map/UsersPropertiesMapBuilder.php

@@ -0,0 +1,77 @@
+<?php
+
+require_once 'propel/map/MapBuilder.php';
+include_once 'creole/CreoleTypes.php';
+
+
+/**
+ * This class adds structure of 'USERS_PROPERTIES' table to 'workflow' DatabaseMap object.
+ *
+ *
+ *
+ * These statically-built map classes are used by Propel to do runtime db structure discovery.
+ * For example, the createSelectSql() method checks the type of a given column used in an
+ * ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
+ * (i.e. if it's a text column type).
+ *
+ * @package    classes.model.map
+ */
+class UsersPropertiesMapBuilder {
+
+	/**
+	 * The (dot-path) name of this class
+	 */
+	const CLASS_NAME = 'classes.model.map.UsersPropertiesMapBuilder';
+
+	/**
+	 * The database map.
+	 */
+	private $dbMap;
+
+	/**
+	 * Tells us if this DatabaseMapBuilder is built so that we
+	 * don't have to re-build it every time.
+	 *
+	 * @return     boolean true if this DatabaseMapBuilder is built, false otherwise.
+	 */
+	public function isBuilt()
+	{
+		return ($this->dbMap !== null);
+	}
+
+	/**
+	 * Gets the databasemap this map builder built.
+	 *
+	 * @return     the databasemap
+	 */
+	public function getDatabaseMap()
+	{
+		return $this->dbMap;
+	}
+
+	/**
+	 * The doBuild() method builds the DatabaseMap
+	 *
+	 * @return     void
+	 * @throws     PropelException
+	 */
+	public function doBuild()
+	{
+		$this->dbMap = Propel::getDatabaseMap('workflow');
+
+		$tMap = $this->dbMap->addTable('USERS_PROPERTIES');
+		$tMap->setPhpName('UsersProperties');
+
+		$tMap->setUseIdGenerator(false);
+
+		$tMap->addPrimaryKey('USR_UID', 'UsrUid', 'string', CreoleTypes::VARCHAR, true, 32);
+
+		$tMap->addColumn('USR_LAST_UPDATE_DATE', 'UsrLastUpdateDate', 'int', CreoleTypes::TIMESTAMP, false, null);
+
+		$tMap->addColumn('USR_LOGGED_NEXT_TIME', 'UsrLoggedNextTime', 'int', CreoleTypes::INTEGER, false, null);
+
+		$tMap->addColumn('USR_PASSWORD_HISTORY', 'UsrPasswordHistory', 'string', CreoleTypes::LONGVARCHAR, false, null);
+
+	} // doBuild()
+
+} // UsersPropertiesMapBuilder