/**
* 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');
}
}
/**
* Refresh all questionnaire signatures
*/
private function refreshSignatures()
{
$this->auth();
$questionnaires = QuestionnaireModel::getAllQuestionnaires();
foreach ($questionnaires as $questionnaire) {
$questionnaire->refreshSignature();
}
QFrame_Db_Table::reset('questionnaire');
}
public function insert(array $data)
{
$info = $this->info();
$instanceNameLength = $info['metadata']['instanceName']['LENGTH'];
if (strlen($data['instanceName']) > $instanceNameLength) {
throw new Exception("Instance name must not be longer than {$instanceNameLength} characters");
}
return parent::insert($data);
}
public function up()
{
// reset db metadata cache
QFrame_Db_Table::scanDb();
QFrame_Db_Table::resetAll();
$this->auth();
$xml = file_get_contents(_path(PROJECT_PATH, 'xml', 'sig-4-0-questionnaire-definition.xml'));
QuestionnaireModel::importXML($xml);
InstanceModel::importXML($xml, 'Sample SIG Instance');
}
public function up()
{
$this->createTable('db_user', array('primary' => 'dbUserID'), array(array('dbUserID', 'integer'), array('dbUserName', 'string', array('limit' => 20)), array('dbUserPW', 'string', array('limit' => 50)), array('dbUserFullName', 'string', array('limit' => 50, 'null' => true)), array('dbUserActive', 'string', array('limit' => 1, 'default' => 'Y')), array('ACLstring', 'text', array('null' => true, 'limit' => '1M'))));
$this->createIndex('db_user', array('dbUserName'));
// reset db metadata cache
QFrame_Db_Table::scanDb();
// create some default data
$admin = new DbUserModel(array('dbUserName' => 'admin', 'dbUserPW' => 'admin', 'dbUserFullName' => 'Administrator'));
$admin->save();
$user = new DbUserModel(array('dbUserName' => 'user', 'dbUserPW' => 'user', 'dbUserFullName' => 'User'));
$user->save();
}
public function up()
{
$this->createTable('role', array('primary' => 'roleID'), array(array('roleID', 'integer'), array('roleDescription', 'string', array('limit' => 128, 'null' => true)), array('ACLstring', 'text', array('null' => true, 'limit' => '1M'))));
$this->createTable('assignment', array('primary' => 'assignmentID'), array(array('dbUserID', 'integer'), array('roleID', 'integer'), array('assignmentID', 'integer'), array('comments', 'text', array('null' => true))));
$this->createIndex('assignment', array('dbUserID', 'roleID'));
// reset db metadata cache
QFrame_Db_Table::scanDb();
// give the admin user full global rights
$adminRole = RoleModel::create(array('roleDescription' => 'Administrators'));
$adminRole->grant('view');
$adminRole->grant('edit');
$adminRole->grant('approve');
$adminRole->grant('administer');
$adminRole->save();
DbUserModel::findByUsername('admin')->addRole($adminRole)->save();
}
public function up()
{
// add the column
$this->addColumn('instance', 'hidden', 'boolean', array('default' => 0));
// reset db metadata cache
QFrame_Db_Table::scanDb();
QFrame_Db_Table::resetAll();
// make sure that existing questionnaires have a default instance (and create one if not)
$this->auth();
foreach (QuestionnaireModel::getAllQuestionnaires('instance') as $questionnaire) {
$default = $questionnaire->getDefaultInstance();
if ($default === null) {
$xml = $questionnaire->fetchQuestionnaireDefinition();
InstanceModel::importXML($xml, '_default_', array('hidden' => 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();
}
}
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;
}
}
function runTests($tree, $branches)
{
$pid = pcntl_fork();
if ($pid != 0) {
pcntl_waitpid($pid, $status);
$failures = file_get_contents(PROJECT_PATH . '/tmp/.autotest');
return intval($failures);
}
/*
* Prepare the database...
*/
require _path(CORE_PATH, 'database.php');
$db = Zend_Db_Table_Abstract::getDefaultAdapter();
foreach (QFrame_Db_Table::getTables() as $table) {
$db->getConnection()->exec("TRUNCATE TABLE {$table}");
}
if (is_array($branches)) {
$tests = array();
$suite_name = implode(' && ', $branches);
foreach ($branches as $branch) {
$tests = array_merge($tests, collectBranchTests($tree, $branch));
}
$tests = array_unique($tests);
if (count($tests) <= 0) {
return;
}
} elseif ($branches == 'all') {
$suite_name = 'all';
$tests = collectAllTests($tree);
}
$suite = new PHPUnit_Framework_TestSuite($suite_name);
foreach ($tests as $test) {
require_once TEST_PATH . '/unit/' . $test;
$class_name = preg_replace('/\\.php$/', '', $test);
$suite_name = preg_replace('/^' . preg_quote(PROJECT_PATH . '/', '/') . '|\\.php$/', '', 'IGNORE');
$suite->addTestSuite(new PHPUnit_Framework_TestSuite('Test_Unit_' . $class_name, $suite_name));
}
$result = new PHPUnit_Framework_TestResult();
$result->addListener(new QFrame_Test_Listener());
$suite->run($result);
file_put_contents(PROJECT_PATH . '/tmp/.autotest', count($result->failures()));
exit;
}
/**
* 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();
}
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;
}
/**
* 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;
}
/**
* Loads Model Sections
*/
private function _loadModelSections()
{
// Load up table data in bulk to limit sql queries
QFrame_Db_Table::preloadPage($this->page->instanceID, $this->page->pageID);
$rows = self::$sectionTable->fetchRows('pageID', $this->page->pageID, 'seqNumber', $this->page->pageID);
foreach ($rows as $row) {
$this->modelSections[] = new ModelSectionModel(array('modelID' => $this->modelID, 'sectionID' => $row->sectionID, 'depth' => $this->depth, 'instance' => $this->compareInstance));
}
}
private function _loadSections()
{
// Load up table data in bulk to limit sql queries
QFrame_Db_Table::preloadPage($this->pageRow->instanceID, $this->pageRow->pageID);
$rows = self::$sectionTable->fetchRows('pageID', $this->pageRow->pageID, 'seqNumber', $this->pageRow->pageID);
$this->sections = array();
foreach ($rows as $row) {
$this->sections[] = new SectionModel(array('sectionID' => $row->sectionID, 'depth' => $this->depth));
}
return 1;
}
private function resetDatabase()
{
$db = Zend_Db_Table_Abstract::getDefaultAdapter();
foreach (QFrame_Db_Table::getTables() as $table) {
$db->getConnection()->exec("TRUNCATE TABLE " . $table);
QFrame_Db_Table::reset($table);
}
}
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 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));
}
/**
* 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']);
}
/**
* 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));
}
}
public function testDeletingRemovesHiddenInstances()
{
$this->auth();
$xml = file_get_contents(PROJECT_PATH . "/test/data/xml/test1-questionnaire-definition.xml");
QuestionnaireModel::importXML($xml);
$questionnaire = new QuestionnaireModel(array('questionnaireName' => 'Test1 Questionnaire', 'questionnaireVersion' => '3.00', 'revision' => 1, 'depth' => 'instance'));
$instanceID = $questionnaire->getDefaultInstance()->instanceID;
$questionnaire->delete();
QFrame_Db_Table::resetAll();
try {
new InstanceModel(array('instanceID' => $instanceID));
} catch (Exception $e) {
$this->assertTrue(preg_match('/^Instance not found/', $e->getMessage()) > 0);
return;
}
$this->fail('Fetching hidden instance after questionnaire deletion should throw an exception');
}
/**
* Helper function for importXML. Logic specifically for rules.
*
* @param See importXML.
*/
private static function importXMLRules($questionnaireID, $instanceID, &$rulesMap, &$pageGuidMap, &$sectionGuidMap, &$questionGuidMap)
{
foreach ($rulesMap as $questionPromptID => $questionPromptIDArray) {
foreach ($questionPromptIDArray as $name => $nameArray) {
foreach ($nameArray as $targetGUID) {
if ($name === 'enableQuestion') {
$questionID = $questionGuidMap[$targetGUID];
if (!isset($questionID)) {
throw new Exception("questionGUID referenced in XML Questionnaire Definition does not exist: {$targetID}");
}
$ruleID = self::$ruleTable->insertBulk(array('questionnaireID' => $questionnaireID, 'instanceID' => $instanceID, 'sourceID' => $questionPromptID, 'targetID' => $questionID, 'targetGUID' => $targetGUID, 'type' => $name, 'enabled' => 'N'));
} elseif ($name === 'enableSection') {
$sectionID = $sectionGuidMap[$targetGUID];
if (!isset($sectionID)) {
throw new Exception("sectionGUID referenced in XML Questionnaire Definition does not exist: {$targetID}");
}
$ruleID = self::$ruleTable->insertBulk(array('questionnaireID' => $questionnaireID, 'instanceID' => $instanceID, 'sourceID' => $questionPromptID, 'targetID' => $sectionID, 'targetGUID' => $targetGUID, 'type' => $name, 'enabled' => 'N'));
} elseif ($name === 'enablePage') {
$pageID = $pageGuidMap[$targetGUID];
if (!isset($pageID)) {
throw new Exception("pageGUID referenced in XML Questionnaire Definition does not exist: {$targetID}");
}
$ruleID = self::$ruleTable->insertBulk(array('questionnaireID' => $questionnaireID, 'instanceID' => $instanceID, 'sourceID' => $questionPromptID, 'targetID' => $pageID, 'targetGUID' => $targetGUID, 'type' => $name, 'enabled' => 'N'));
} elseif ($name === 'disableQuestion') {
$questionID = $questionGuidMap[$targetGUID];
if (!isset($questionID)) {
throw new Exception("questionGUID referenced in XML Questionnaire Definition does not exist: {$targetID}");
}
$ruleID = self::$ruleTable->insertBulk(array('questionnaireID' => $questionnaireID, 'instanceID' => $instanceID, 'sourceID' => $questionPromptID, 'targetID' => $questionID, 'targetGUID' => $targetGUID, 'type' => $name, 'enabled' => 'N'));
} elseif ($name === 'disableSection') {
$sectionID = $sectionGuidMap[$targetGUID];
if (!isset($sectionID)) {
throw new Exception("sectionGUID referenced in XML Questionnaire Definition does not exist: {$targetID}");
}
$ruleID = self::$ruleTable->insertBulk(array('questionnaireID' => $questionnaireID, 'instanceID' => $instanceID, 'sourceID' => $questionPromptID, 'targetID' => $sectionID, 'targetGUID' => $targetGUID, 'type' => $name, 'enabled' => 'N'));
} elseif ($name === 'disablePage') {
$pageID = $pageGuidMap[$targetGUID];
if (!isset($pageID)) {
throw new Exception("pageGUID referenced in XML Questionnaire Definition does not exist: {$targetID}");
}
$ruleID = self::$ruleTable->insertBulk(array('questionnaireID' => $questionnaireID, 'instanceID' => $instanceID, 'sourceID' => $questionPromptID, 'targetID' => $pageID, 'targetGUID' => $targetGUID, 'type' => $name, 'enabled' => 'N'));
}
}
}
}
// reset table cache as there are now new rules
QFrame_Db_Table::reset('rules');
}
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);
}
}
}
}
