/**
* Instantiate a new ModelPageModel object
*
* @param array
*/
public function __construct($args = array())
{
$args = array_merge(array('depth' => 'page', 'instance' => null), $args);
$this->depth = $args['depth'];
$this->compareInstance = $args['instance'];
if (!isset(self::$modelTable)) {
self::$modelTable = QFrame_Db_Table::getTable('model');
}
if (!isset(self::$modelResponseTable)) {
self::$modelResponseTable = QFrame_Db_Table::getTable('model_response');
}
if (!isset(self::$sectionTable)) {
self::$sectionTable = QFrame_Db_Table::getTable('section');
}
if (isset($args['modelID']) && isset($args['pageID'])) {
$this->modelID = $args['modelID'];
$this->page = new PageModel(array('pageID' => $args['pageID'], 'depth' => $args['depth']));
} else {
throw new InvalidArgumentException('Missing arguments to ModelPageModel constructor');
}
// To populate cache
self::$modelResponseTable->fetchRows('modelID', $this->modelID, 'modelResponseID', $this->modelID);
if ($this->depth !== 'page') {
$this->_loadModelSections();
}
}
/**
* Instantiate a new ModelResponseModel object
*
* @param array
*/
public function __construct($args = array())
{
$args = array_merge(array('depth' => 'response', 'instance' => null), $args);
$this->depth = $args['depth'];
$this->compareInstance = $args['instance'];
if (!isset(self::$modelTable)) {
self::$modelTable = QFrame_Db_Table::getTable('model');
}
if (!isset(self::$modelResponseTable)) {
self::$modelResponseTable = QFrame_Db_Table::getTable('model_response');
}
if (!isset(self::$questionPromptTable)) {
self::$questionPromptTable = QFrame_Db_Table::getTable('question_prompt');
}
if (isset($args['modelResponseID'])) {
$rows = self::$modelResponseTable->fetchRows('modelResponseID', $args['modelResponseID']);
$this->modelResponseRow = $rows[0];
} else {
throw new InvalidArgumentException('Missing arguments to ModelResponseModel constructor');
}
// model response row assertion
if ($this->modelResponseRow === NULL) {
throw new Exception('Model response not found');
}
}
function __construct($args)
{
$args = array_merge(array('depth' => 'response'), $args);
$this->depth = $args['depth'];
// argument assertions
if (!isset($args['pageID'])) {
throw new InvalidArgumentException('Missing pageID as argument to PageModel constructor');
}
if (!isset(self::$pageTable)) {
self::$pageTable = QFrame_Db_Table::getTable('page');
}
if (!isset(self::$sectionTable)) {
self::$sectionTable = QFrame_Db_Table::getTable('section');
}
if (!isset(self::$questionTable)) {
self::$questionTable = QFrame_Db_Table::getTable('question');
}
if (!isset(self::$ruleTable)) {
self::$ruleTable = QFrame_Db_Table::getTable('rule');
}
if (!isset(self::$questionTypeTable)) {
self::$questionTypeTable = QFrame_Db_Table::getTable('question_type');
}
if (!isset(self::$pageReferenceTable)) {
self::$pageReferenceTable = QFrame_Db_Table::getTable('page_reference');
}
if (!isset(self::$referenceDetailTable)) {
self::$referenceDetailTable = QFrame_Db_Table::getTable('reference_detail');
}
$rows = self::$pageTable->fetchRows('pageID', $args['pageID']);
$this->pageRow = $rows[0];
// page row assertion
if ($this->pageRow === NULL) {
throw new Exception('Page not found [' . $args['pageID'] . ']');
}
$ruleRows = self::$ruleTable->fetchRows('targetID', $this->pageRow->pageID, null, $this->pageRow->instanceID);
$disableCount = 0;
foreach ($ruleRows as $row) {
if ($row->enabled === 'Y' && $row->type === 'disablePage') {
$disableCount++;
} elseif ($row->enabled === 'Y' && $row->type === 'enablePage') {
$disableCount--;
}
}
if ($this->pageRow->defaultPageHidden) {
$disableCount++;
}
if ($disableCount != $this->pageRow->disableCount) {
$this->pageRow->disableCount = $disableCount;
$this->pageRow->save();
}
if ($this->depth !== 'page') {
$this->_loadSections();
}
$pageReferenceRows = self::$pageReferenceTable->fetchRows('pageID', $this->pageRow->pageID, null, $this->pageRow->instanceID);
foreach ($pageReferenceRows as $row) {
$rows = self::$referenceDetailTable->fetchRows('referenceDetailID', $row->referenceDetailID, null, $this->pageRow->instanceID);
$this->referenceDetailRows[] = $rows[0]->toArray();
}
}
function __construct($args = array())
{
if (!isset(self::$responseTable)) {
self::$responseTable = QFrame_Db_Table::getTable('response');
}
if (!isset(self::$questionPromptTable)) {
self::$questionPromptTable = QFrame_Db_Table::getTable('question_prompt');
}
$args = array_merge(array('questionID' => null, 'instanceID' => null, 'responseText' => null, 'additionalInfo' => null, 'privateNote' => null, 'externalReference' => null, 'state' => null, 'dbUserID' => -1), $args);
if (isset($args['responseID'])) {
$responseRows = self::$responseTable->fetchRows('responseID', intval($args['responseID']));
foreach ($responseRows as $r) {
if (!$r->responseEndDate) {
$this->responseRow = $r;
}
}
// response row assertion
if ($this->responseRow === NULL) {
throw new Exception('Response not found');
}
$this->dirty = 0;
} else {
$this->responseRow = self::$responseTable->createRow();
$this->responseRow->questionID = intval($args['questionID']);
$this->responseRow->instanceID = intval($args['instanceID']);
$this->responseRow->pageID = intval($args['pageID']);
$this->responseRow->sectionID = intval($args['sectionID']);
$this->responseRow->responseText = $args['responseText'];
$this->responseRow->additionalInfo = $args['additionalInfo'];
$this->responseRow->privateNote = $args['privateNote'];
$this->responseRow->externalReference = $args['externalReference'];
$this->responseRow->state = $args['state'];
$this->responseRow->dbUserID = $args['dbUserID'];
$this->dirty = 1;
}
}
/**
* Instantiate a new ModelSectionModel object
*
* @param array
*/
public function __construct($args = array())
{
$args = array_merge(array('depth' => 'section', 'instance' => null), $args);
$this->depth = $args['depth'];
$this->compareInstance = $args['instance'];
if (!isset(self::$modelTable)) {
self::$modelTable = QFrame_Db_Table::getTable('model');
}
if (!isset(self::$modelResponseTable)) {
self::$modelResponseTable = QFrame_Db_Table::getTable('model_response');
}
if (!isset(self::$questionTable)) {
self::$questionTable = QFrame_Db_Table::getTable('question');
}
if (isset($args['modelID']) && isset($args['sectionID'])) {
$this->modelID = $args['modelID'];
$this->section = new SectionModel(array('sectionID' => $args['sectionID'], 'depth' => $args['depth']));
} else {
throw new InvalidArgumentException('Missing arguments to ModelSectionModel constructor');
}
if ($this->depth !== 'section') {
$this->_loadModelQuestions();
}
}
/**
* Reload this object's data based on a given key
*
* @param integer primary key
*/
public function _load($key)
{
if (!isset(self::$roleTable)) {
self::$roleTable = QFrame_Db_Table::getTable('role');
}
$data = self::$roleTable->find($key)->current()->toArray();
$this->setAttributes($data, false);
$this->acl = unserialize($data['ACLstring']);
}
private function _loadQuestions()
{
$questions = QFrame_Db_Table::getTable('question')->fetchRows('sectionID', $this->sectionID, 'seqNumber', $this->sectionRow->pageID);
$this->questions = array();
foreach ($questions as $question) {
if ($question->parentID == 0) {
$this->questions[] = new QuestionModel(array('questionID' => $question->questionID, 'depth' => $this->depth));
}
}
reset($this->questions);
return 1;
}
public static function importXML(&$import, $options = array())
{
if (!isset(self::$questionnaireTable)) {
self::$questionnaireTable = QFrame_Db_Table::getTable('questionnaire');
}
libxml_use_internal_errors(true);
if (is_a($import, 'ZipArchiveModel')) {
$zip =& $import;
$xml = $import->getQuestionnaireDefinitionXMLDocument();
if ($xml === NULL) {
$xml = $import->getInstanceFullResponsesXMLDocument();
}
if ($xml === NULL) {
throw new Exception('Questionnaire definition not found in zip archive');
}
$dom = new DOMDocument();
$dom->loadXML($xml);
} elseif (is_a($import, 'DOMDocument')) {
$dom =& $import;
$xml = $dom->saveXML();
} else {
$xml =& $import;
$dom = new DOMDocument();
$dom->loadXML($xml);
}
$errors = libxml_get_errors();
try {
$logger = Zend_Registry::get('logger');
} catch (Zend_Exception $e) {
}
foreach ($errors as $error) {
$message = rtrim("XML error on line {$error->line} of {$error->file}: {$error->message}");
if (isset($logger) && $logger) {
$logger->log($message, Zend_Log::ERR);
}
error_log($message);
}
if (count($errors) > 0) {
throw new Exception('XML Exception');
}
self::validateQuestionnaireDefinitionXML($dom);
$questionnaire = $dom->getElementsByTagName('questionnaire')->item(0);
$questionnaireName = $questionnaire->getAttribute('questionnaireName');
$questionnaireVersion = $questionnaire->getAttribute('questionnaireVersion');
$revision = $questionnaire->getAttribute('revision');
$transactionNumber = self::startSerializableTransaction();
if (isset($options['SkipQuestionnaireExistCheck'])) {
$signature = 'nosignature';
} else {
$questionnaireID = self::$questionnaireTable->getQuestionnaireID($questionnaireName, $questionnaireVersion, $revision);
$signature = self::generateSignature($dom);
if (isset($questionnaireID)) {
$prevQuestionnaire = new QuestionnaireModel(array('questionnaireID' => $questionnaireID, 'depth' => 'questionnaire'));
if ($signature === $prevQuestionnaire->signature) {
$message = "Skipping questionnaire import since {$questionnaireName} {$questionnaireVersion} {$revision} already exists and has the same signature";
if (isset($logger) && $logger) {
$logger->log($message, Zend_Log::ERR);
}
self::dbCommit($transactionNumber);
return $questionnaireID;
} else {
throw new Exception('A questionnaire with the same name, version, and revision already exists with different content');
}
}
}
$questionnaireID = self::$questionnaireTable->insert(array('questionnaireName' => $questionnaireName, 'questionnaireVersion' => $questionnaireVersion, 'revision' => $revision, 'signature' => $signature));
$questionnaire = new QuestionnaireModel(array('questionnaireID' => $questionnaireID, 'depth' => 'questionnaire'));
$questionnaire->validateQuestionnaireDefinitionXML($dom);
// store files
if (!isset($options['SkipFileAttachments'])) {
$questionnaire->questionnaireDefinition2responseSchema($dom);
$questionnaire->questionnaireDefinition2completedResponseSchema($dom);
$files = new FileModel($questionnaire);
$files->store($xml, array('filename' => 'questionnaire-definition.xml'));
}
self::dbCommit($transactionNumber);
if (!isset($options['SkipQuestionnaireExistCheck']) && !$questionnaire->getDefaultInstance()) {
InstanceModel::importXML($xml, '_default_', array('hidden' => 1));
}
return $questionnaireID;
}
/**
* Get the model (or models) with the given name
*
* @param string model The name of the model (or models) we are looking for
* @return array
*/
public static function findModelsByName($name)
{
if (!isset(self::$modelTable)) {
self::$modelTable = QFrame_Db_Table::getTable('model');
}
$where = self::$modelTable->getAdapter()->quoteInto('name = ?', $name);
$rows = self::$modelTable->fetchAll($where);
$models = array();
foreach ($rows as $row) {
$models[] = new ModelModel(array('modelID' => $row->modelID));
}
return $models;
}
/**
* Imports an XML Document and creates an instance
*
* @param mixed $import maybe a string xml document, DOMDocument object, or ZipArchiveModel object
* @param string $instanceName is the name of the new instance
* @param array $options contains a mix of options for import sources and validation
* @return integer instanceID
*/
public static function importXML(&$import, $instanceName, $options = array())
{
$options = array_merge(array('pageClones' => 0, 'sectionClones' => 0, 'questionClones' => 0, 'pageResponses' => array('all' => 0), 'hidden' => 0), $options);
if (!isset($instanceName) || strlen($instanceName) == 0) {
throw new InvalidArgumentException('Missing instanceName argument');
}
libxml_use_internal_errors(true);
if (is_a($import, 'ZipArchiveModel')) {
$zip =& $import;
$xml = $import->getInstanceFullResponsesXMLDocument();
if ($xml === NULL) {
$xml = $import->getQuestionnaireDefinitionXMLDocument();
}
if ($xml === NULL) {
throw new Exception('Questionnaire definition not found in zip archive');
}
$dom = new DOMDocument();
$dom->loadXML($xml);
} elseif (is_a($import, 'DOMDocument')) {
$dom =& $import;
$xml = $dom->saveXML();
} else {
$xml =& $import;
$dom = new DOMDocument();
$dom->loadXML($xml);
}
$errors = libxml_get_errors();
try {
$logger = Zend_Registry::get('logger');
} catch (Zend_Exception $e) {
}
foreach ($errors as $error) {
$message = rtrim("XML error on line {$error->line} of {$error->file}: {$error->message}");
if (isset($logger) && $logger) {
$logger->log($message, Zend_Log::ERR);
}
error_log($message);
}
if (count($errors) > 0) {
throw new Exception('XML Exception');
}
if (!isset(self::$questionReferenceTable)) {
self::$questionReferenceTable = QFrame_Db_Table::getTable('question_reference');
}
if (!isset(self::$sectionReferenceTable)) {
self::$sectionReferenceTable = QFrame_Db_Table::getTable('section_reference');
}
if (!isset(self::$pageReferenceTable)) {
self::$pageReferenceTable = QFrame_Db_Table::getTable('page_reference');
}
if (!isset(self::$referenceTable)) {
self::$referenceTable = QFrame_Db_Table::getTable('reference');
}
if (!isset(self::$referenceDetailTable)) {
self::$referenceDetailTable = QFrame_Db_Table::getTable('reference_detail');
}
if (!isset(self::$ruleTable)) {
self::$ruleTable = QFrame_Db_Table::getTable('rule');
}
if (!isset(self::$questionTypeTable)) {
self::$questionTypeTable = QFrame_Db_Table::getTable('question_type');
}
if (!isset(self::$questionPromptTable)) {
self::$questionPromptTable = QFrame_Db_Table::getTable('question_prompt');
}
if (!isset(self::$pageTable)) {
self::$pageTable = QFrame_Db_Table::getTable('page');
}
if (!isset(self::$sectionTable)) {
self::$sectionTable = QFrame_Db_Table::getTable('section');
}
if (!isset(self::$questionTable)) {
self::$questionTable = QFrame_Db_Table::getTable('question');
}
if (!isset(self::$questionnaireTable)) {
self::$questionnaireTable = QFrame_Db_Table::getTable('questionnaire');
}
if (!isset(self::$instanceTable)) {
self::$instanceTable = QFrame_Db_Table::getTable('instance');
}
$transactionNumber = self::startSerializableTransaction();
$questionTypeIDCache = array();
// Stores questionTypes that have already been inserted
$rulesMap = array();
// Stores sourceID to questionGUID
$pageGuidMap = array();
// Stores pageGUID to pageID
$sectionGuidMap = array();
// Stores sectionGUID to sectionID
$questionGuidMap = array();
// Stores questionGUID to questionID
$responseObjs = array();
// Stores response objects so that they may be saved at the end
// to ensure all rules and rule targets have been inserted
$fileAttachments = array();
// Stores information for attachments so that attachments may be inserted
// at the end, after the question bulk load is complete
$processedReferences = array();
// Stores references (shortNames) that have already been inserted
// into the reference table
$questionPromptsMap = array();
// Stores question prompts. First key is questionTypeID, second key is
// prompt value, and the value is the promptID.
$questionnaire = $dom->getElementsByTagName('questionnaire')->item(0);
$questionnaireName = $questionnaire->getAttribute('questionnaireName');
$questionnaireVersion = $questionnaire->getAttribute('questionnaireVersion');
$revision = $questionnaire->getAttribute('revision');
// If questionnaireID is already known and passed an argument, use it instead of looking it up
if (isset($options['questionnaireID'])) {
$questionnaireID = $options['questionnaireID'];
} else {
$questionnaireID = self::$questionnaireTable->getQuestionnaireID($questionnaireName, $questionnaireVersion, $revision);
}
if (isset($questionnaireID)) {
$instanceID = self::$instanceTable->getInstanceID($questionnaireID, $instanceName);
if (isset($instanceID)) {
throw new Exception('Instance name already exists for this questionnaire');
}
} else {
throw new Exception('Questionnaire was not found');
}
if (isset($options['instanceID'])) {
$importResponsesInstance = new InstanceModel(array('instanceID' => $options['instanceID']));
$importDom = new DOMDocument();
$importDom->loadXML($importResponsesInstance->toXML());
$importInstanceQuestionsDom = $importDom->getElementsByTagName('question');
for ($q = 0; $q < $importInstanceQuestionsDom->length; $q++) {
$question = $importInstanceQuestionsDom->item($q);
if ($question->getElementsByTagName('questionType') === 'V') {
continue;
}
$responses = $question->getElementsByTagName('responses');
if ($responses->length) {
$resps = $responses->item(0)->getElementsByTagName('response');
for ($r = 0; $r < $resps->length; $r++) {
$response = $resps->item($r);
$additionalInfo = isset($responses->item(0)->getElementsByTagName('additionalInfo')->item(0)->nodeValue) ? $responses->item(0)->getElementsByTagName('additionalInfo')->item(0)->nodeValue : '';
$approverComments = isset($responses->item(0)->getElementsByTagName('approverComments')->item(0)->nodeValue) ? $responses->item(0)->getElementsByTagName('approverComments')->item(0)->nodeValue : '';
$importInstanceResponses[$question->getElementsByTagName('questionGUID')->item(0)->nodeValue][] = array('responseText' => $response->getElementsByTagName('responseText')->item(0)->nodeValue, 'additionalInfo' => $additionalInfo, 'approverComments' => $approverComments);
}
}
}
}
$instanceID = self::$instanceTable->insert(array('questionnaireID' => $questionnaireID, 'instanceName' => $instanceName, 'hidden' => $options['hidden']));
$pages = $questionnaire->getElementsByTagName('page');
for ($t = 0; $t < $pages->length; $t++) {
$page = $pages->item($t);
$pageIDs = self::importXMLPage($page, $questionnaireID, $instanceID, $pageGuidMap);
$pageID = $pageIDs[0];
$pageGUID = $pageIDs[1];
$pageReferences = $page->getElementsByTagName('pageReferences');
self::importXMLReferences('page', $pageReferences, $instanceID, $pageID, null, null, $processedReferences);
$sections = $page->getElementsByTagName('section');
for ($s = 0; $s < $sections->length; $s++) {
$section = $sections->item($s);
$sectionIDs = self::importXMLSection($section, $instanceID, $pageID, $sectionGuidMap);
$sectionID = $sectionIDs[0];
$sectionGUID = $sectionIDs[1];
$sectionReferences = $section->getElementsByTagName('sectionReferences');
self::importXMLReferences('section', $sectionReferences, $instanceID, $pageID, $sectionID, null, $processedReferences);
foreach ($section->getElementsByTagName('questions')->item(0)->childNodes as $question) {
if ($question->nodeName === 'csi:question') {
$questionIDs = self::importXMLQuestion(false, null, $question, $questionnaireID, $instanceID, $pageID, $pageGUID, $sectionID, $sectionGUID, $questionGuidMap, $questionTypeIDCache, $rulesMap, $questionPromptsMap);
$questionID = $questionIDs[0];
$questionGUID = $questionIDs[1];
$questionTypeID = $questionIDs[2];
$questionPrompts = $question->getElementsByTagName('questionPrompt');
$questionReferences = $question->getElementsByTagName('questionReferences');
self::importXMLReferences('question', $questionReferences, $instanceID, $pageID, $sectionID, $questionID, $processedReferences);
$responses = $question->getElementsByTagName('responses');
self::importXMLResponses($responses, $question, $instanceID, $pageID, $sectionID, $questionID, $questionGUID, $questionTypeID, $importInstanceResponses, $questionPrompts, $questionPromptsMap, $responseObjs, $fileAttachments, $options);
} elseif ($question->nodeName === 'csi:questionGroup') {
$questionIDs = self::importXMLQuestion(true, null, $question, $questionnaireID, $instanceID, $pageID, $pageGUID, $sectionID, $sectionGUID, $questionGuidMap, $questionTypeIDCache, $rulesMap, $questionPromptsMap);
$parentQuestionID = $questionIDs[0];
$questionReferences = $question->getElementsByTagName('groupQuestionReferences');
self::importXMLReferences('question', $questionReferences, $instanceID, $pageID, $sectionID, $parentQuestionID, $processedReferences);
if ($options['pageResponses']['all'] || isset($options['pageResponses'][$pageID]) && $options['pageResponses'][$pageID]) {
$attachments = $question->getElementsByTagName('attachment');
$fileAttachments[$parentQuestionID] = $attachments;
}
$childQuestions = $question->getElementsByTagName('question');
for ($cq = 0; $cq < $childQuestions->length; $cq++) {
$question = $childQuestions->item($cq);
$questionIDs = self::importXMLQuestion(false, $parentQuestionID, $question, $questionnaireID, $instanceID, $pageID, $pageGUID, $sectionID, $sectionGUID, $questionGuidMap, $questionTypeIDCache, $rulesMap, $questionPromptsMap);
$questionID = $questionIDs[0];
$questionGUID = $questionIDs[1];
$questionTypeID = $questionIDs[2];
$questionPrompts = $question->getElementsByTagName('questionPrompt');
$questionReferences = $question->getElementsByTagName('questionReferences');
self::importXMLReferences('question', $questionReferences, $instanceID, $pageID, $sectionID, $questionID, $processedReferences);
$responses = $question->getElementsByTagName('responses');
self::importXMLResponses($responses, $question, $instanceID, $pageID, $sectionID, $questionID, $questionGUID, $questionTypeID, $importInstanceResponses, $questionPrompts, $questionPromptsMap, $responseObjs, $fileAttachments, $options);
}
}
}
}
}
self::importXMLRules($questionnaireID, $instanceID, $rulesMap, $pageGuidMap, $sectionGuidMap, $questionGuidMap);
self::$questionTable->processBulk();
self::$sectionTable->processBulk();
self::$pageTable->processBulk();
self::$questionPromptTable->processBulk();
self::$questionTypeTable->processBulk();
self::$ruleTable->processBulk();
self::$referenceTable->processBulk();
self::$referenceDetailTable->processBulk();
self::$questionReferenceTable->processBulk();
self::$sectionReferenceTable->processBulk();
self::$pageReferenceTable->processBulk();
foreach ($responseObjs as $response) {
$response->save();
}
foreach ($fileAttachments as $questionID => $attachments) {
$questionModel = new QuestionModel(array('questionID' => $questionID, 'depth' => 'question'));
self::importXMLAttachments($attachments, $questionModel, $import);
}
$instance = new InstanceModel(array('instanceID' => $instanceID, 'depth' => 'page'));
$instance->save();
self::dbCommit($transactionNumber);
return $instance->instanceID;
}
/**
* Remove a role from a user
*
* @param RoleModel role to remove
*/
public function removeRole(RoleModel $role)
{
if (!isset(self::$assignmentTable)) {
self::$assignmentTable = QFrame_Db_Table::getTable('assignment');
}
$adapter = self::$assignmentTable->getAdapter();
$where = $adapter->quoteInto('dbUserID = ?', intVal($this->dbUserID)) . ' AND ';
$where .= $adapter->quoteInto('roleID = ?', intVal($role->roleID));
self::$assignmentTable->delete($where);
$this->loadRoles();
}
/**
* Loads children questions
*/
public function _loadChildren()
{
$this->children = array();
$rows = QFrame_Db_Table::getTable('question')->fetchRows('parentID', $this->questionID, 'seqNumber', $this->question->pageID);
foreach ($rows as $row) {
$this->children[] = new ModelQuestionModel(array('modelID' => $this->modelID, 'questionID' => $row->questionID, 'depth' => $this->depth, 'instance' => $this->compareInstance));
}
}
/**
* Fetches all object IDs, arranged by objectType, that belong to the given instance
*
* Array returned is of the form:
*
* array {
* ['<objectType>'] => array {
* [<objectID>] => true
* }
* }
*
* @param integer|string instance ID
* @return Array
*/
public static function fetchObjectIdsByInstance($instanceID)
{
if (!isset(self::$attachmentTable)) {
self::$attachmentTable = QFrame_Db_Table::getTable('attachment');
}
$result = array();
// Get all files assocated with this instance ID
$select = self::$attachmentTable->getAdapter()->select()->from(array('a' => 'attachment'), array('objectType', 'objectID'))->where('a.instanceID = ?', $instanceID);
$stmt = self::$attachmentTable->getAdapter()->query($select);
$rows = $stmt->fetchAll();
// Sort files by objectType and add them to the array to be returned
foreach ($rows as $row) {
$result[$row['objectType']][$row['objectID']] = true;
}
return $result;
}
/**
* Imports a Rijndael 256 key
*
* @param string Name of the encryption profile
* @param string Key encoded in base64
* @return CryptoModel
*/
public static function importRijnDael256Key($name, $key)
{
if (!isset(self::$cryptoTable)) {
self::$cryptoTable = QFrame_Db_Table::getTable('crypto');
}
$transactionNumber = self::startSerializableTransaction();
if (self::$cryptoTable->getCryptoID($name) !== NULL) {
throw new Exception('Profile name already exists [' . $name . ']');
}
if (strlen($key) !== 44) {
throw new Exception('Key length must be 44 characters.');
}
$row = self::$cryptoTable->createRow();
$row->name = $name;
$row->cryptoKey = $key;
$row->type = 'RIJNDAEL_256';
$row->save();
self::dbCommit($transactionNumber);
return new CryptoModel(array('name' => $name));
}
public static function preloadPage($instanceID, $pageID)
{
$adapter = Zend_Db_Table_Abstract::getDefaultAdapter();
$tableNames = self::getTables();
foreach ($tableNames as $tableName) {
if (isset(self::$preload[$tableName][$pageID])) {
continue;
}
self::$preload[$tableName][$pageID] = true;
$table = QFrame_Db_Table::getTable($tableName);
if ($tableName === 'model_response') {
continue;
}
// No need to preload this in normal usage
if (isset(self::$primaryKeysFieldTable['pageID'][$tableName]) || isset(self::$discriminatorKeysTableField[$tableName]) && self::$discriminatorKeysTableField[$tableName] === 'pageID') {
if ($tableName === 'section' || $tableName === 'question') {
$table->fetchRows('pageID', $pageID, 'seqNumber');
} else {
$table->fetchRows('pageID', $pageID);
}
}
if (isset(self::$primaryKeysFieldTable['instanceID'][$tableName]) || isset(self::$discriminatorKeysTableField[$tableName]) && self::$discriminatorKeysTableField[$tableName] === 'instanceID') {
if ($tableName === 'page') {
$table->fetchRows('instanceID', $instanceID, 'seqNumber');
} else {
$table->fetchRows('instanceID', $instanceID);
}
}
}
}
