/** @return ItempolicyuserDao */
public function createPolicy($user, $item, $policy)
{
if (!$user instanceof UserDao) {
throw new Zend_Exception('Should be a user.');
}
if (!$item instanceof ItemDao) {
throw new Zend_Exception('Should be an item.');
}
if (!is_numeric($policy)) {
throw new Zend_Exception('Should be a number.');
}
if (!$user->saved && !$item->saved) {
throw new Zend_Exception('Save the daos first.');
}
$policyUser = $this->getPolicy($user, $item);
if ($policyUser !== false) {
$this->delete($policyUser);
}
/** @var ItempolicyuserDao $policyUser */
$policyUser = MidasLoader::newDao('ItempolicyuserDao');
$policyUser->setUserId($user->getUserId());
$policyUser->setItemId($item->getItemId());
$policyUser->setPolicy($policy);
$this->save($policyUser);
return $policyUser;
}
/**
* Call this function to acquire the download lock.
* This will return false if an active download already exists for
* this ip address, otherwise it will return the active download
* lock that was created.
*/
public function acquireLock()
{
$ip = $_SERVER['REMOTE_ADDR'];
if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
$ip .= '_' . $_SERVER['HTTP_X_FORWARDED_FOR'];
}
$oldLock = $this->getByIp($ip);
if ($oldLock !== false) {
// If an old lock exists but has not been updated in more than 5 minutes, we
// should release the old lock and create a new one.
$lastUpdate = strtotime($oldLock->getLastUpdate());
if (time() > $lastUpdate + 300) {
$this->delete($oldLock);
} else {
return false;
}
}
/** @var ActivedownloadDao $activeDownload */
$activeDownload = MidasLoader::newDao('ActivedownloadDao');
$activeDownload->setDateCreation(date('Y-m-d H:i:s'));
$activeDownload->setLastUpdate(date('Y-m-d H:i:s'));
$activeDownload->setIp($ip);
$this->save($activeDownload);
return $activeDownload;
}
/**
* Schedule the perform cleanup job.
*
* @param int $days days to keep partial files
* @param string $tempDirectory temporary directory
* @param null|UserDao $userDao user scheduling the job
*/
public function schedulePerformCleanupJob($days, $tempDirectory, $userDao = null)
{
/** @var Scheduler_JobModel $jobModel */
$jobModel = MidasLoader::loadModel('Job', 'scheduler');
$jobDaos = $jobModel->getJobsByTask('TASK_CLEANUP_PERFORM_CLEANUP');
$cleanupJobDao = false;
foreach ($jobDaos as $jobDao) {
if ($jobDao->getTask() === 'TASK_CLEANUP_PERFORM_CLEANUP') {
$cleanupJobDao = $jobDao;
break;
}
}
if ($cleanupJobDao === false) {
/** @var Scheduler_JobDao $cleanupJobDao */
$cleanupJobDao = MidasLoader::newDao('JobDao', 'scheduler');
$cleanupJobDao->setTask('TASK_CLEANUP_PERFORM_CLEANUP');
$cleanupJobDao->setPriority(1);
$cleanupJobDao->setRunOnlyOnce(0);
$cleanupJobDao->setFireTime(date('Y-m-d', strtotime('+1 day' . date('Y-m-d H:i:s'))) . ' 01:00:00');
$cleanupJobDao->setTimeInterval(86400);
$cleanupJobDao->setStatus(SCHEDULER_JOB_STATUS_TORUN);
if (!is_null($userDao)) {
$cleanupJobDao->setCreatorId($userDao->getKey());
}
}
$cleanupJobDao->setParams(JsonComponent::encode(array('days' => $days, 'tempDirectory' => $tempDirectory)));
$jobModel->save($cleanupJobDao);
}
/** create a policy
* @return FolderpolicygroupDao
*/
public function createPolicy($group, $folder, $policy)
{
if (!$group instanceof GroupDao) {
throw new Zend_Exception('Should be a group.');
}
if (!$folder instanceof FolderDao) {
throw new Zend_Exception('Should be a folder.');
}
if (!is_numeric($policy)) {
throw new Zend_Exception('Should be a number.');
}
if (!$group->saved && !$folder->saved) {
throw new Zend_Exception('Save the daos first.');
}
$policyGroupDao = $this->getPolicy($group, $folder);
if ($policyGroupDao !== false) {
$this->delete($policyGroupDao);
}
/** @var FolderpolicygroupDao $policyGroupDao */
$policyGroupDao = MidasLoader::newDao('FolderpolicygroupDao');
$policyGroupDao->setGroupId($group->getGroupId());
$policyGroupDao->setFolderId($folder->getFolderId());
$policyGroupDao->setPolicy($policy);
$this->save($policyGroupDao);
if ($policyGroupDao->getGroupId() == MIDAS_GROUP_ANONYMOUS_KEY) {
$this->computePolicyStatus($folder);
}
return $policyGroupDao;
}
/**
* Test that we receive the correct daily totals from our model.
*/
public function testDailyTotals()
{
/** @var Statistics_DownloadModel $downloadModel */
$downloadModel = MidasLoader::loadModel('Download', 'statistics');
// Add 50 downloads 3 days ago
for ($i = 0; $i < 50; ++$i) {
/** @var Statistics_DownloadDao $dao */
$dao = MidasLoader::newDao('DownloadDao', 'statistics');
$dao->setItemId(7);
$dao->setIpLocationId(1);
$dao->setDate(date('Y-m-d 01:' . str_pad($i, 2, '0', STR_PAD_LEFT) . ':00', strtotime('-3 day')));
$downloadModel->save($dao);
}
// Add 20 downloads 2 days ago
for ($i = 0; $i < 20; ++$i) {
/** @var Statistics_DownloadDao $dao */
$dao = MidasLoader::newDao('DownloadDao', 'statistics');
$dao->setItemId(7);
$dao->setIpLocationId(1);
$dao->setDate(date('Y-m-d 01:' . str_pad($i, 2, '0', STR_PAD_LEFT) . ':00', strtotime('-2 day')));
$downloadModel->save($dao);
}
$arrayDownload = $downloadModel->getDailyCounts(array(7), date('Y-m-d H:i:s', strtotime('-20 day' . date('Y-m-d G:i:s'))), date('Y-m-d H:i:s'));
$this->assertEquals(count($arrayDownload), 2);
$this->assertEquals($arrayDownload[date('Y-m-d', strtotime('-3 day'))], 50);
$this->assertEquals($arrayDownload[date('Y-m-d', strtotime('-2 day'))], 20);
}
/**
* Schedule or cancel the send report job.
*
* @param bool $schedule schedule the job if true, cancel the job if false
* @param null|UserDao $userDao user scheduling the job
*
* @throws Zend_Exception
*/
public function scheduleOrCancelSendReportJob($schedule, $userDao = null)
{
/** @var Scheduler_JobModel $jobModel */
$jobModel = MidasLoader::loadModel('Job', 'scheduler');
$jobDaos = $jobModel->getJobsByTask('TASK_STATISTICS_SEND_REPORT');
$reportJobDao = false;
foreach ($jobDaos as $jobDao) {
if ($jobDao->getTask() === 'TASK_STATISTICS_SEND_REPORT') {
$reportJobDao = $jobDao;
break;
}
}
if ($schedule) {
if ($reportJobDao === false) {
/** @var Scheduler_JobDao $reportJobDao */
$reportJobDao = MidasLoader::newDao('JobDao', 'scheduler');
$reportJobDao->setTask('TASK_STATISTICS_SEND_REPORT');
$reportJobDao->setPriority(1);
$reportJobDao->setRunOnlyOnce(0);
$reportJobDao->setFireTime(date('Y-m-d', strtotime('+1 day' . date('Y-m-d H:i:s'))) . ' 01:00:00');
$reportJobDao->setTimeInterval(86400);
$reportJobDao->setStatus(SCHEDULER_JOB_STATUS_TORUN);
$reportJobDao->setCreatorId($this->userSession->Dao->getKey());
$reportJobDao->setParams(JsonComponent::encode(array()));
if (!is_null($userDao)) {
$reportJobDao->setCreatorId($userDao->getKey());
}
$jobModel->save($reportJobDao);
}
} else {
if ($reportJobDao !== false) {
$jobModel->delete($reportJobDao);
}
}
}
/**
* Create a thumbnail bitstream in the provided assetstore using the
* passed tempThumbnailFile, which will be moved to the assetstore.
*
* @return The bitstream dao that was created for the thumbnail
*/
public function createThumbnail($assetstore, $tempThumbnailFile)
{
/** @var BitstreamDao $bitstreamDao */
$bitstreamDao = MidasLoader::newDao('BitstreamDao');
$md5 = md5_file($tempThumbnailFile);
$bitstreamDao->setName('thumbnail.jpeg');
$bitstreamDao->setItemrevisionId(-1);
//-1 indicates this does not belong to any revision
$bitstreamDao->setMimetype('image/jpeg');
$bitstreamDao->setSizebytes(filesize($tempThumbnailFile));
$bitstreamDao->setDate(date('Y-m-d H:i:s'));
$bitstreamDao->setChecksum($md5);
$existing = $this->getByChecksum($md5);
if ($existing) {
unlink($tempThumbnailFile);
$bitstreamDao->setPath($existing->getPath());
$bitstreamDao->setAssetstoreId($existing->getAssetstoreId());
} else {
$path = substr($md5, 0, 2) . '/' . substr($md5, 2, 2) . '/' . $md5;
$fullpath = $assetstore->getPath() . '/' . $path;
$currentdir = $assetstore->getPath() . '/' . substr($md5, 0, 2);
$this->_createAssetstoreDirectory($currentdir);
$currentdir .= '/' . substr($md5, 2, 2);
$this->_createAssetstoreDirectory($currentdir);
rename($tempThumbnailFile, $fullpath);
$bitstreamDao->setAssetstoreId($assetstore->getKey());
$bitstreamDao->setPath($path);
}
$this->save($bitstreamDao);
return $bitstreamDao;
}
/** create a policy
* @return FeedpolicyuserDao
*/
public function createPolicy($user, $feed, $policy)
{
if (!$user instanceof UserDao) {
throw new Zend_Exception('Should be a user.');
}
if (!$feed instanceof FeedDao) {
throw new Zend_Exception('Should be a feed.');
}
if (!is_numeric($policy)) {
throw new Zend_Exception('Should be a number.');
}
if (!$user->saved && !$feed->saved) {
throw new Zend_Exception('Save the daos first.');
}
if ($this->getPolicy($user, $feed) !== false) {
$this->delete($this->getPolicy($user, $feed));
}
/** @var FeedpolicyuserDao $policyUser */
$policyUser = MidasLoader::newDao('FeedpolicyuserDao');
$policyUser->setUserId($user->getUserId());
$policyUser->setFeedId($feed->getFeedId());
$policyUser->setPolicy($policy);
$this->save($policyUser);
return $policyUser;
}
/** add a download record for the given item */
public function addDownload($item, $user)
{
if (!$item instanceof ItemDao) {
throw new Zend_Exception('Error: item parameter is not an item dao');
}
$userAgent = array_key_exists('HTTP_USER_AGENT', $_SERVER) ? $_SERVER['HTTP_USER_AGENT'] : '';
$ip = $_SERVER['REMOTE_ADDR'];
if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
$ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
}
/** @var Statistics_IpLocationModel $ipLocationModel */
$ipLocationModel = MidasLoader::loadModel('IpLocation', 'statistics');
$ipLocation = $ipLocationModel->getByIp($ip);
if ($ipLocation == false) {
/** @var Statistics_IpLocationDao $ipLocation */
$ipLocation = MidasLoader::newDao('IpLocationDao', 'statistics');
$ipLocation->setIp($ip);
// we will perform the geolocation later, since it can be slow
$ipLocation->setLatitude('');
$ipLocation->setLongitude('');
$ipLocationModel->save($ipLocation);
}
/** @var Statistics_DownloadDao $download */
$download = MidasLoader::newDao('DownloadDao', 'statistics');
$download->setItemId($item->getKey());
$download->setIpLocationId($ipLocation->getKey());
$download->setDate(date('Y-m-d H:i:s'));
$download->setUserAgent($userAgent);
if ($user instanceof UserDao) {
$download->setUserId($user->getKey());
}
$this->save($download);
}
/**
* 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;
}
/** create a policy
* @return FeedpolicygroupDao
*/
public function createPolicy($group, $feed, $policy)
{
if (!$group instanceof GroupDao) {
throw new Zend_Exception('Should be a group.');
}
if (!$feed instanceof FeedDao) {
throw new Zend_Exception('Should be a feedDao.');
}
if (!is_numeric($policy)) {
throw new Zend_Exception('Should be a number.');
}
if (!$group->saved && !$feed->saved) {
throw new Zend_Exception('Save the daos first.');
}
if ($this->getPolicy($group, $feed) !== false) {
$this->delete($this->getPolicy($group, $feed));
}
/** @var FeedpolicygroupDao $policyGroupDao */
$policyGroupDao = MidasLoader::newDao('FeedpolicygroupDao');
$policyGroupDao->setGroupId($group->getGroupId());
$policyGroupDao->setFeedId($feed->getFeedId());
$policyGroupDao->setPolicy($policy);
$this->save($policyGroupDao);
return $policyGroupDao;
}
/**
* Register an item.
*
* @param string $item_id
* @return Dicomserver_RegistrationDao
*/
public function createRegistration($item_id)
{
/** @var Dicomserver_RegistrationDao $registrationDao */
$registrationDao = MidasLoader::newDao('RegistrationDao', 'dicomserver');
$registrationDao->setItemId($item_id);
$this->save($registrationDao);
return $registrationDao;
}
/**
* Create a community agreement.
*
* @param string $community_id
* @param string $agreement
* @return Communityagreement_AgreementDao
*/
public function createAgreement($community_id, $agreement)
{
/** @var Communityagreement_AgreementDao $agreementDao */
$agreementDao = MidasLoader::newDao('AgreementDao', 'communityagreement');
$agreementDao->setCommunityId($community_id);
$agreementDao->setAgreement($agreement);
$this->save($agreementDao);
return $agreementDao;
}
/** save logs */
public function saveLog($jobDao, $text)
{
/** @var Scheduler_JobLogDao $joblog */
$joblog = MidasLoader::newDao('JobLogDao', 'scheduler');
$joblog->setJobId($jobDao->getKey());
$joblog->setDate(date('Y-m-d H:i:s'));
$joblog->setLog($text);
$this->save($joblog);
}
/** Create a wallet
* @return WalletDao
*/
public function createWallet($userDao, $dollars)
{
/** @var Example_WalletDao $wallet */
$wallet = MidasLoader::newDao('WalletDao', 'example');
$wallet->setUserId($userDao->getKey());
$wallet->setDollars($dollars);
$this->save($wallet);
return $wallet;
}
/**
* Create a new record of a user who authenticates via google auth.
*
* @param $user The user dao representing this user's information
* @param $googlePersonId The unique identifier value for the google user
* @return The created googleauth_user dao.
*/
public function createGoogleUser($user, $googlePersonId)
{
/** @var Googleauth_UserDao $guserDao */
$guserDao = MidasLoader::newDao('UserDao', 'googleauth');
$guserDao->setUserId($user->getKey());
$guserDao->setGooglePersonId($googlePersonId);
$this->save($guserDao);
return $guserDao;
}
/**
* Create a temporary token that will be used to fetch the user's real API token later.
*
* @param UserDao $user user to create the token for
* @param TokenDao $tokenDao token DAO
* @return Mfa_ApitokenDao
* @throws Zend_Exception
*/
public function createTempToken($user, $tokenDao)
{
/** @var Mfa_ApitokenDao $newToken */
$newToken = MidasLoader::newDao('ApitokenDao', 'mfa');
$newToken->setUserId($user->getKey());
$newToken->setTokenId($tokenDao->getKey());
$newToken->setCreationDate(date('Y-m-d H:i:s'));
$this->save($newToken);
return $newToken;
}
/** Add a comment to an item */
public function addComment($user, $item, $comment)
{
/** @var Comments_ItemcommentDao $commentDao */
$commentDao = MidasLoader::newDao('ItemcommentDao', 'comments');
$commentDao->setUserId($user->getKey());
$commentDao->setItemId($item->getKey());
$commentDao->setComment($comment);
$this->save($commentDao);
Zend_Registry::get('notifier')->callback('CALLBACK_COMMENTS_ADDED_COMMENT', array('comment' => $commentDao));
}
/**
* Enable or disable the community as a package-hosting project.
*
* @param community The community dao
* @param $value Boolean value for whether or not the community is a package-hosting project
*/
public function setEnabled($community, $value)
{
$project = $this->getByCommunityId($community->getKey());
if (!$project) {
/** @var Packages_ProjectDao $project */
$project = MidasLoader::newDao('ProjectDao', $this->moduleName);
$project->setCommunityId($community->getKey());
}
$project->setEnabled($value ? 1 : 0);
$this->save($project);
}
/**
* Create a new progress record beginning with the current value equal to 0.
*
* @param int $max maximum value of the progress (default is 0 for indeterminate)
* @param string $message initial progress message (default is empty)
* @return ProgressDao progress DAO
*/
public function createProgress($max = 0, $message = '')
{
/** @var ProgressDao $progress */
$progress = MidasLoader::newDao('ProgressDao');
$progress->setCurrent(0);
$progress->setMaximum($max);
$progress->setMessage($message);
$progress->setDateCreation(date('Y-m-d H:i:s'));
$progress->setLastUpdate(date('Y-m-d H:i:s'));
$this->save($progress);
return $progress;
}
/**
* Create a big thumbnail for the given bitstream with the given width. It is used as the main image of the given item and shown in the item view page.
*
* @path /thumbnailcreator/item/bigthumbnail/{id}
* @http PUT
* @param bitstreamId The bitstream to create the thumbnail from
* @param id The item to set the thumbnail on
* @param width (Optional) The width in pixels to resize to (aspect ratio will be preserved). Defaults to 575
* @return The ItemthumbnailDao object that was created
*
* @param array $args parameters
* @throws Exception
*/
public function createBigThumbnail($args)
{
/** @var ApihelperComponent $apihelperComponent */
$apihelperComponent = MidasLoader::loadComponent('Apihelper');
$apihelperComponent->renameParamKey($args, 'itemId', 'id', false);
$apihelperComponent->validateParams($args, array('id'));
/** @var Thumbnailcreator_ImagemagickComponent $imComponent */
$imComponent = MidasLoader::loadComponent('Imagemagick', 'thumbnailcreator');
/** @var AuthenticationComponent $authComponent */
$authComponent = MidasLoader::loadComponent('Authentication');
$userDao = $authComponent->getUser($args, Zend_Registry::get('userSession')->Dao);
$itemId = $args['id'];
$bitstreamId = $args['bitstreamId'];
$width = '575';
if (isset($args['width'])) {
$width = $args['width'];
}
/** @var BitstreamModel $bitstreamModel */
$bitstreamModel = MidasLoader::loadModel('Bitstream');
/** @var ItemModel $itemModel */
$itemModel = MidasLoader::loadModel('Item');
/** @var Thumbnailcreator_ItemthumbnailModel $itemthumbnailModel */
$itemthumbnailModel = MidasLoader::loadModel('Itemthumbnail', 'thumbnailcreator');
$bitstream = $bitstreamModel->load($bitstreamId);
$item = $itemModel->load($itemId);
if (!$itemModel->policyCheck($item, $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);
}
$itemThumbnail = $itemthumbnailModel->getByItemId($item->getKey());
if (!$itemThumbnail) {
/** @var Thumbnailcreator_ItemthumbnailDao $itemThumbnail */
$itemThumbnail = MidasLoader::newDao('ItemthumbnailDao', 'thumbnailcreator');
$itemThumbnail->setItemId($item->getKey());
} else {
$oldThumb = $bitstreamModel->load($itemThumbnail->getThumbnailId());
$bitstreamModel->delete($oldThumb);
}
try {
$thumbnail = $imComponent->createThumbnailFromPath($bitstream->getName(), $bitstream->getFullPath(), (int) $width, 0, false);
if (!file_exists($thumbnail)) {
throw new Exception('Could not create thumbnail from the bitstream', MIDAS_INTERNAL_ERROR);
}
/** @var AssetstoreModel $assetstoreModel */
$assetstoreModel = MidasLoader::loadModel('Assetstore');
$thumb = $bitstreamModel->createThumbnail($assetstoreModel->getDefault(), $thumbnail);
$itemThumbnail->setThumbnailId($thumb->getKey());
$itemthumbnailModel->save($itemThumbnail);
return $itemThumbnail->toArray();
} catch (Exception $e) {
throw new Exception($e->getMessage(), MIDAS_INTERNAL_ERROR);
}
}
/**
* Create an item metric.
*
* @param string $metricName
* @param string $bmsName
* @return Batchmake_ItemmetricDao
* @throws Zend_Exception if an item metric already exists with this metric name
*/
public function createItemmetric($metricName, $bmsName)
{
/** @var Batchmake_ItemmetricDao $itemmetric */
$itemmetric = MidasLoader::newDao('ItemmetricDao', 'batchmake');
// make sure one isn't already there by this name
$found = $this->findBy('metric_name', $metricName);
if (isset($found) && count($found) > 0) {
// don't allow the creation, as we have a metric of this name already
throw new Zend_Exception('An Itemmetric already exists with that name');
}
$itemmetric->setMetricName($metricName);
$itemmetric->setBmsName($bmsName);
$this->save($itemmetric);
return $itemmetric;
}
/**
* Create a new ldap user and an underlying core user entry.
*
* @param ldapLogin What the user uses to actually login to the ldap
* @param email The user's email (because it might be different from ldap login)
* @param password The user's password (not stored, just used to generate initial default api key)
* @param firstName User's first name
* @param lastName User's last name
* @return The ldap user dao that was created
*/
public function createLdapUser($ldapLogin, $email, $password, $firstName, $lastName)
{
/** @var UserModel $userModel */
$userModel = MidasLoader::loadModel('User');
$userDao = $userModel->createUser($email, $password, $firstName, $lastName);
$userDao->setSalt('x');
// place invalid salt so normal authentication will fail
$userModel->save($userDao);
/** @var Ldap_UserDao $ldapUserDao */
$ldapUserDao = MidasLoader::newDao('UserDao', 'ldap');
$ldapUserDao->setUserId($userDao->getKey());
$ldapUserDao->setLogin($ldapLogin);
$this->save($ldapUserDao);
return $ldapUserDao;
}
/** Add a metadata
* @return MetadataDao
*/
public function addMetadata($type, $element, $qualifier, $description = null)
{
// Gets the metadata
$metadata = $this->getMetadata($type, $element, $qualifier);
if ($metadata) {
throw new Zend_Exception('Metadata already exists.');
}
/** @var MetadataDao $metadataDao */
$metadataDao = MidasLoader::newDao('MetadataDao');
$metadataDao->setMetadatatype($type);
$metadataDao->setElement($element);
$metadataDao->setQualifier($qualifier);
$this->save($metadataDao);
return $metadataDao;
}
/** Index action */
public function indexAction()
{
$this->requireAdminPrivileges();
$this->view->pageTitle = 'Landing Page Module Configuration';
$form = new Landingpage_Form_Admin();
$textDaos = $this->Landingpage_Text->getAll();
if ($this->getRequest()->isPost()) {
$data = $this->getRequest()->getPost();
if ($form->isValid($data)) {
$values = $form->getValues();
if (count($textDaos) > 0) {
$textDao = $textDaos[0];
} else {
/** @var Landingpage_TextDao $textDao */
$textDao = MidasLoader::newDao('Text', $this->moduleName);
}
$textDao->setText($values[LANDINGPAGE_TEXT_KEY]);
$this->Landingpage_Text->save($textDao);
unset($values[LANDINGPAGE_TEXT_KEY]);
foreach ($values as $key => $value) {
if ($key !== 'csrf' && !is_null($value)) {
$this->Setting->setConfig($key, $value, $this->moduleName);
}
}
}
$form->populate($data);
} else {
$elements = $form->getElements();
foreach ($elements as $element) {
$name = $element->getName();
if ($name === LANDINGPAGE_TEXT_KEY) {
if (count($textDaos) > 0) {
$value = $textDaos[0]->getText();
$form->setDefault($name, $value);
}
} elseif ($name !== 'csrf' && $name !== 'submit') {
$value = $this->Setting->getValueByName($name, $this->moduleName);
if (!is_null($value)) {
$form->setDefault($name, $value);
}
}
}
}
$this->view->form = $form;
session_start();
}
/**
* Create a task.
*
* @param UserDao $userDao
* @param string $tmpWorkDirRoot
* @return Batchmake_TaskDao
* @throws Zend_Exception
*/
public function createTask($userDao, $tmpWorkDirRoot)
{
if (!$userDao instanceof UserDao) {
throw new Zend_Exception('Error parameters.');
}
/** @var Batchmake_TaskDao $task */
$task = MidasLoader::newDao('TaskDao', 'batchmake');
$task->setUserId($userDao->getKey());
$this->save($task);
$userId = $task->getUserId();
$taskId = $task->getKey();
$subdirs = array(MIDAS_BATCHMAKE_SSP_DIR, $userId, $taskId);
// create a workDir based on the task and user
$workDir = KWUtils::createSubDirectories($tmpWorkDirRoot . '/', $subdirs);
$task->setWorkDir($workDir);
$this->save($task);
return $task;
}
/**
* Add scheduled tasks for notifying users that a threshold was crossed.
*
* @param Tracker_ScalarDao $scalarDao scalar DAO
* @param array $thresholdNotificationDaos threshold notification DAOs
*/
public function scheduleNotifications($scalarDao, $thresholdNotificationDaos)
{
/** @var Scheduler_JobModel $jobModel */
$jobModel = MidasLoader::loadModel('Job', 'scheduler');
/** @var Tracker_ThresholdNotificationDao $thresholdNotificationDao */
foreach ($thresholdNotificationDaos as $thresholdNotificationDao) {
/** @var Scheduler_JobDao $jobDao */
$jobDao = MidasLoader::newDao('JobDao', 'scheduler');
$jobDao->setTask('TASK_TRACKER_SEND_THRESHOLD_NOTIFICATION');
$jobDao->setPriority(1);
$jobDao->setRunOnlyOnce(1);
$jobDao->setFireTime(date('Y-m-d H:i:s'));
$jobDao->setTimeInterval(0);
$jobDao->setStatus(SCHEDULER_JOB_STATUS_TORUN);
$jobDao->setCreatorId($thresholdNotificationDao->getRecipientId());
$jobDao->setParams(JsonComponent::encode(array('notification' => $thresholdNotificationDao, 'scalar' => $scalarDao)));
$jobModel->save($jobDao);
}
}
/**
* 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;
}
/**
* Set the rating on an item for a user (overwrites if already exists)
* If a 0 rating is passed, any existing rating will be removed.
*/
public function setRating($user, $item, $rating)
{
$row = $this->database->fetchRow($this->database->select()->where('item_id = ?', $item->getKey())->where('user_id = ?', $user->getKey()));
$dao = $this->initDao('Itemrating', $row, 'ratings');
if ($dao == null) {
if ($rating == 0) {
return;
// no need to save this rating at all
}
/** @var Ratings_ItemratingDao $dao */
$dao = MidasLoader::newDao('ItemratingDao', 'ratings');
$dao->setUserId($user->getKey());
$dao->setItemId($item->getKey());
} elseif ($rating == 0) {
$this->delete($dao);
return;
}
$dao->setRating($rating);
$this->save($dao);
}
/**
* Create an invitation record for the user into the given group.
*
* @param GroupDao $groupDao The group to invite the user to
* @param UserDao $userDao The user performing the invitation (typically the session user)
* @param UserDao $invitedUserDao The user being invited to the group
* @return false|CommunityInvitationDao
* @throws Zend_Exception
*/
public function createInvitation($groupDao, $userDao, $invitedUserDao)
{
$communityDao = $groupDao->getCommunity();
$invitations = $invitedUserDao->getInvitations();
foreach ($invitations as $invitation) {
if ($invitation->getCommunityId() == $communityDao->getKey()) {
return false;
}
}
/** @var CommunityInvitationDao $invitationDao */
$invitationDao = MidasLoader::newDao('CommunityInvitationDao');
$invitationDao->setCommunityId($communityDao->getKey());
$invitationDao->setGroupId($groupDao->getKey());
$invitationDao->setUserId($invitedUserDao->getKey());
$this->save($invitationDao);
/** @var FeedModel $feedModel */
$feedModel = MidasLoader::loadModel('Feed');
/** @var FeedpolicyuserModel $feedpolicyuserModel */
$feedpolicyuserModel = MidasLoader::loadModel('Feedpolicyuser');
$feed = $feedModel->createFeed($userDao, MIDAS_FEED_COMMUNITY_INVITATION, $invitationDao, $communityDao);
$feedpolicyuserModel->createPolicy($invitedUserDao, $feed, MIDAS_POLICY_ADMIN);
return $invitationDao;
}
