/**
* Get the survey id for this round
*
* @return int
*/
public function getSurvey()
{
if (false !== $this->_survey) {
return $this->_survey;
}
$surveyId = $this->getSurveyId();
if ($surveyId) {
$this->_survey = $this->tracker->getSurvey($surveyId);
} else {
$this->_survey = null;
}
return $this->_survey;
}
/**
* The action where survey sources should return to after survey completion
*/
public function returnAction()
{
if (!$this->_initToken()) {
// In all other cases: the action that generates meaningfull warnings and is reachable for everyone
$this->_forward('forward');
return;
}
if ($url = $this->token->getReturnUrl()) {
// Check for completed tokens
$this->tracker->processCompletedTokens($this->token->getRespondentId(), $this->token->getChangedBy(), $this->token->getOrganizationId());
// Redirect at once, might be another site url
header('Location: ' . $url);
exit;
}
// No return? Check for old style user based return
if (!$this->currentUser->isActive()) {
$this->_forward('forward');
return;
}
// Check for completed tokens
$this->tracker->processCompletedTokens($this->token->getRespondentId(), $this->currentUser->getUserId());
// Get return route parameters
$parameters = $this->currentUser->getSurveyReturn();
if (!$parameters) {
// Default fallback for the fallback
$request = $this->getRequest();
$parameters[$request->getControllerKey()] = 'respondent';
$parameters[$request->getActionKey()] = 'show';
$parameters[\MUtil_Model::REQUEST_ID] = $this->token->getPatientNumber();
}
$this->_reroute($parameters, true);
}
/**
* Set those values needed for editing
*
* @return \Gems\Tracker\Model\FieldMaintenanceModel (continuation pattern)
*/
public function applyEditSettings()
{
$this->applyDetailSettings();
$this->set('gtf_id_field', 'elementClass', 'Hidden');
$this->set('gtf_id_track', 'elementClass', 'Exhibitor');
$this->set('gtf_field_type', 'elementClass', 'Exhibitor');
$this->set('gtf_field_name', 'elementClass', 'Text', 'size', '30', 'minlength', 2, 'required', true, 'validator', $this->createUniqueValidator(array('gtf_field_name', 'gtf_id_track')));
$this->set('gtf_id_order', 'elementClass', 'Text', 'validators[int]', 'Int', 'validators[gt]', new \Zend_Validate_GreaterThan(0), 'validators[unique]', $this->createUniqueValidator(array('gtf_id_order', 'gtf_id_track')));
$this->set('gtf_field_code', 'elementClass', 'Text', 'minlength', 4);
$this->set('gtf_field_description', 'elementClass', 'Text', 'size', 30);
$this->set('gtf_field_values', 'elementClass', 'Hidden');
$this->set('gtf_to_track_info', 'elementClass', 'CheckBox', 'onclick', 'this.form.submit();');
$this->set('gtf_track_info_label', 'elementClass', 'CheckBox', 'required', false);
$this->set('gtf_required', 'elementClass', 'CheckBox');
$this->set('gtf_readonly', 'elementClass', 'CheckBox');
$this->set('gtf_filter_id', 'elementClass', 'Hidden');
$this->set('gtf_min_diff_length', 'elementClass', 'Hidden');
$this->set('gtf_min_diff_unit', 'elementClass', 'Hidden');
$this->set('gtf_max_diff_length', 'elementClass', 'Hidden');
$this->set('gtf_max_diff_unit', 'elementClass', 'Hidden');
$this->set('gtf_after_next', 'elementClass', 'None');
// Deprecatedin 1.7.1
$this->set('gtf_uniqueness', 'elementClass', 'Hidden');
$this->set('gtf_create_track', 'elementClass', 'Hidden');
$this->set('gtf_create_wait_days', 'elementClass', 'Hidden');
$class = 'Model\\Dependency\\FieldTypeChangeableDependency';
$dependency = $this->tracker->createTrackClass($class, $this->_modelField);
$this->addDependency($dependency);
}
/**
* Sets the labels, format functions, etc...
*
* @param boolean $detailed True when shopwing detailed information
* @param boolean $edit When true use edit settings
* @return \Gems_Tracker_Model_TrackModel
*/
public function applyFormatting($detailed = false, $edit = false)
{
$translated = $this->util->getTranslated();
$translator = $this->getTranslateAdapter();
if ($edit) {
$dateFormat = \MUtil_Model_Bridge_FormBridge::getFixedOption('date', 'dateFormat');
} else {
$dateFormat = $translated->dateFormatString;
}
$this->resetOrder();
$this->set('gtr_track_name', 'label', $translator->_('Name'));
$this->set('gtr_track_class', 'label', $translator->_('Track Engine'), 'multiOptions', $this->tracker->getTrackEngineList($detailed));
$this->set('gtr_survey_rounds', 'label', $translator->_('Surveys'));
$this->set('gtr_active', 'label', $translator->_('Active'), 'multiOptions', $translated->getYesNo());
$this->set('gtr_date_start', 'label', $translator->_('From'), 'dateFormat', $dateFormat, 'formatFunction', $translated->formatDate);
$this->set('gtr_date_until', 'label', $translator->_('Use until'), 'dateFormat', $dateFormat, 'formatFunction', $translated->formatDateForever);
$this->setIfExists('gtr_code', 'label', $translator->_('Track code'), 'size', 10, 'description', $translator->_('Optional code name to link the track to program code.'));
if ($detailed) {
$events = $this->loader->getEvents();
$caList = $events->listTrackCalculationEvents();
if (count($caList) > 1) {
$this->setIfExists('gtr_calculation_event', 'label', $translator->_('Before (re)calculation'), 'multiOptions', $caList);
}
$coList = $events->listTrackCompletionEvents();
if (count($coList) > 1) {
$this->setIfExists('gtr_completed_event', 'label', $translator->_('After completion'), 'multiOptions', $coList);
}
$bfuList = $events->listTrackBeforeFieldUpdateEvents();
if (count($bfuList) > 1) {
$this->setIfExists('gtr_beforefieldupdate_event', 'label', $translator->_('Before field update'), 'multiOptions', $bfuList);
}
$fuList = $events->listTrackFieldUpdateEvents();
if (count($fuList) > 1) {
$this->setIfExists('gtr_fieldupdate_event', 'label', $translator->_('After field update'), 'multiOptions', $fuList);
}
$this->setIfExists('gtr_organizations', 'label', $translator->_('Organizations'), 'elementClass', 'MultiCheckbox', 'multiOptions', $this->util->getDbLookup()->getOrganizationsWithRespondents(), 'required', true);
$ct = new \MUtil_Model_Type_ConcatenatedRow('|', $translator->_(', '));
$ct->apply($this, 'gtr_organizations');
}
if ($edit) {
$this->set('toggleOrg', 'elementClass', 'ToggleCheckboxes', 'selectorName', 'gtr_organizations');
$this->set('gtr_track_name', 'minlength', 4, 'size', 30, 'validators[unique]', $this->createUniqueValidator('gtr_track_name'));
}
return $this;
}
/**
* Returns/sets a password element.
*
* @return \Zend_Form_Element_Password
*/
public function getTokenElement()
{
$element = $this->getElement($this->_tokenFieldName);
if (!$element) {
$tokenLib = $this->tracker->getTokenLibrary();
$max_length = $tokenLib->getLength();
// Veld token
$element = new \Zend_Form_Element_Text($this->_tokenFieldName);
$element->setLabel($this->translate->_('Token'));
$element->setDescription(sprintf($this->translate->_('Enter tokens as %s.'), $tokenLib->getFormat()));
$element->setAttrib('size', $max_length + 2);
$element->setAttrib('maxlength', $max_length);
$element->setRequired(true);
$element->addFilter($this->tracker->getTokenFilter());
$element->addValidator($this->tracker->getTokenValidator());
$this->addElement($element);
}
return $element;
}
/**
*
* @return \Gems_Tracker_Source_SourceInterface
*/
public function getSource()
{
if (!$this->_source && isset($this->_gemsSurvey['gsu_id_source']) && $this->_gemsSurvey['gsu_id_source']) {
$this->_source = $this->tracker->getSource($this->_gemsSurvey['gsu_id_source']);
if (!$this->_source) {
throw new \Gems_Exception('No source for exists for source ' . $this->_gemsSurvey['gsu_id_source'] . '.');
}
}
return $this->_source;
}
/**
* Updates the gems__tokens table so all tokens stick to the (possibly) new token name rules.
*
* @param int $userId Id of the user who takes the action (for logging)
* @return int The number of tokens changed
*/
protected function updateTokens($userId, $updateTokens = true)
{
$tokenLib = $this->tracker->getTokenLibrary();
$sql = 'UPDATE gems__tokens
SET gto_id_token = ' . $this->_getTokenFromToSql($tokenLib->getFrom(), $tokenLib->getTo(), 'gto_id_token') . ',
gto_changed = CURRENT_TIMESTAMP,
gto_changed_by = ' . $this->_gemsDb->quote($userId) . '
WHERE ' . $this->_getTokenFromSqlWhere($tokenLib->getFrom(), 'gto_id_token') . ' AND
gto_id_survey IN (SELECT gsu_id_survey FROM gems__surveys WHERE gsu_id_source = ' . $this->_gemsDb->quote($this->getId()) . ')';
return $this->_gemsDb->query($sql)->rowCount();
}
/**
* This transform function is called before the saving of the data in the source model and allows you to
* change all data.
*
* @param \MUtil_Model_ModelAbstract $model The parent model
* @param array $row Array containing row
* @return array Row array containing (optionally) transformed data
*/
public function transformRowBeforeSave(\MUtil_Model_ModelAbstract $model, array $row)
{
if (!$this->tracker) {
$this->tracker = $this->loader->getTracker();
}
if (isset($row[$this->respTrackIdField]) && $row[$this->respTrackIdField]) {
$respTrack = $this->tracker->getRespondentTrack($row[$this->respTrackIdField]);
$fields = $respTrack->processFieldsBeforeSave($row);
$row['gr2t_track_info'] = $this->fieldsDefinition->calculateFieldsInfo($fields);
// Also save the calculated fields into the row (actual save is in transformRowAfterSave)
return $fields + $row;
}
return $row;
}
/**
* Load the settings for the survey
*/
protected function loadTrackSettings()
{
$respTracks = $this->tracker->getRespondentTracks($this->formData['gto_id_respondent'], $this->formData['gto_id_organization']);
$tracks = array();
foreach ($respTracks as $respTrack) {
if ($respTrack instanceof \Gems_Tracker_RespondentTrack) {
if ($respTrack->hasSuccesCode()) {
$tracks[$respTrack->getRespondentTrackId()] = substr(sprintf($this->_('%s - %s'), $respTrack->getTrackEngine()->getTrackName(), $respTrack->getFieldsInfo()), 0, 100);
}
}
}
if ($tracks) {
if (!isset($this->formData['gto_id_track'])) {
reset($tracks);
$this->formData['gto_id_track'] = key($tracks);
}
} else {
$this->addMessageInvalid($this->_('Survey insertion impossible: respondent has no track!'));
$tracks = $this->util->getTranslated()->getEmptyDropdownArray();
}
asort($tracks);
$model = $this->getModel();
$model->set('gto_id_track', 'multiOptions', $tracks);
if (count($tracks) === 1) {
$model->set('gto_id_track', 'elementClass', 'Exhibitor');
}
if (isset($this->formData['gto_id_track'])) {
$this->respondentTrack = $respTracks[$this->formData['gto_id_track']];
// Add relation field when survey is not for staff
if ($this->survey && $this->survey->isTakenByStaff() === false) {
$engine = $this->respondentTrack->getTrackEngine();
if (method_exists($engine, 'getRespondentRelationFields')) {
$empty = array('-1' => $this->_('Patient'));
$relations = $empty + $engine->getRespondentRelationFields();
$model->set('gto_id_relationfield', 'label', $this->_('Fill out by'), 'multiOptions', $relations, 'elementClass', 'Select', 'required', true);
}
}
}
}
/**
* Returns a model that can be used to save, edit, etc. the token
*
* @return \Gems_Tracker_Model_StandardTokenModel
*/
public function getTokenModel()
{
return $this->tracker->getTokenModel();
}
/**
* Refreshes the tokens in the source
*
* @param string $batch_id A unique identifier for the current batch
* @param string $cond An optional where statement
* @return \Gems_Task_TaskRunnerBatch A batch to process the changes
*/
public function refreshTokenAttributes($batch_id, $cond = null)
{
$batch = $this->loader->getTaskRunnerBatch($batch_id);
if (!$batch->isLoaded()) {
$tokenSelect = $this->getTokenSelect(array('gto_id_token'));
$tokenSelect->andSurveys(array())->forWhere('gsu_surveyor_active = 1')->forWhere('gto_in_source = 1');
if ($cond) {
// Add all connections for filtering, but select only surveys that are active in the source
$tokenSelect->andReceptionCodes(array())->andRespondents(array())->andRespondentOrganizations(array())->andConsents(array())->forWhere($cond);
}
foreach ($this->db->fetchCol($tokenSelect->getSelect()) as $token) {
$batch->addTask('Tracker_RefreshTokenAttributes', $token);
}
}
self::$verbose = true;
return $batch;
}
/**
* Returns a model that can be used to retrieve or save the field definitions for the track editor.
*
* @param boolean $detailed Create a model for the display of detailed item data or just a browse table
* @param string $action The current action
* @return \Gems\Tracker\Model\FieldMaintenanceModel
*/
public function getMaintenanceModel($detailed = false, $action = 'index')
{
if (isset($this->_maintenanceModels[$action])) {
return $this->_maintenanceModels[$action];
}
$model = $this->tracker->createTrackClass('Model\\FieldMaintenanceModel');
if ($detailed) {
if ('edit' === $action || 'create' === $action) {
$model->applyEditSettings();
if ('create' === $action) {
$model->set('gtf_id_track', 'default', $this->_trackId);
// Set the default round order
// Load last row
$row = $model->loadFirst(array('gtf_id_track' => $this->_trackId), array('gtf_id_order' => SORT_DESC), false);
if ($row && isset($row['gtf_id_order'])) {
$newOrder = $row['gtf_id_order'] + 10;
$model->set('gtf_id_order', 'default', $newOrder);
}
}
} else {
$model->applyDetailSettings();
}
} else {
$model->applyBrowseSettings();
}
$this->_maintenanceModels[$action] = $model;
return $model;
}
/**
*
* @param mixed $token
* @param int $userId The current user
* @return int The number of tokens changed by this event
*/
public function handleRoundCompletion($token, $userId)
{
if (!$token instanceof \Gems_Tracker_Token) {
$token = $this->tracker->getToken($token);
}
// \MUtil_Echo::track($token->getRawAnswers());
// Store the current token as startpoint if it is the first changed token
if ($this->_checkStart) {
if ($this->_checkStart->getRoundId() > $token->getRoundId()) {
// Replace current token
$this->_checkStart = $token;
}
} else {
$this->_checkStart = $token;
}
// Process any events
if ($event = $this->getTrackEngine()->getRoundChangedEvent($token->getRoundId())) {
return $event->processChangedRound($token, $this, $userId);
}
return 0;
}
/**
*
* @param array $gemsData Optional, the data refresh with, otherwise refresh from database.
* @return \Gems_Tracker_Token (continuation pattern)
*/
public function refresh(array $gemsData = null)
{
if (is_array($gemsData)) {
$this->_gemsData = $gemsData + $this->_gemsData;
} else {
$tokenSelect = $this->tracker->getTokenSelect();
$tokenSelect->andReceptionCodes()->andRespondents()->andRespondentOrganizations()->andConsents()->forTokenId($this->_tokenId);
$this->_gemsData = $tokenSelect->fetchRow();
if (false == $this->_gemsData) {
// on failure, reset to empty array
$this->_gemsData = array();
}
}
$this->exists = isset($this->_gemsData['gto_id_token']);
return $this;
}
/**
* This tests if the public property exists is set correctly
*
* @dataProvider providerTokenData
*/
public function testTokenExists($tokenData, $exists)
{
$token = $this->tracker->getToken($tokenData);
$this->assertEquals($exists, $token->exists);
}
