/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task * * @param array $trackData Nested array of trackdata */ public function execute($lineNr = null, $fieldData = null) { $batch = $this->getBatch(); $import = $batch->getVariable('import'); if (isset($fieldData['gtf_id_order']) && $fieldData['gtf_id_order']) { $import['fieldOrder'][$fieldData['gtf_id_order']] = false; if ($batch->hasVariable('trackEngine') && isset($fieldData['gtf_field_type']) && $fieldData['gtf_field_type']) { $trackEngine = $batch->getVariable('trackEngine'); if ($trackEngine instanceof \Gems_Tracker_Engine_TrackEngineInterface) { $fieldDef = $trackEngine->getFieldsDefinition(); $field = $fieldDef->getFieldByOrder($fieldData['gtf_id_order']); if ($field instanceof FieldInterface) { if ($field->getFieldType() != $fieldData['gtf_field_type']) { $batch->addToCounter('import_errors'); $batch->addMessage(sprintf($this->_('Conflicting field types "%s" and "%s" for field orders %d specified on line %d.'), $field->getFieldType(), $fieldData['gtf_field_type'], $fieldData['gtf_id_order'], $lineNr)); } } } } } else { $batch->addToCounter('import_errors'); $batch->addMessage(sprintf($this->_('No gtf_id_order specified for field at line %d.'), $lineNr)); } if (isset($fieldData['gtf_field_type']) && $fieldData['gtf_field_type']) { $model = $this->loader->getTracker()->createTrackClass('Model\\FieldMaintenanceModel'); $fields = $model->getFieldTypes(); if (!isset($fields[$fieldData['gtf_field_type']])) { $batch->addToCounter('import_errors'); $batch->addMessage(sprintf($this->_('Unknown field type "%s" specified on line %d.'), $fieldData['gtf_field_type'], $lineNr)); } } else { $batch->addToCounter('import_errors'); $batch->addMessage(sprintf($this->_('No field type specified on line %d.'), $lineNr)); } }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task * * @param array $trackData Nested array of trackdata */ public function execute($formData = null) { $batch = $this->getBatch(); $import = $batch->getVariable('import'); $tracker = $this->loader->getTracker(); $model = $tracker->getTrackModel(); $model->applyFormatting(true, true); $trackData = $import['trackData']; $trackData['gtr_track_name'] = $formData['gtr_track_name']; $trackData['gtr_organizations'] = $formData['gtr_organizations']; if ($batch->hasVariable('trackEngine')) { $trackEngine = $batch->getVariable('trackEngine'); if ($trackEngine instanceof \Gems_Tracker_Engine_TrackEngineInterface) { $trackData['gtr_id_track'] = $trackEngine->getTrackId(); } } // \MUtil_Echo::track($trackData); if ($trackData['gtr_date_start'] && !$trackData['gtr_date_start'] instanceof \Zend_Date) { $trackData['gtr_date_start'] = new \MUtil_Date($trackData['gtr_date_start'], 'yyyy-MM-dd'); } $output = $model->save($trackData); $import['trackId'] = $output['gtr_id_track']; $import['trackData']['gtr_id_track'] = $output['gtr_id_track']; $batch->addMessage($this->_('Merged track data')); }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute($lineNr = null, $roundData = null) { $batch = $this->getBatch(); $import = $batch->getVariable('import'); if (!(isset($import['trackId']) && $import['trackId'])) { // Do nothing return; } // Only save when export code is known and set if (!isset($roundData['survey_export_code'], $import['surveyCodes'][$roundData['survey_export_code']])) { // Do nothing, no survey export code or no known export code return; } if (!$import['surveyCodes'][$roundData['survey_export_code']]) { // Export code not set to skip import of round return; } $fieldCodes = $import['fieldCodes']; $roundOrders = isset($import['roundOrders']) ? $import['roundOrders'] : array(); $tracker = $this->loader->getTracker(); $trackEngine = $tracker->getTrackEngine($import['trackId']); $model = $trackEngine->getRoundModel(true, 'create'); $roundData['gro_id_track'] = $import['trackId']; $roundData['gro_id_survey'] = $import['surveyCodes'][$roundData['survey_export_code']]; if (isset($roundData['valid_after']) && $roundData['valid_after']) { if (isset($roundOrders[$roundData['valid_after']]) && $roundOrders[$roundData['valid_after']]) { $roundData['gro_valid_after_id'] = $roundOrders[$roundData['valid_after']]; } else { $batch->addTask('Tracker\\Import\\UpdateRoundValidTask', $lineNr, $roundData['gro_id_order'], $roundData['valid_after'], 'gro_valid_after_id'); } } if (isset($roundData['gro_valid_after_source'], $fieldData['gro_valid_after_field'])) { switch ($roundData['gro_valid_after_source']) { case self::APPOINTMENT_TABLE: case self::RESPONDENT_TRACK_TABLE: if (isset($fieldCodes[$fieldData['gro_valid_after_field']])) { $fieldData['gro_valid_after_field'] = $fieldCodes[$fieldData['gro_valid_after_field']]; } } } if (isset($roundData['valid_for']) && $roundData['valid_for']) { if (isset($roundOrders[$roundData['valid_for']]) && $roundOrders[$roundData['valid_for']]) { $roundData['gro_valid_for_id'] = $roundOrders[$roundData['valid_for']]; } else { $batch->addTask('Tracker\\Import\\UpdateRoundValidTask', $lineNr, $roundData['gro_id_order'], $roundData['valid_for'], 'gro_valid_for_id'); } } if (isset($roundData['gro_valid_for_source'], $fieldData['gro_valid_for_field'])) { switch ($roundData['gro_valid_for_source']) { case self::APPOINTMENT_TABLE: case self::RESPONDENT_TRACK_TABLE: if (isset($fieldCodes[$fieldData['gro_valid_for_field']])) { $fieldData['gro_valid_for_field'] = $fieldCodes[$fieldData['gro_valid_for_field']]; } } } $roundData = $model->save($roundData); $import['rounds'][$lineNr]['gro_id_round'] = $roundData['gro_id_round']; $import['roundOrders'][$roundData['gro_id_order']] = $roundData['gro_id_round']; }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute($tokenData = null, $userId = null) { $batch = $this->getBatch(); $tracker = $this->loader->getTracker(); $batch->addToCounter('checkedTokens'); $token = $tracker->getToken($tokenData); $wasAnswered = $token->isCompleted(); if ($result = $token->checkTokenCompletion($userId)) { if ($result & \Gems_Tracker_Token::COMPLETION_DATACHANGE) { $i = $batch->addToCounter('resultDataChanges'); $batch->setMessage('resultDataChanges', sprintf($this->_('Results and timing changed for %d tokens.'), $i)); if ($wasAnswered) { $action = 'token.data-changed'; $message = sprintf($this->_("Token '%s' data has changed."), $token->getTokenId()); } else { $action = 'token.answered'; $message = sprintf($this->_("Token '%s' was answered."), $token->getTokenId()); } if (!$this->request instanceof \Zend_Controller_Request_Abstract) { $this->request = \Zend_Controller_Front::getInstance()->getRequest(); } $this->accesslog->logEntry($this->request, $action, true, $message, $token->getArrayCopy(), $token->getRespondentId()); } if ($result & \Gems_Tracker_Token::COMPLETION_EVENTCHANGE) { $i = $batch->addToCounter('surveyCompletionChanges'); $batch->setMessage('surveyCompletionChanges', sprintf($this->_('Answers changed by survey completion event for %d tokens.'), $i)); } } if ($token->isCompleted()) { $batch->setTask('Tracker_ProcessTokenCompletion', 'tokproc-' . $token->getTokenId(), $tokenData, $userId); } $batch->setMessage('checkedTokens', sprintf($this->_('Checked %d tokens.'), $batch->getCounter('checkedTokens'))); // Free memory $tracker->removeToken($token); }
/** * Get information on the field translations * * @return array of fields sourceName => targetName * @throws \MUtil_Model_ModelException */ public function getFieldsTranslations() { if (!$this->_targetModel instanceof \MUtil_Model_ModelAbstract) { throw new \MUtil_Model_ModelTranslateException(sprintf('Called %s without a set target model.', __FUNCTION__)); } $this->_targetModel->set('gto_id_token', 'label', $this->_('Token'), 'import_descr', $this->loader->getTracker()->getTokenLibrary()->getFormat(), 'required', true, 'order', 2); return array('token' => 'gto_id_token') + parent::getFieldsTranslations(); }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute($respTrackData = null, $userId = null) { $batch = $this->getBatch(); $tracker = $this->loader->getTracker(); $respTrack = $tracker->getRespondentTrack($respTrackData); $engine = $respTrack->getTrackEngine(); $engine->checkRoundsFor($respTrack, $userId, $batch); }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute($surveyId = null, $questionId = null, $order = null) { $batch = $this->getBatch(); $survey = $this->loader->getTracker()->getSurvey($surveyId); // Now save the questions $answerModel = $survey->getAnswerModel('en'); $questionModel = new \MUtil_Model_TableModel('gems__survey_questions'); \Gems_Model::setChangeFieldsByPrefix($questionModel, 'gsq'); $label = $answerModel->get($questionId, 'label'); /* if ($label instanceof \MUtil_Html_HtmlInterface) { $label = $label->render($this->view); } // */ $question['gsq_id_survey'] = $surveyId; $question['gsq_name'] = $questionId; $question['gsq_name_parent'] = $answerModel->get($questionId, 'parent_question'); $question['gsq_order'] = $order; $question['gsq_type'] = $answerModel->getWithDefault($questionId, 'type', \MUtil_Model::TYPE_STRING); $question['gsq_class'] = $answerModel->get($questionId, 'thClass'); $question['gsq_group'] = $answerModel->get($questionId, 'group'); $question['gsq_label'] = $label; $question['gsq_description'] = $answerModel->get($questionId, 'description'); // \MUtil_Echo::track($question); try { $questionModel->save($question); } catch (\Exception $e) { $batch->addMessage(sprintf($this->_('Save failed for survey %s, question %s: %s'), $survey->getName(), $questionId, $e->getMessage())); } $batch->addToCounter('checkedQuestions'); if ($questionModel->getChanged()) { $batch->addToCounter('changedQuestions'); } $batch->setMessage('questionschanged', sprintf($this->_('%d of %d questions changed.'), $batch->getCounter('changedQuestions'), $batch->getCounter('checkedQuestions'))); $options = $answerModel->get($questionId, 'multiOptions'); if ($options) { $optionModel = new \MUtil_Model_TableModel('gems__survey_question_options'); \Gems_Model::setChangeFieldsByPrefix($optionModel, 'gsqo'); $option['gsqo_id_survey'] = $surveyId; $option['gsqo_name'] = $questionId; $i = 0; // \MUtil_Echo::track($options); foreach ($options as $key => $label) { $option['gsqo_order'] = $i; $option['gsqo_key'] = $key; $option['gsqo_label'] = $label; try { $optionModel->save($option); } catch (\Exception $e) { $batch->addMessage(sprintf($this->_('Save failed for survey %s, question %s, option "%s" => "%s": %s'), $survey->getName(), $questionId, $key, $label, $e->getMessage())); } $i++; } $batch->addToCounter('checkedOptions', count($options)); $batch->addToCounter('changedOptions', $optionModel->getChanged()); $batch->setMessage('optionschanged', sprintf($this->_('%d of %d options changed.'), $batch->getCounter('changedOptions'), $batch->getCounter('checkedOptions'))); } }
/** * Create the snippets content * * This is a stub function either override getHtmlOutput() or override render() * * @param \Zend_View_Abstract $view Just in case it is needed here * @return \MUtil_Html_HtmlInterface Something that can be rendered */ public function getHtmlOutput(\Zend_View_Abstract $view) { $messages = false; if ($this->wasAnswered) { $this->currentToken = $this->token->getNextUnansweredToken(); } else { $validator = $this->loader->getTracker()->getTokenValidator(); if ($validator->isValid($this->token->getTokenId())) { $this->currentToken = $this->token; } else { $messages = $validator->getMessages(); $this->currentToken = $this->token->getNextUnansweredToken(); } } if ($this->currentToken instanceof \Gems_Tracker_Token) { $href = $this->getTokenHref($this->currentToken); $url = $href->render($this->view); // Redirect at once header('Location: ' . $url); exit; } // After the header() so that the patient does not see the messages after answering surveys if ($messages) { $this->addMessage($messages); } $org = $this->token->getOrganization(); $html = $this->getHtmlSequence(); $html->h3($this->_('Token')); $html->pInfo(sprintf($this->_('Thank you %s,'), $this->token->getRespondentName())); if ($welcome = $org->getWelcome()) { $html->pInfo()->raw(\MUtil_Markup::render($this->_($welcome), 'Bbcode', 'Html')); } $p = $html->pInfo()->spaced(); if ($this->wasAnswered) { $p->append($this->_('Thanks for answering our questions.')); } elseif (!$this->isValid) { if ($this->token->isExpired()) { $this->addMessage($this->_('This survey has expired. You can no longer answer it.')); } else { $this->addMessage($this->_('This survey is no longer valid.')); } } $p->append($this->_('We have no further questions for you at the moment.')); $p->append($this->_('We appreciate your cooperation very much.')); if ($sig = $org->getSignature()) { $html->pInfo()->raw(\MUtil_Markup::render($this->_($sig), 'Bbcode', 'Html')); } /* $html->br(); $href = array($this->request->getActionKey() => 'index', \MUtil_Model::REQUEST_ID => null); $buttonDiv = $html->buttonDiv(array('class' => 'centerAlign')); $buttonDiv->actionLink($href, $this->_('OK')); // */ return $html; }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute($sourceId = null, $command = null) { $batch = $this->getBatch(); $params = array_slice(func_get_args(), 2); $source = $this->loader->getTracker()->getSource($sourceId); if ($messages = call_user_func_array(array($source, $command), $params)) { foreach ($messages as $message) { $batch->addMessage($command . ': ' . $message); } } }
/** * Sets up the fixture, for example, opens a network connection. * This method is called before a test is executed. */ protected function setUp() { $this->db = \Zend_Db::factory('pdo_sqlite', array('dbname' => ':memory:')); \Zend_Registry::set('db', $this->db); $settings = new \Zend_Config_Ini(GEMS_ROOT_DIR . '/configs/application.example.ini', APPLICATION_ENV); $sa = $settings->toArray(); $this->loader = new \Gems_Loader(\Zend_Registry::getInstance(), $sa['loaderDirs']); \Zend_Registry::set('loader', $this->loader); $this->tracker = $this->loader->getTracker(); \Zend_Registry::set('tracker', $this->tracker); }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute($sourceId = null, $userId = null) { $batch = $this->getBatch(); $source = $this->loader->getTracker()->getSource($sourceId); if (is_null($userId)) { $userId = $this->loader->getCurrentUser()->getUserId(); } $surveyCount = $batch->addToCounter('sourceSyncSources'); $batch->setMessage('sourceSyncSources', sprintf($this->plural('Check %s source', 'Check %s sources', $surveyCount), $surveyCount)); $source->synchronizeSurveyBatch($batch, $userId); }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute() { $batch = $this->getBatch(); $import = $batch->getVariable('import'); if (!(isset($import['trackId']) && $import['trackId'])) { // Do nothing return; } $tracker = $this->loader->getTracker(); $trackEngine = $tracker->getTrackEngine($import['trackId']); $trackEngine->updateRoundCount($this->currentUser->getUserLoginId()); }
/** * Creates the model * * @return \MUtil_Model_ModelAbstract */ protected function createModel() { if ($this->model instanceof \Gems_Tracker_Model_StandardTokenModel) { $model = $this->model; } else { $model = $this->loader->getTracker()->getTokenModel(); } $model->addColumn('CASE WHEN gto_completion_time IS NULL THEN gto_valid_from ELSE gto_completion_time END', 'calc_used_date', 'gto_valid_from'); $model->addColumn('CASE WHEN gto_completion_time IS NULL THEN gto_valid_from ELSE NULL END', 'calc_valid_from', 'gto_valid_from'); $model->addColumn('CASE WHEN gto_completion_time IS NULL AND grc_success = 1 AND gto_valid_from <= CURRENT_TIMESTAMP AND gto_completion_time IS NULL AND (gto_valid_until IS NULL OR gto_valid_until >= CURRENT_TIMESTAMP) THEN gto_id_token ELSE NULL END', 'calc_id_token', 'gto_id_token'); $model->addColumn('CASE WHEN gto_completion_time IS NULL AND grc_success = 1 AND gto_valid_from <= CURRENT_TIMESTAMP AND gto_completion_time IS NULL AND gto_valid_until < CURRENT_TIMESTAMP THEN 1 ELSE 0 END', 'was_missed'); return $model; }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute($respTrackData = null, $userId = null) { $batch = $this->getBatch(); $tracker = $this->loader->getTracker(); $respTrack = $tracker->getRespondentTrack($respTrackData); $i = $batch->addToCounter('checkedRespondentTracks'); if ($result = $respTrack->checkTrackTokens($userId)) { $a = $batch->addToCounter('tokenDateCauses'); $b = $batch->addToCounter('tokenDateChanges', $result); $batch->setMessage('tokenDateChanges', sprintf($this->_('%2$d token date changes in %1$d tracks.'), $a, $b)); } $batch->setMessage('checkedRespondentTracks', sprintf($this->_('Checked %d tracks.'), $i)); }
/** * Process the respondent and return true when data has changed. * * The event has to handle the actual storage of the changes. * * @param \Gems_Tracker_Respondent $respondent * @param int $userId The current user * @return boolean True when something changed */ public function processChangedRespondent(\Gems_Tracker_Respondent $respondent) { $changes = 0; $tracker = $this->loader->getTracker(); $respTracks = $tracker->getRespondentTracks($respondent->getId(), $respondent->getOrganizationId()); $userId = $this->currentUser->getUserId(); foreach ($respTracks as $respondentTrack) { if ($respondentTrack instanceof \Gems_Tracker_RespondentTrack) { $changes += $respondentTrack->checkTrackTokens($userId); } } // \MUtil_Echo::track('Hi there! ' . $changes); return (bool) $changes; }
/** * Creates the model * * @return \MUtil_Model_ModelAbstract */ protected function createModel() { $model = $this->loader->getTracker()->getRespondentTrackModel(); $model->addColumn('CONCAT(gr2t_completed, \'' . $this->_(' of ') . '\', gr2t_count)', 'progress'); $model->resetOrder(); $model->set('gtr_track_name', 'label', $this->_('Track')); $model->set('gr2t_track_info', 'label', $this->_('Description')); $model->set('gr2t_start_date', 'label', $this->_('Start'), 'formatFunction', $this->util->getTranslated()->formatDate, 'default', \MUtil_Date::format(new \Zend_Date(), 'dd-MM-yyyy')); $model->set('gr2t_reception_code'); $model->set('progress', 'label', $this->_('Progress')); // , 'tdClass', 'rightAlign', 'thClass', 'rightAlign'); $model->set('assigned_by', 'label', $this->_('Assigned by')); return $model; }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute($tokenId = null) { $batch = $this->getBatch(); $tracker = $this->loader->getTracker(); $token = $tracker->getToken($tokenId); $checked = $batch->addToCounter('ta-checkedTokens'); if ($token->inSource()) { $survey = $token->getSurvey(); if ($survey->copyTokenToSource($token, '')) { $batch->addToCounter('ta-changedTokens'); } } $cTokens = $batch->getCounter('ta-changedTokens'); $batch->setMessage('ta-check', sprintf($this->plural('%d token out of %d tokens changed.', '%d tokens out of %d tokens changed.', $cTokens), $cTokens, $checked)); }
/** * Default overview action */ public function indexAction() { if ($this->checkForAnswersOnLoad) { $this->loader->getTracker()->processCompletedTokens(null, $this->currentUser->getUserId(), $this->currentUser->getCurrentOrganizationId(), true); } parent::indexAction(); }
public function save(array $newValues, array $filter = null) { // Allow to add default fields to any new track if ($defaultFields = $this->getDefaultFields()) { $keys = $this->getKeys(); $keys = array_flip($keys); $missing = array_diff_key($keys, $newValues); // On copy track the key exists but is null $newValues = parent::save($newValues, $filter); if (!empty($missing)) { // We have an insert! $foundKeys = array_intersect_key($newValues, $missing); // Now get the fieldmodel $engine = $this->loader->getTracker()->getTrackEngine($foundKeys['gtr_id_track']); $fieldmodel = $engine->getFieldsMaintenanceModel(true, 'create'); $lastOrder = 0; foreach ($defaultFields as $field) { // Load defaults $record = $fieldmodel->loadNew(); $record['gtf_id_order'] = $lastOrder + 10; $record = $field + $record; // Add defaults to the new field $record = $fieldmodel->save($record); $lastOrder = $record['gtf_id_order']; // Save order for next record } } } else { $newValues = parent::save($newValues, $filter); } return $newValues; }
/** * Perform automatic job mail */ public function commJob() { $batch = $this->loader->getTaskRunnerBatch('cron'); $batch->minimalStepDurationMs = 3000; // 3 seconds max before sending feedback $batch->autoStart = true; if (!$batch->isLoaded()) { // Check for unprocessed tokens $tracker = $this->loader->getTracker(); $tracker->processCompletedTokens(null, $this->currentUser->getUserId()); $batch->addTask('Mail\\AddAllMailJobsTask'); } $title = $this->_('Executing cron jobs'); $this->_helper->BatchRunner($batch, $title, $this->accesslog); $this->html->br(); }
/** * Return the survey id (and set a menu var) * * @return int */ public function getSurveyId() { $id = $this->_getIdParam(); $survey = $this->loader->getTracker()->getSurvey($id); $this->menu->getParameterSource()->offsetSet('gsu_active', $survey->isActive() ? 1 : 0); return $id; }
/** * Validate the data against the target form * * @param array $row * @param scalar $key * @return mixed Row array or false when errors occurred */ public function validateRowValues(array $row, $key) { $row = parent::validateRowValues($row, $key); $token = $this->loader->getTracker()->getToken($row['token'] ? $row['token'] : 'emptytoken'); if ($token->exists) { // If token is not completed we can use it, otherwise it depends on the settings if ($token->isCompleted()) { switch ($this->getTokenCompleted()) { case self::TOKEN_SKIP: return false; case self::TOKEN_ERROR: $this->_addErrors(sprintf($this->_('Token %s is completed.'), $token->getTokenId()), $key); break; // Intentional fall-through, // other case are handled in SaveAnswerTask } } } else { switch ($this->getNoToken()) { case self::TOKEN_SKIP: return false; case self::TOKEN_ERROR: $this->_addErrors($this->getNoTokenError($row, $key), $key); break; default: $respTrack = $this->findRespondentTrackFor($row); if ($respTrack) { $row['resp_track_id'] == $respTrack; } else { $this->_addErrors(sprintf($this->_('No track for inserting found for %s.'), implode(" / ", $row)), $key); } } } return $row; }
/** * Hook that loads the form data from $_POST or the model * * Or from whatever other source you specify here. */ protected function loadFormData() { parent::loadFormData(); $surveyId = $this->request->getParam(\MUtil_Model::REQUEST_ID); if (isset($this->formData['survey']) && $this->formData['survey'] && !$this->_survey instanceof \Gems_Tracker_Survey) { $this->_survey = $this->loader->getTracker()->getSurvey($this->formData['survey']); } if ($this->_survey instanceof \Gems_Tracker_Survey) { // Add (optional) survey specific translators $extraTrans = $this->importLoader->getAnswerImporters($this->_survey); if ($extraTrans) { $this->importTranslators = $extraTrans + $this->importTranslators; $this->_translatorDescriptions = false; $this->importModel->set('trans', 'multiOptions', $this->getTranslatorDescriptions()); } } if ($this->_survey instanceof \Gems_Tracker_Survey) { $this->targetModel = $this->_survey->getAnswerModel($this->locale->toString()); $this->importer->setTargetModel($this->targetModel); $source = $this->menu->getParameterSource(); $source->offsetSet('gsu_has_pdf', $this->_survey->hasPdf() ? 1 : 0); $source->offsetSet('gsu_active', $this->_survey->isActive() ? 1 : 0); } // \MUtil_Echo::track($this->formData); }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute($sourceId = null, $sourceSurveyId = null, $surveyId = null, $userId = null) { $batch = $this->getBatch(); $source = $this->loader->getTracker()->getSource($sourceId); if (null === $userId) { $userId = $this->loader->getCurrentUser()->getUserId(); } $messages = $source->checkSurvey($sourceSurveyId, $surveyId, $userId); $batch->addToCounter('checkedSurveys'); $batch->addToCounter('changedSurveys', $messages ? 1 : 0); $batch->setMessage('changedSurveys', sprintf($this->_('%d of %d surveys changed.'), $batch->getCounter('changedSurveys'), $batch->getCounter('checkedSurveys'))); if ($messages) { foreach ((array) $messages as $message) { $batch->addMessage($message); } } }
private function getRepeater($trackId) { if (!$this->trackEngine instanceof \Gems_Tracker_Engine_TrackEngineInterface) { $this->trackEngine = $this->loader->getTracker()->getTrackEngine($trackId); } $roundModel = $this->trackEngine->getRoundModel(true, null); return $roundModel->loadRepeatable(array('gro_id_track' => $trackId, 'gro_active' => 1)); }
/** * The place to check if the data set in the snippet is valid * to generate the snippet. * * When invalid data should result in an error, you can throw it * here but you can also perform the check in the * checkRegistryRequestsAnswers() function from the * {@see \MUtil_Registry_TargetInterface}. * * @return boolean */ public function hasHtmlOutput() { if ($this->respondent instanceof \Gems_Tracker_Respondent) { if (!$this->patientId) { $this->patientId = $this->respondent->getPatientNumber(); } if (!$this->organizationId) { $this->organizationId = $this->respondent->getOrganizationId(); } } // Try to get $this->respondentTrackId filled if (!$this->respondentTrackId) { if ($this->respondentTrack) { $this->respondentTrackId = $this->respondentTrack->getRespondentTrackId(); } else { $this->respondentTrackId = $this->request->getParam(\Gems_Model::RESPONDENT_TRACK); } } // Try to get $this->respondentTrack filled if ($this->respondentTrackId && !$this->respondentTrack) { $this->respondentTrack = $this->loader->getTracker()->getRespondentTrack($this->respondentTrackId); } // Set the user id if (!$this->userId) { $this->userId = $this->loader->getCurrentUser()->getUserId(); } if ($this->respondentTrack) { // We are updating $this->createData = false; // Try to get $this->trackEngine filled if (!$this->trackEngine) { // Set the engine used $this->trackEngine = $this->respondentTrack->getTrackEngine(); } } else { // We are inserting $this->createData = true; $this->saveLabel = $this->_($this->_('Add track')); // Try to get $this->trackId filled if (!$this->trackId) { if ($this->trackEngine) { $this->trackId = $this->trackEngine->getTrackId(); } else { $this->trackId = $this->request->getParam(\Gems_Model::TRACK_ID); } } // Try to get $this->trackEngine filled if ($this->trackId && !$this->trackEngine) { $this->trackEngine = $this->loader->getTracker()->getTrackEngine($this->trackId); } if (!($this->trackEngine && $this->patientId && $this->organizationId && $this->userId)) { throw new \Gems_Exception_Coding('Missing parameter for ' . __CLASS__ . ': could not find data for editing a respondent track nor the track engine, patientId and organizationId needed for creating one.'); } } return parent::hasHtmlOutput(); }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute($tokenData = null, $userId = null) { $tracker = $this->loader->getTracker(); $token = $tracker->getToken($tokenData[0]); $survey = $token->getSurvey(); $source = $survey->getSource(); if (method_exists($source, 'getCompletedTokens')) { $completed = $source->getCompletedTokens($tokenData, $survey->getSourceSurveyId()); } else { // No bulk method, check all individually $completed = $tokenData; } if ($completed) { $batch = $this->getBatch(); foreach ($completed as $tokenId) { $batch->setTask('Tracker_CheckTokenCompletion', 'tokchk-' . $tokenId, $tokenId, $userId); } } }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task */ public function execute($tokenData = null, $userId = null) { $batch = $this->getBatch(); $tracker = $this->loader->getTracker(); $token = $tracker->getToken($tokenData); if ($token->isCompleted()) { $respTrack = $token->getRespondentTrack(); $userId = $userId ? $userId : $this->loader->getCurrentUser()->getUserId(); if ($result = $respTrack->handleRoundCompletion($token, $userId)) { $a = $batch->addToCounter('roundCompletionCauses'); $b = $batch->addToCounter('roundCompletionChanges', $result); $batch->setMessage('roundCompletionChanges', sprintf($this->_('%d token round completion events caused changed to %d tokens.'), $a, $b)); } $trackId = $respTrack->getRespondentTrackId(); $batch->setTask('Tracker_CheckTrackTokens', 'chktrck-' . $trackId, $trackId, $userId); } // Free memory $tracker->removeToken($token); }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task * * @param array $trackData Nested array of trackdata */ public function execute($lineNr = null, $fieldData = null) { $batch = $this->getBatch(); $import = $batch->getVariable('import'); if (!(isset($import['trackId']) && $import['trackId'])) { // Do nothing return; } $tracker = $this->loader->getTracker(); $trackEngine = $tracker->getTrackEngine($import['trackId']); $fieldModel = $trackEngine->getFieldsMaintenanceModel(true, 'create'); $fieldData['gtf_id_track'] = $import['trackId']; $fieldData = $fieldModel->save($fieldData); // Store the field reference $import['fieldCodes']['{f' . $fieldData['gtf_id_order'] . '}'] = FieldsDefinition::makeKey($fieldData['sub'], $fieldData['gtf_id_field']); if (isset($fieldData['gtf_calculate_using']) && $fieldData['gtf_calculate_using']) { $batch->addTask('Tracker\\Import\\UpdateFieldCalculationTask', $lineNr, $fieldData['gtf_id_field'], $fieldModel->getModelNameForRow($fieldData), $fieldData['gtf_calculate_using']); } }
/** * Should handle execution of the task, taking as much (optional) parameters as needed * * The parameters should be optional and failing to provide them should be handled by * the task * * @param array $trackData Nested array of trackdata */ public function execute($formData = null) { $batch = $this->getBatch(); $import = $batch->getVariable('import'); $tracker = $this->loader->getTracker(); $model = $tracker->getTrackModel(); $model->applyFormatting(true, true); $trackData = $import['trackData']; $trackData['gtr_track_name'] = $formData['gtr_track_name']; $trackData['gtr_organizations'] = $formData['gtr_organizations']; // \MUtil_Echo::track($trackData); if ($trackData['gtr_date_start'] && !$trackData['gtr_date_start'] instanceof \Zend_Date) { $trackData['gtr_date_start'] = new \MUtil_Date($trackData['gtr_date_start'], 'yyyy-MM-dd'); } $output = $model->save($trackData); $import['trackId'] = $output['gtr_id_track']; $import['trackData']['gtr_id_track'] = $output['gtr_id_track']; $batch->addMessage(sprintf($this->_('Created track with id %d'), $output['gtr_id_track'])); }