public function down()
{
$this->auth();
try {
$instance = new InstanceModel(array('questionnaireName' => 'CSI SIG', 'questionnaireVersion' => '4.0', 'revision' => '2', 'instanceName' => 'Sample SIG Instance'));
$questionnaire = $instance->parent;
$instance->delete();
$questionnaire->delete();
} catch (Exception $e) {
}
}
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));
}
}
}
public function testEncryptedZipArchiveExportCanBeImported()
{
$this->auth();
$crypto = CryptoModel::importRijndael256Key('testdupe', 'BqPwhnSskTFzxPUlljXG1zgG8cfgTSaGj8UyRWsKanA=');
$instance = new InstanceModel(array('instanceID' => 1));
$zip = new ZipArchiveModel($instance, array('new' => '1'));
$zip->addInstanceFullResponsesXMLDocument();
$zip->close();
$encrypted = $crypto->encrypt($zip->getZipFileContents());
$zip->deleteZipFile();
$decrypted = $crypto->decrypt($encrypted);
$tempfile = tempnam(PROJECT_PATH . DIRECTORY_SEPARATOR . 'tmp', 'zip');
unlink($tempfile);
file_put_contents($tempfile, $decrypted);
$zip = new ZipArchiveModel(null, array('filename' => $tempfile));
InstanceModel::importXML($zip, 'test encryption import');
$zip->deleteZipFile();
}
public function approveSaveAction()
{
try {
if ($this->_hasParam('approvals')) {
$page = new PageModel(array('pageID' => $this->_getParam('id'), 'depth' => 'response'));
$comments = $this->_getParam('comments');
foreach ($this->_getParam('approvals') as $questionID => $state) {
$question = $page->getQuestion(intval($questionID));
if ($question === null) {
throw new Exception('Invalid attempt to approve a non-existent question or question on another page');
}
$response = $question->getResponse();
if ($response->requiresAdditionalInfo() && !$response->hasAdditionalInfo()) {
throw new Exception('Invalid attempt to approve a response that requires additional information with none provided');
}
$response->state = intval($state);
if (array_key_exists($questionID, $comments)) {
if ($comments[$questionID] === '') {
$response->approverComments = null;
} else {
$response->approverComments = $comments[$questionID];
}
}
$response->save();
foreach ($question->children as $child) {
$response = $child->getResponse();
$response->state = intval($state);
$response->save();
}
}
$page->save();
$instance = new InstanceModel(array('instanceID' => $page->instanceID, 'depth' => 'page'));
$instance->save();
}
} catch (Exception $e) {
$this->view->error = $e->getMessage();
}
$this->view->setRenderLayout(false);
}
/**
* Generates a signature for an questionnaire definition
*
* @param questionnaire definition xml dom object
* @return string md5 hash
*/
public static function generateSignature($dom)
{
$questionnaireID = QuestionnaireModel::importXML($dom, array('SkipQuestionnaireExistCheck' => 1, 'SkipFileAttachments' => 1));
$instanceID = InstanceModel::importXML($dom, '_generateSignature', array('questionnaireID' => $questionnaireID));
$instance = new InstanceModel(array('instanceID' => $instanceID, 'depth' => 'instance'));
$questionnaire = new QuestionnaireModel(array('questionnaireID' => $questionnaireID, 'depth' => 'questionnaire'));
$signature = md5($instance->toXML(1));
$instance->delete();
$questionnaire->delete();
return $signature;
}
/**
* 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;
}
public function testNoResponsesInstanceWithMergedResponsesExportEqualsResponsesInstanceExport()
{
$this->auth();
$xml = file_get_contents(PROJECT_PATH . "/test/data/xml/responses-questionnaire-definition.xml");
QuestionnaireModel::importXML($xml);
InstanceModel::importXML($xml, 'Test1 Resp. Company', array('pageResponses' => array('all' => 1)));
$instance1 = new InstanceModel(array('questionnaireName' => 'Test1 Questionnaire', 'questionnaireVersion' => '3.00', 'revision' => 1, 'instanceName' => 'Test1 Resp. Company'));
$xml = file_get_contents(PROJECT_PATH . "/test/data/xml/no-responses-questionnaire-definition.xml");
InstanceModel::importXML($xml, 'Test1 Company', array('instanceID' => $instance1->instanceID));
$instance2 = new InstanceModel(array('questionnaireName' => 'Test1 Questionnaire', 'questionnaireVersion' => '3.00', 'revision' => 1, 'instanceName' => 'Test1 Company'));
$xml1 = $instance1->toXML(1);
$xml2 = $instance2->toXML(1);
$xml1 = preg_replace("/Test1 Resp. Company/", "Test1 Company", $xml1);
$xml1 = preg_replace("/<csi:responseDate>.+<\\/csi:responseDate>/", "", $xml1);
$xml2 = preg_replace("/<csi:responseDate>.+<\\/csi:responseDate>/", "", $xml2);
$this->assertEquals($xml1, $xml2);
}
/**
* Adds all attachments associated with the instance to the zip archive
*/
public function addAttachments()
{
$attachmentQuestions = FileModel::fetchObjectIdsByInstance($this->instance->instanceID);
$instance = new InstanceModel(array('instanceID' => $this->instance->instanceID, 'depth' => 'question'));
while ($page = $instance->nextPage()) {
while ($section = $page->nextSection()) {
while ($question = $section->nextQuestion()) {
if (isset($attachmentQuestions['QuestionModel'][$question->questionID])) {
$fileObj = new FileModel($question);
$ids = $fileObj->fetchAll();
if ($ids === NULL) {
continue;
}
foreach ($ids as $id) {
$file = $fileObj->fetchWithProperties($id);
$this->addFromString("files/{$id}", $file['contents']);
}
}
}
}
}
}
public function PdfDownloadAction()
{
$session = new Zend_Session_Namespace('login');
$cryptoID = $this->_hasParam('cryptoID') ? $this->_getParam('cryptoID') : null;
$pageHeadersAll = $this->_hasParam('pageHeader') ? $this->_getParam('pageHeader') : array();
$pageHeaders = array();
while (list($key, $val) = each($pageHeadersAll)) {
if (isset($val[pdf]) && $val[pdf] == 1) {
$pageHeaders[] = $key;
}
}
if ($this->_hasParam('download') && isset($session->tempFile)) {
if (isset($cryptoID) && $cryptoID != 0) {
$this->view->cryptoID = $cryptoID;
}
$this->view->pdf = file_get_contents($session->tempFile);
unlink($session->tempFile);
unset($session->tempFile);
} else {
$instance = new InstanceModel(array('instanceID' => $session->dataInstanceID, 'depth' => 'instance'));
$html = $instance->xml2html($pageHeaders);
$dompdf = new DOMPDF();
$dompdf->load_html($html);
$dompdf->render();
$pdf = $dompdf->output();
if (isset($cryptoID) && $cryptoID != 0) {
$crypto = new CryptoModel(array('cryptoID' => $cryptoID));
$pdf = $crypto->encrypt($pdf);
$this->view->cryptoID = $cryptoID;
}
$tempFile = tempnam(PROJECT_PATH . DIRECTORY_SEPARATOR . 'tmp', 'exp');
file_put_contents($tempFile, $pdf);
$session->tempFile = $tempFile;
}
$this->view->setRenderLayout(false);
}
$core_path = _path(dirname(__FILE__), '..', 'core');
/*
* Set up a bunch of path constants that the application will use to refer
* to various application directories
*/
include _path(dirname(__FILE__), '..', 'core', 'paths.php');
/*
* Deal with environment stuff including determining the current environment
* and loading the configuration stuff for that environment
*/
include _path(CORE_PATH, 'env.php');
/*
* Include file that contains pure configuration (used for testing)
* as well as routing. Also include the file that sets up database
* "stuff".
*/
include _path(CORE_PATH, 'database.php');
/*
* Set up any dynamic properties (properties that rely on current environment configuration)
*/
include _path($core_path, 'dynamic.php');
// perform mock authentication
$auth_adapter = new QFrame_Auth_Adapter('', '', true);
$auth = Zend_Auth::getInstance();
$auth->authenticate($auth_adapter);
$content = file_get_contents(_path(PROJECT_PATH, 'xml', 'sig-4-0-questionnaire-definition.xml'));
QuestionnaireModel::importXML($content);
$options['pageResponses']['all'] = 1;
// import all responses
InstanceModel::importXML($content, 'Acme Vendor', $options);
