/** * Extract the dicom metadata from a revision. * * @param item the id of the item to be extracted * @return the id of the revision */ public function extract($args) { /** @var ApihelperComponent $ApihelperComponent */ $ApihelperComponent = MidasLoader::loadComponent('Apihelper'); $ApihelperComponent->renameParamKey($args, 'item', 'id'); return $this->_callModuleApiMethod($args, 'extract', 'item'); }
/** * Get default reception directory. */ public function getDefaultReceptionDir() { /** @var UtilityComponent $utilityComponent */ $utilityComponent = MidasLoader::loadComponent('Utility'); $defaultReceptionDirectory = $utilityComponent->getTempDirectory('dicomserver'); return $defaultReceptionDirectory; }
/** test index action */ public function testIndexAction() { /** @var GroupModel $groupModel */ $groupModel = MidasLoader::loadModel('Group'); /** @var ItempolicygroupModel $itempolicygroupModel */ $itempolicygroupModel = MidasLoader::loadModel('Itempolicygroup'); /** @var UserModel $userModel */ $userModel = MidasLoader::loadModel('User'); /** @var FolderModel $folderModel */ $folderModel = MidasLoader::loadModel('Folder'); /** @var UploadComponent $uploadComponent */ $uploadComponent = MidasLoader::loadComponent('Upload'); $usersFile = $this->loadData('User', 'default'); $userDao = $userModel->load($usersFile[0]->getKey()); Zend_Registry::set('notifier', new MIDAS_Notifier(false, null)); $privateFolder = $folderModel->load(1002); $item = $uploadComponent->createUploadedItem($userDao, 'test.png', BASE_PATH . '/tests/testfiles/search.png', $privateFolder, null, '', true); $anonymousGroup = $groupModel->load(MIDAS_GROUP_ANONYMOUS_KEY); $itempolicygroupModel->createPolicy($anonymousGroup, $item, MIDAS_POLICY_READ); $this->params['itemId'] = $item->getKey(); $this->dispatchUrl('/visualize/index/index'); $this->assertController('index'); $this->dispatchUrl('/visualize/image/index'); $this->assertController('image'); $this->dispatchUrl('/visualize/media/index'); $this->assertController('media'); $this->dispatchUrl('/visualize/pdf/index'); $this->assertController('pdf'); $this->dispatchUrl('/visualize/txt/index'); $this->assertController('txt'); $this->dispatchUrl('/visualize/webgl/index'); $this->assertController('webgl'); }
/** Post database upgrade. */ public function postUpgrade() { /** @var RandomComponent $randomComponent */ $randomComponent = MidasLoader::loadComponent('Random'); $securityKey = $randomComponent->generateString(32); /** @var SettingModel $settingModel */ $settingModel = MidasLoader::loadModel('Setting'); $configPath = LOCAL_CONFIGS_PATH . DIRECTORY_SEPARATOR . $this->moduleName . '.local.ini'; if (file_exists($configPath)) { $config = new Zend_Config_Ini($configPath, 'global'); $settingModel->setConfig(MIDAS_REMOTEPROCESSING_SECURITY_KEY_KEY, $config->get('securitykey', $securityKey), $this->moduleName); $showButton = $config->get('showbutton'); if ($showButton === 'true') { $showButton = 1; } elseif ($showButton === 'false') { $showButton = 0; } else { $showButton = MIDAS_REMOTEPROCESSING_SHOW_BUTTON_DEFAULT_VALUE; } $settingModel->setConfig(MIDAS_REMOTEPROCESSING_SHOW_BUTTON_KEY, $showButton, $this->moduleName); $config = new Zend_Config_Ini($configPath, null, true); unset($config->securitykey->securitykey); unset($config->showbutton->showbutton); $writer = new Zend_Config_Writer_Ini(); $writer->setConfig($config); $writer->setFilename($configPath); $writer->write(); } else { $settingModel->setConfig(MIDAS_REMOTEPROCESSING_SECURITY_KEY_KEY, $securityKey, $this->moduleName); $settingModel->setConfig(MIDAS_REMOTEPROCESSING_SHOW_BUTTON_KEY, MIDAS_REMOTEPROCESSING_SHOW_BUTTON_DEFAULT_VALUE, $this->moduleName); } }
/** * Generate an upload token that will act as the authentication token for the upload. * This token is the filename of a unique file which will be placed under the * directory specified by the dirname parameter, which should be used to ensure that * the user can only write into a certain logical space. * * @param array $args * @param string $dirname * @return array * @throws Exception */ public function generateToken($args, $dirname = '') { if (!array_key_exists('filename', $args)) { throw new Exception('Parameter filename is not defined', MIDAS_HTTPUPLOAD_FILENAME_PARAM_UNDEFINED); } $tempDirectory = UtilityComponent::getTempDirectory(); $dir = $dirname === '' ? '' : '/' . $dirname; $dir = $tempDirectory . $dir; if (!file_exists($dir)) { if (!mkdir($dir, 0777, true)) { throw new Exception('Failed to create temporary upload dir', MIDAS_HTTPUPLOAD_TMP_DIR_CREATION_FAILED); } } /** @var RandomComponent $randomComponent */ $randomComponent = MidasLoader::loadComponent('Random'); $uniqueIdentifier = $randomComponent->generateString(64); if ($dirname != '') { $uniqueIdentifier = $dirname . '/' . $uniqueIdentifier; } $path = $tempDirectory . '/' . $uniqueIdentifier; if (file_exists($path)) { throw new Exception('Failed to generate upload token', MIDAS_HTTPUPLOAD_UPLOAD_TOKEN_GENERATION_FAILED); } if (touch($path) === false) { mkdir($path, 0777, true); $uniqueIdentifier .= '/'; } return array('token' => $uniqueIdentifier); }
/** * Fetch the information about an ItemRevision. * * @path /itemrevision/{id} * @http GET * @param id The id of the ItemRevision * @return ItemRevision object * * @param array $args parameters * @throws Exception */ public function itemrevisionGet($args) { /** @var ApihelperComponent $apihelperComponent */ $apihelperComponent = MidasLoader::loadComponent('Apihelper'); $apihelperComponent->validateParams($args, array('id')); $apihelperComponent->requirePolicyScopes(array(MIDAS_API_PERMISSION_SCOPE_READ_DATA)); $userDao = $apihelperComponent->getUser($args); $itemrevision_id = $args['id']; /** @var ItemRevisionModel $itemRevisionModel */ $itemRevisionModel = MidasLoader::loadModel('ItemRevision'); $itemRevision = $itemRevisionModel->load($itemrevision_id); /** @var ItemModel $itemModel */ $itemModel = MidasLoader::loadModel('Item'); $item = $itemModel->load($itemRevision->getItemId()); if ($item === false || !$itemModel->policyCheck($item, $userDao, MIDAS_POLICY_READ)) { throw new Exception("This item doesn't exist or you don't have the permissions.", MIDAS_INVALID_POLICY); } $in = $itemRevision->toArray(); $out = array(); $out['id'] = $in['itemrevision_id']; $out['item_id'] = $in['item_id']; $out['date_created'] = $in['date']; $out['date_updated'] = $in['date']; // fix this $out['changes'] = $in['changes']; $out['user_id'] = $in['user_id']; $out['license_id'] = $in['license_id']; $out['uuid'] = $in['uuid']; $out['bitstreams'] = array_map(array($this, 'getBitstreamId'), $itemRevision->getBitstreams()); return $out; }
/** * Create the database record for inviting a user via email that is not registered yet. * * @param email The email of the user (should not exist in Midas already) * @param group The group to invite the user to * @param inviter The user issuing the invitation (typically the session user) * @return the created NewUserInvitationDao */ public function createInvitation($email, $group, $inviter) { /** @var RandomComponent $randomComponent */ $randomComponent = MidasLoader::loadComponent('Random'); $email = strtolower($email); /** @var NewUserInvitationDao $newUserInvitation */ $newUserInvitation = MidasLoader::newDao('NewUserInvitationDao'); $newUserInvitation->setEmail($email); $newUserInvitation->setAuthKey($randomComponent->generateString(64, '0123456789abcdef')); $newUserInvitation->setInviterId($inviter->getKey()); $newUserInvitation->setGroupId($group->getKey()); $newUserInvitation->setCommunityId($group->getCommunityId()); $newUserInvitation->setDateCreation(date('Y-m-d H:i:s')); /** @var UserModel $userModel */ $userModel = MidasLoader::loadModel('User'); $existingUser = $userModel->getByEmail($email); if ($existingUser) { throw new Zend_Exception('User with that email already exists'); } // If the user has already been sent an invitation to this community, delete existing record $existingInvitation = $this->getByParams(array('email' => $email, 'community_id' => $group->getCommunityId())); if ($existingInvitation) { $this->delete($existingInvitation); } $this->save($newUserInvitation); return $newUserInvitation; }
/** * Submit your OTP after calling core login, and you will receive your api token. * * @param otp The one-time password * @param mfaTokenId The id of the temporary MFA token * @return The api token * @throws Exception */ public function otpLogin($params) { $this->_checkKeys(array('otp', 'mfaTokenId'), $params); /** @var Mfa_ApitokenModel $tempTokenModel */ $tempTokenModel = MidasLoader::loadModel('Apitoken', 'mfa'); /** @var Mfa_OtpdeviceModel $otpDeviceModel */ $otpDeviceModel = MidasLoader::loadModel('Otpdevice', 'mfa'); /** @var TokenModel $apiTokenModel */ $apiTokenModel = MidasLoader::loadModel('Token'); $tempToken = $tempTokenModel->load($params['mfaTokenId']); if (!$tempToken) { throw new Exception('Invalid MFA token id', -1); } $apiToken = $apiTokenModel->load($tempToken->getTokenId()); if (!$apiToken) { $tempTokenModel->delete($tempToken); throw new Exception('Corresponding api token no longer exists', -1); } $user = $tempToken->getUser(); $otpDevice = $otpDeviceModel->getByUser($user); if (!$otpDevice) { $tempTokenModel->delete($tempToken); throw new Exception('User does not have an OTP device', -1); } $tempTokenModel->delete($tempToken); /** @var Mfa_OtpComponent $otpComponent */ $otpComponent = MidasLoader::loadComponent('Otp', 'mfa'); if (!$otpComponent->authenticate($otpDevice, $params['otp'])) { throw new Exception('Incorrect OTP', -1); } $token = $apiToken->getToken(); return array('token' => $token); }
/** * Get the readme text from the specified folder. */ public function fromFolder($folder) { /** @var FolderModel $folderModel */ $folderModel = MidasLoader::loadModel('Folder'); /** @var ItemModel $itemModel */ $itemModel = MidasLoader::loadModel('Item'); $readmeItem = null; $candidates = array('readme.md', 'readme.txt', 'readme'); foreach ($candidates as $candidate) { $readmeItem = $folderModel->getItemByName($folder, $candidate, false); if ($readmeItem != null) { break; } } if ($readmeItem == null) { return array('text' => ''); } $revisionDao = $itemModel->getLastRevision($readmeItem); if ($revisionDao === false) { return array('text' => ''); } $bitstreams = $revisionDao->getBitstreams(); if (count($bitstreams) === 0) { return array('text' => ''); } $bitstream = $bitstreams[0]; $path = $bitstream->getAssetstore()->getPath() . '/' . $bitstream->getPath(); $contents = file_get_contents($path); MidasLoader::loadComponent('Utility'); $parsedContents = UtilityComponent::markdown(htmlspecialchars($contents, ENT_COMPAT, 'UTF-8')); return array('text' => $parsedContents); }
/** Post database upgrade. */ public function postUpgrade() { /** @var SettingModel $settingModel */ $settingModel = MidasLoader::loadModel('Setting'); $config = new Zend_Config_Ini(APPLICATION_CONFIG, 'global'); $settingModel->setConfig('address_verification', $config->get('verifyemail', 0), 'mail'); if ($config->get('smtpfromaddress')) { $fromAddress = $config->get('smtpfromaddress'); } elseif (ini_get('sendmail_from')) { $fromAddress = ini_get('sendmail_from'); } else { $fromAddress = '*****@*****.**'; // RFC2606 } $settingModel->setConfig('from_address', $fromAddress, 'mail'); if ($config->get('smtpserver')) { $components = parse_url($config->get('smtpserver')); if (isset($components['host'])) { $settingModel->setConfig('smtp_host', $components['host'], 'mail'); } if (isset($components['port'])) { $settingModel->setConfig('smtp_port', $components['port'], 'mail'); if ($components['port'] === 587) { $settingModel->setConfig('smtp_use_ssl', 1, 'mail'); } } if (isset($components['user'])) { $settingModel->setConfig('smtp_username', $components['user'], 'mail'); } if (isset($components['pass'])) { $settingModel->setConfig('smtp_password', $components['pass'], 'mail'); } } if ($config->get('smtpuser')) { $settingModel->setConfig('smtp_username', $config->get('smtpuser'), 'mail'); } if ($config->get('smtppassword')) { $settingModel->setConfig('smtp_password', $config->get('smtppassword'), 'mail'); } if ($settingModel->getValueByName('smtp_host', 'mail')) { $provider = 'smtp'; } else { $provider = 'mail'; } $settingModel->setConfig('provider', $provider, 'mail'); /** @var UtilityComponent $utilityComponent */ $utilityComponent = MidasLoader::loadComponent('Utility'); $utilityComponent->installModule('mail'); $config = new Zend_Config_Ini(APPLICATION_CONFIG, null, true); unset($config->global->smtpfromaddress); unset($config->global->smtpserver); unset($config->global->smtpuser); unset($config->global->smtppassword); unset($config->global->verifyemail); $writer = new Zend_Config_Writer_Ini(); $writer->setConfig($config); $writer->setFilename(APPLICATION_CONFIG); $writer->write(); }
/** * Call module API method. * * @param array $args * @param string $coreApiMethod * @param null|string $resource * @param bool $hasReturn * @return null|mixed * @throws Zend_Exception */ private function _callModuleApiMethod($args, $coreApiMethod, $resource = null, $hasReturn = true) { $ApiComponent = MidasLoader::loadComponent('Api' . $resource, 'sizequota'); $rtn = $ApiComponent->{$coreApiMethod}($args); if ($hasReturn) { return $rtn; } return; }
/** Post database install. */ public function postInstall() { /** @var RandomComponent $randomComponent */ $randomComponent = MidasLoader::loadComponent('Random'); $securityKey = $randomComponent->generateString(32); /** @var SettingModel $settingModel */ $settingModel = MidasLoader::loadModel('Setting'); $settingModel->setConfig(MIDAS_REMOTEPROCESSING_SECURITY_KEY_KEY, $securityKey, $this->moduleName); $settingModel->setConfig(MIDAS_REMOTEPROCESSING_SHOW_BUTTON_KEY, MIDAS_REMOTEPROCESSING_SHOW_BUTTON_DEFAULT_VALUE, $this->moduleName); }
/** * Get the readme text for a folder. * * @path /readmes/folder/{id} * @http GET * @param id the id of the folder from which to get the readme * @return the text of the readme */ public function get($args) { /** @var ApihelperComponent $apihelperComponent */ $apihelperComponent = MidasLoader::loadComponent('Apihelper'); /** @var Readmes_GetReadmeComponent $readmeComponent */ $readmeComponent = MidasLoader::loadComponent('GetReadme', 'readmes'); $apihelperComponent->validateParams($args, array('id')); /** @var FolderModel $folderModel */ $folderModel = MidasLoader::loadModel('Folder'); $folderDao = $folderModel->load($args['id']); $readme = $readmeComponent->fromFolder($folderDao); return $readme; }
/** Get json to pass to the view initially */ public function getJson($params) { $json = array('limit' => 10, 'offset' => 0); if ($this->userSession->Dao != null) { $json['user'] = $this->userSession->Dao; } /** @var Comments_CommentComponent $commentComponent */ $commentComponent = MidasLoader::loadComponent('Comment', $this->moduleName); list($comments, $total) = $commentComponent->getComments($params['item'], $json['limit'], $json['offset']); $json['comments'] = $comments; $json['total'] = $total; return $json; }
/** Test extraction of a zip file */ public function testPerformAction() { // Simulate uploading our zip file into the assetstore (cp instead of mv) /** @var UploadComponent $uploadComponent */ $uploadComponent = MidasLoader::loadComponent('Upload'); $adminUser = $this->User->load(3); $adminFolders = $adminUser->getFolder()->getFolders(); $parent = $adminFolders[0]; $path = BASE_PATH . '/modules/archive/tests/data/test.zip'; $item = $uploadComponent->createUploadedItem($adminUser, 'test.zip', $path, $parent, null, '', true); // Should fail when we try without privileges $url = '/archive/extract/perform?deleteArchive=true&itemId=' . $item->getKey(); $this->dispatchUrl($url, null, true); // Now run with proper privileges $this->resetAll(); $this->dispatchUrl($url, $adminUser); // The original item should have been deleted $item = $this->Item->load($item->getKey()); $this->assertFalse($item); // It should be replaced by the expected hierarchy /** @var SortdaoComponent $sortDaoComponent */ $sortDaoComponent = MidasLoader::loadComponent('Sortdao'); $sortDaoComponent->field = 'name'; $childItems = $parent->getItems(); $this->assertEquals(count($childItems), 2); usort($childItems, array($sortDaoComponent, 'sortByName')); $child0 = $childItems[0]; $this->assertEquals($child0->getName(), 'AppController.php'); $child1 = $childItems[1]; $this->assertEquals($child1->getName(), 'Notification.php'); $childFolders = $parent->getFolders(); $this->assertEquals(count($childFolders), 2); usort($childFolders, array($sortDaoComponent, 'sortByName')); $childPublic = $childFolders[0]; $this->assertEquals($childPublic->getName(), 'public'); $childTranslation = $childFolders[1]; $this->assertEquals($childTranslation->getName(), 'translation'); $translationChildFolders = $childTranslation->getFolders(); $this->assertEquals(count($translationChildFolders), 0); $translationChildItems = $childTranslation->getItems(); $this->assertEquals(count($translationChildItems), 1); $this->assertEquals($translationChildItems[0]->getName(), 'fr-main.csv'); $publicChildItems = $childPublic->getItems(); $this->assertEquals(count($publicChildItems), 0); $publicChildFolders = $childPublic->getFolders(); $this->assertEquals(count($publicChildFolders), 2); usort($publicChildFolders, array($sortDaoComponent, 'sortByName')); $this->assertEquals($publicChildFolders[0]->getName(), 'css'); $this->assertEquals($publicChildFolders[1]->getName(), 'js'); // The rest is assumed to follow by induction :) }
/** save */ public function save($dao) { if (!isset($dao->uuid) || empty($dao->uuid)) { /** @var UuidComponent $uuidComponent */ $uuidComponent = MidasLoader::loadComponent('Uuid'); $dao->setUuid($uuidComponent->generate()); } $name = $dao->getName(); if (empty($name) && $name !== '0') { throw new Zend_Exception('Please set a name for the Community.'); } $cleanDescription = UtilityComponent::filterHtmlTags($dao->getDescription()); $dao->setDescription($cleanDescription); parent::save($dao); }
/** * Extract an archive out of an item and into the hierarchy in place. * * @param ItemDao $itemDao item representing the archive to extract * @param bool $deleteArchive whether to delete the archive item when finished extraction * @param UserDao $user user DAO * @param null|ProgressDao $progressDao progress DAO * @return FolderDao * @throws Zend_Exception */ public function extractInPlace($itemDao, $deleteArchive, $user, $progressDao = null) { $this->Item = MidasLoader::loadModel('Item'); $this->Folder = MidasLoader::loadModel('Folder'); $this->Folderpolicyuser = MidasLoader::loadModel('Folderpolicyuser'); $this->Folderpolicygroup = MidasLoader::loadModel('Folderpolicygroup'); $this->Progress = MidasLoader::loadModel('Progress'); $this->Setting = MidasLoader::loadModel('Setting'); $this->UploadComponent = MidasLoader::loadComponent('Upload'); $this->user = $user; $rev = $this->Item->getLastRevision($itemDao); if (!$rev) { throw new Zend_Exception('This item has no revisions'); } $bitstreams = $rev->getBitstreams(); if (count($bitstreams) !== 1) { throw new Zend_Exception('Head revision must have only one bitstream'); } if ($progressDao) { $this->Progress->updateProgress($progressDao, 0, 'Preparing to extract archive...'); } $bitstreamDao = $bitstreams[0]; $name = $bitstreamDao->getName(); $folders = $itemDao->getFolders(); $parentFolder = $folders[0]; // First extract the archive into a temp location on disk if ($this->_isFileExtension($name, '.zip')) { $extractedPath = $this->_extractZip($bitstreamDao, $progressDao); } else { throw new Zend_Exception('This file is not a supported archive type'); } // Next create the hierarchy from the temp location if ($progressDao) { $this->Progress->updateProgress($progressDao, 0, 'Adding items to Midas tree...'); } $this->_addToHierarchy($extractedPath, $parentFolder, $progressDao); // Clean up the dirs we made in the temp directory UtilityComponent::rrmdir($extractedPath); // Finally, delete existing archive item if user has specified to do so if ($deleteArchive) { if ($progressDao) { $progressDao->setMessage('Deleting old archive...'); $this->Progress->save($progressDao); } $this->Item->delete($itemDao); } return $parentFolder; }
/** * @param tmp_dir the path to the batchmake temp dir * @param bin_dir the path to the batchmake bin dir, should have BatchMake exe * @param script_dir the path to the batchmake script dir, where bms files live * @param app_dir the path to the dir housing executables * @param data_dir the path to the data export dir * @param condor_bin_dir the path to the location of the condor executables * @return an array, the first value is a 0 if the config is incorrect or 1 * if the config is correct, the second value is a list of individual config values and their statuses. */ public function testconfig($params) { // any values that aren't filled in, fill them in with a blank $expectedKeys = array('tmp_dir', 'bin_dir', 'script_dir', 'app_dir', 'data_dir', 'condor_bin_dir'); $configParams = array(); foreach ($expectedKeys as $propKey) { if (!isset($params[$propKey])) { $configParams[$propKey] = ''; } else { $configParams[$propKey] = $params[$propKey]; } } /** @var Batchmake_KWBatchmakeComponent $kwbatchmakeComponent */ $kwbatchmakeComponent = MidasLoader::loadComponent('KWBatchmake', 'batchmake'); return $kwbatchmakeComponent->testconfig($configParams); }
/** * Constructs the link that is used to initiate a google oauth authentication. * This link redirects the user to google so they can approve of the requested * oauth scopes, and in turn google will redirect them back to our callback * url with an authorization code. */ public function googleAuthLink() { $clientId = $this->Setting->getValueByName(GOOGLE_AUTH_CLIENT_ID_KEY, $this->moduleName); $scheme = array_key_exists('HTTPS', $_SERVER) && $_SERVER['HTTPS'] ? 'https://' : 'http://'; $fc = Zend_Controller_Front::getInstance(); /** @var RandomComponent $randomComponent */ $randomComponent = MidasLoader::loadComponent('Random'); $csrfToken = $randomComponent->generateString(30); $redirectUri = $scheme . $_SERVER['HTTP_HOST'] . $fc->getBaseUrl() . '/' . $this->moduleName . '/callback'; $scopes = array('profile', 'email'); $href = 'https://accounts.google.com/o/oauth2/auth?response_type=code' . '&client_id=' . urlencode($clientId) . '&redirect_uri=' . urlencode($redirectUri) . '&scope=' . urlencode(implode(' ', $scopes)) . '&state=' . urlencode($csrfToken); $userNs = new Zend_Session_Namespace('Auth_User'); $userNs->oauthToken = $csrfToken; session_write_close(); return '<div style="margin-top: 10px; display: inline-block;">Or ' . '<a class="googleauth-login" style="text-decoration: underline;" href="' . htmlspecialchars($href, ENT_QUOTES, 'UTF-8') . '">' . 'Login with your Google account</a></div><script type="text/javascript"' . ' src="' . $fc->getBaseUrl() . '/modules/' . $this->moduleName . '/public/js/login/googleauth.login.js"></script>'; }
/** * Test geolocation. */ public function testGeolocationTask() { // We need the module constants to be imported, and the notifier to be set require_once BASE_PATH . '/modules/scheduler/constant/module.php'; Zend_Registry::set('notifier', new MIDAS_Notifier(false, null)); // Use the admin user so we can configure the module $usersFile = $this->loadData('User', 'default'); $userDao = $this->User->load($usersFile[2]->getKey()); /** @var Scheduler_JobModel $jobModel */ $jobModel = MidasLoader::loadModel('Job', 'scheduler'); /** @var Statistics_IpLocationModel $ipLocationModel */ $ipLocationModel = MidasLoader::loadModel('IpLocation', 'statistics'); $ipLocations = $ipLocationModel->getAllUnlocated(); $this->assertEquals(count($ipLocations), 1); $this->assertEquals($ipLocations[0]->getLatitude(), ''); $this->assertEquals($ipLocations[0]->getLongitude(), ''); $ip = $ipLocations[0]->getIp(); /** @var $adminComponent Statistics_AdminComponent */ $adminComponent = MidasLoader::loadComponent('Admin', 'statistics'); $adminComponent->schedulePerformGeolocationJob('1234', $userDao); // Assert that the task is now scheduled $jobs = $jobModel->getJobsByTask('TASK_STATISTICS_PERFORM_GEOLOCATION'); $this->assertEquals(count($jobs), 1); $job = $jobs[0]; $params = json_decode($job->getParams()); $this->assertEquals($params->apikey, '1234'); // Make it so the job will fire on the next scheduler run $job->setFireTime(date('Y-m-d', strtotime('-1 day')) . ' 01:00:00'); $jobModel->save($job); // Run the scheduler $this->resetAll(); $this->dispatchUrl('/scheduler/run/index', $userDao); // Assert that geolocation task was performed $ipLocations = $ipLocationModel->getAllUnlocated(); $this->assertEquals(count($ipLocations), 0); $ipLocation = $ipLocationModel->getByIp($ip); $this->assertTrue($ipLocation != false); $this->assertEquals($ipLocation->getLatitude(), '0'); $this->assertEquals($ipLocation->getLongitude(), '0'); // We should have a message in the log now $logs = $job->getLogs(); $this->assertEquals(count($logs), 1); $this->assertTrue(strpos($logs[0]->getLog(), 'IpInfoDb lookup failed') !== false); echo 'Log = ' . $logs[0]->getLog(); }
/** * Returns a page of comments and all required information * to be rendered in the view. */ public function getComments($item, $limit, $offset) { /** @var Comments_ItemcommentModel $itemCommentModel */ $itemCommentModel = MidasLoader::loadModel('Itemcomment', 'comments'); /** @var DateComponent $dateComponent */ $dateComponent = MidasLoader::loadComponent('Date'); $comments = $itemCommentModel->getComments($item, $limit, $offset); $total = $itemCommentModel->getTotal($item); $commentsList = array(); foreach ($comments as $comment) { $commentArray = $comment->toArray(); $commentArray['user'] = $comment->getUser()->toArray(); $commentArray['comment'] = htmlspecialchars($commentArray['comment'], ENT_QUOTES, 'UTF-8'); $commentArray['ago'] = $dateComponent->ago($commentArray['date']); $commentsList[] = $commentArray; } return array($commentsList, $total); }
/** * Create and return a new oauth client owned by the given user. * * @param UserDao $userDao owner of the client * @param string $name human readable name of the client * @return Oauth_ClientDao * @throws Zend_Exception */ public function create($userDao, $name) { if (!$userDao instanceof UserDao) { throw new Zend_Exception('Invalid userDao'); } if (empty($name)) { throw new Zend_Exception('Client name must not be empty'); } /** @var RandomComponent $randomComponent */ $randomComponent = MidasLoader::loadComponent('Random'); /** @var Oauth_ClientDao $clientDao */ $clientDao = MidasLoader::newDao('ClientDao', $this->moduleName); $clientDao->setName($name); $clientDao->setOwnerId($userDao->getKey()); $clientDao->setSecret($randomComponent->generateString(40)); $clientDao->setCreationDate(date('Y-m-d H:i:s')); $this->save($clientDao); return $clientDao; }
/** * Used to refresh the list of comments on the page. * * @param itemId The item id whose comments to get * @param limit Max number of comments to display at once * @param offset Offset count for pagination * @throws Zend_Exception */ public function getAction() { $itemId = $this->getParam('itemId'); if (!isset($itemId) || !$itemId) { throw new Zend_Exception('Must set itemId parameter'); } $item = $this->Item->load($itemId); if (!$item) { throw new Zend_Exception('Not a valid itemId'); } $limit = $this->getParam('limit'); $offset = $this->getParam('offset'); $this->disableView(); $this->disableLayout(); /** @var Comments_CommentComponent $commentComponent */ $commentComponent = MidasLoader::loadComponent('Comment', $this->moduleName); list($comments, $total) = $commentComponent->getComments($item, $limit, $offset); echo JsonComponent::encode(array('status' => 'ok', 'comments' => $comments, 'total' => $total)); }
/** * Test uploading a scalar with a submission attached via uuid. * * @throws Zend_Exception */ public function testUploadScalarWithSubmission() { $uuidComponent = MidasLoader::loadComponent('Uuid'); $uuid = $uuidComponent->generate(); $token = $this->_loginAsAdministrator(); $outputs = array(); $outputs['metric_0'] = $this->_submitScalar($token, $uuid, 'metric_0', '18'); $outputs['metric_1'] = $this->_submitScalar($token, $uuid, 'metric_1', '19', 'meters'); $outputs['metric_2'] = $this->_submitScalar($token, $uuid, 'metric_2', '20', 'mm'); /** @var Tracker_SubmissionModel $submissionModel */ $submissionModel = MidasLoader::loadModel('Submission', 'tracker'); /** @var Tracker_SubmissionDao $submissionDao */ $submissionDao = $submissionModel->getSubmission($uuid); $scalarDaos = $submissionModel->getScalars($submissionDao); /** @var Tracker_ScalarDao $scalarDao */ foreach ($scalarDaos as $scalarDao) { $curOutput = $outputs[$scalarDao->getTrend()->getMetricName()]; $this->assertEquals($curOutput->value, $scalarDao->getValue()); $this->assertEquals($submissionDao->getKey(), $scalarDao->getSubmissionId()); } }
/** * Extract the dicom metadata from a revision. * * @path /dicomextractor/item/{id} * @http PUT * @param id the id of the item to be extracted * @return the id of the revision * * @param array $args parameters * @throws Exception */ public function extract($args) { /** @var ApihelperComponent $apihelperComponent */ $apihelperComponent = MidasLoader::loadComponent('Apihelper'); $apihelperComponent->validateParams($args, array('id')); /** @var ItemModel $itemModel */ $itemModel = MidasLoader::loadModel('Item'); /** @var AuthenticationComponent $authComponent */ $authComponent = MidasLoader::loadComponent('Authentication'); $itemDao = $itemModel->load($args['id']); $userDao = $authComponent->getUser($args, Zend_Registry::get('userSession')->Dao); if (!$itemModel->policyCheck($itemDao, $userDao, MIDAS_POLICY_WRITE)) { throw new Exception('You didn\'t log in or you don\'t have the write ' . 'permission for the given item.', MIDAS_INVALID_POLICY); } $revisionDao = $itemModel->getLastRevision($itemDao); if ($revisionDao === false) { throw new Exception('The item has no revisions', MIDAS_INVALID_POLICY); } /** @var Dicomextractor_ExtractorComponent $dicomComponent */ $dicomComponent = MidasLoader::loadComponent('Extractor', 'dicomextractor'); $dicomComponent->extract($revisionDao); $dicomComponent->thumbnail($itemDao); return json_encode($revisionDao); }
/** * Create and return a new oauth authorization code for the given client and user. Expires after 10 minutes * in accordance with the recommendation in the IETF draft v31. * * @param UserDao $userDao resource owner (end user to authenticate via the client) * @param Oauth_ClientDao $clientDao client that will be receiving the code * @param array $scopes array of permission scopes (see api module constants) * @return Oauth_CodeDao * @throws Zend_Exception */ public function create($userDao, $clientDao, $scopes) { if (!$userDao instanceof UserDao) { throw new Zend_Exception('Invalid userDao'); } if (!$clientDao instanceof Oauth_ClientDao) { throw new Zend_Exception('Invalid userDao'); } if (!is_array($scopes)) { throw new Zend_Exception('Scopes must be an array'); } /** @var RandomComponent $randomComponent */ $randomComponent = MidasLoader::loadComponent('Random'); /** @var Oauth_CodeDao $codeDao */ $codeDao = MidasLoader::newDao('CodeDao', $this->moduleName); $codeDao->setCode($randomComponent->generateString(32)); $codeDao->setScopes(JsonComponent::encode($scopes)); $codeDao->setUserId($userDao->getKey()); $codeDao->setClientId($clientDao->getKey()); $codeDao->setCreationDate(date('Y-m-d H:i:s')); $codeDao->setExpirationDate(date('Y-m-d H:i:s', strtotime('+10 minutes'))); $this->save($codeDao); return $codeDao; }
/** * Generate an upload token and upload URL. * * @param array $args * @return array */ public function uploadGeneratetoken($args) { /** @var Googleappengine_ApiuploadComponent $apiuploadComponent */ $apiuploadComponent = MidasLoader::loadComponent('Apiupload', $this->moduleName); return $apiuploadComponent->uploadToken($args); }
/** * Date ago view helper. * * @param int|string $timestamp timestamp * @return string date ago as a formatted string */ public function dateago($timestamp) { /** @var DateComponent $dateComponent */ $dateComponent = MidasLoader::loadComponent('Date'); return htmlspecialchars($dateComponent->ago($timestamp), ENT_QUOTES, 'UTF-8'); }
/** * Call this to stream the large thumbnail for the item. Should only be called if the item has a thumbnail; * otherwise the request produces no output. * * @param itemthumbnail The itemthumbnail_id to stream * @throws Zend_Exception */ public function itemAction() { $itemthumbnailId = $this->getParam('itemthumbnail'); if (!isset($itemthumbnailId)) { throw new Zend_Exception('Must pass an itemthumbnail parameter'); } $itemthumbnail = $this->Thumbnailcreator_Itemthumbnail->load($itemthumbnailId); if (!$itemthumbnail) { throw new Zend_Exception('Invalid itemthumbnail parameter'); } if (!$this->Item->policyCheck($itemthumbnail->getItem(), $this->userSession->Dao)) { throw new Zend_Exception('Invalid policy'); } $this->disableLayout(); $this->disableView(); if ($itemthumbnail->getThumbnailId() !== null) { $bitstream = $this->Bitstream->load($itemthumbnail->getThumbnailId()); /** @var DownloadBitstreamComponent $downloadBitstreamComponent */ $downloadBitstreamComponent = MidasLoader::loadComponent('DownloadBitstream'); $downloadBitstreamComponent->download($bitstream); } }
/** * Set a single scalar result value. * * @param dashboard_id the id of the target dashboard * @param folder_id the id of the target result folder * @param item_id the id of the result item * @param value the value of the result being set * @return the id of the created scalar result * @throws Exception */ public function setScalarResult($value) { // check for the proper parameters $this->_checkKeys(array('dashboard_id', 'folder_id', 'item_id', 'value'), $value); // Verify authentication (only admins can set results) /** @var AuthenticationComponent $authComponent */ $authComponent = MidasLoader::loadComponent('Authentication'); $userDao = $authComponent->getUser($value, Zend_Registry::get('userSession')->Dao); if (!$userDao || !$userDao->isAdmin()) { throw new Exception('Only administrators can write result scalars.', -1); } // Load the necessary models /** @var Validation_DashboardModel $dashboardModel */ $dashboardModel = MidasLoader::loadModel('Dashboard', 'validation'); // Verify that the dashboard exists $dashboardDao = $dashboardModel->load($value['dashboard_id']); if (!$dashboardDao) { throw new Exception('No dashboard found with that id.', -1); } // Verify that the folder_id is associated with the dashboard as a result $results = $dashboardDao->getResults(); $tgtResult = null; foreach ($results as $result) { if ($result->getKey() == $value['folder_id']) { $tgtResult = $result; break; } } if (!$tgtResult) { throw new Exception('No result found with that folder_id.', -1); } // Verify that an item with item_id is in that result set $resultItems = $tgtResult->getItems(); $tgtItem = null; foreach ($resultItems as $resultItem) { if ($resultItem->getKey() == $value['item_id']) { $tgtItem = $resultItem; } } if (!$tgtItem) { throw new Exception('No result item found with that item_id.', -1); } // Assuming everything went according to plan, set the result scalar $scalarResult = $dashboardModel->setScore($dashboardDao, $tgtResult, $tgtItem, $value['value']); return array('scalarresult_id' => $scalarResult->getScalarresultId()); }