function _cacheMiss(&$cache, $id) { $allCodelistItems =& Registry::get('all' . $this->getListName() . 'CodelistItems', true, null); if ($allCodelistItems === null) { // Add a locale load to the debug notes. $notes =& Registry::get('system.debug.notes'); $locale = $cache->cacheId; if ($locale == null) { $locale = AppLocale::getLocale(); } $filename = $this->getFilename($locale); $notes[] = array('debug.notes.codelistItemListLoad', array('filename' => $filename)); // Reload locale registry file $xmlDao = new XMLDAO(); $listName = $this->getListName(); // i.e., 'List30' import('lib.pkp.classes.codelist.ONIXParserDOMHandler'); $handler = new ONIXParserDOMHandler($listName); import('lib.pkp.classes.xslt.XSLTransformer'); import('lib.pkp.classes.file.FileManager'); import('classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $fileManager = new FileManager(); // Ensure that the temporary file dir exists $tmpDir = $temporaryFileManager->getBasePath(); if (!file_exists($tmpDir)) { mkdir($tmpDir); } $tmpName = tempnam($tmpDir, 'ONX'); $xslTransformer = new XSLTransformer(); $xslTransformer->setParameters(array('listName' => $listName)); $xslTransformer->setRegisterPHPFunctions(true); $xslFile = 'lib/pkp/xml/onixFilter.xsl'; $filteredXml = $xslTransformer->transform($filename, XSL_TRANSFORMER_DOCTYPE_FILE, $xslFile, XSL_TRANSFORMER_DOCTYPE_FILE, XSL_TRANSFORMER_DOCTYPE_STRING); if (!$filteredXml) { assert(false); } $data = null; if (is_writeable($tmpName)) { $fp = fopen($tmpName, 'wb'); fwrite($fp, $filteredXml); fclose($fp); $data = $xmlDao->parseWithHandler($tmpName, $handler); $fileManager->deleteFile($tmpName); } else { fatalError('misconfigured directory permissions on: ' . $tmpDir); } // Build array with ($charKey => array(stuff)) if (isset($data[$listName])) { foreach ($data[$listName] as $code => $codelistData) { $allCodelistItems[$code] = $codelistData; } } if (is_array($allCodelistItems)) { asort($allCodelistItems); } $cache->setEntireCache($allCodelistItems); } return null; }
/** * Upload a new cover image file. * @param $args array * @param $request PKPRequest * @return JSONMessage JSON object */ function uploadCoverImage($args, $request) { $user = $request->getUser(); import('lib.pkp.classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFile = $temporaryFileManager->handleUpload('uploadedFile', $user->getId()); if ($temporaryFile) { $json = new JSONMessage(true); $json->setAdditionalAttributes(array('temporaryFileId' => $temporaryFile->getId())); return $json; } else { return new JSONMessage(false, __('common.uploadFailed')); } }
/** * Create a new temporary file from a paper file. * @param $paperFile object * @param $userId int * @return object The new TemporaryFile or false on failure */ function paperToTemporaryFile($paperFile, $userId) { // Get the file extension, then rename the file. $fileExtension = $this->parseFileExtension($paperFile->getFileName()); if (!$this->fileExists($this->filesDir, 'dir')) { // Try to create destination directory $this->mkdirtree($this->filesDir); } $newFileName = basename(tempnam($this->filesDir, $fileExtension)); if (!$newFileName) { return false; } if (copy($paperFile->getFilePath(), $this->filesDir . $newFileName)) { $temporaryFileDao =& DAORegistry::getDAO('TemporaryFileDAO'); $temporaryFile = new TemporaryFile(); $temporaryFile->setUserId($userId); $temporaryFile->setFileName($newFileName); $temporaryFile->setFileType($paperFile->getFileType()); $temporaryFile->setFileSize($paperFile->getFileSize()); $temporaryFile->setOriginalFileName(TemporaryFileManager::truncateFileName($paperFile->getOriginalFileName(), 127)); $temporaryFile->setDateUploaded(Core::getCurrentDate()); $temporaryFileDao->insertTemporaryFile($temporaryFile); return $temporaryFile; } else { return false; } }
function display(&$args, $request) { parent::display($args, $request); $templateMgr =& TemplateManager::getManager(); $journal =& $request->getJournal(); switch (array_shift($args)) { case 'export': @set_time_limit(0); $errors = array(); $success = $this->handleExport($journal, $errors); if ($success === false) { return $errors; } break; case 'import': AppLocale::requireComponents(LOCALE_COMPONENT_OJS_EDITOR, LOCALE_COMPONENT_OJS_AUTHOR); import('classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); if ($existingFileId = $request->getUserVar('temporaryFileId')) { // The user has just entered more context. Fetch an existing file. $temporaryFile = $temporaryFileManager->getFile($existingFileId, $user->getId()); } else { $user = Request::getUser(); $temporaryFile = $temporaryFileManager->handleUpload('importFile', $user->getId()); } if (!$temporaryFile) { $templateMgr->assign('error', 'plugins.importexport.fullJournal.error.uploadFailed'); return $templateMgr->display($this->getTemplatePath() . 'importError.tpl'); } @set_time_limit(0); $errors = array(); if ($this->handleImport($temporaryFile->getFilePath(), $errors)) { return $templateMgr->display($this->getTemplatePath() . 'importSuccess.tpl'); } else { $templateMgr->assign_by_ref('errors', $errors); return $templateMgr->display($this->getTemplatePath() . 'importError.tpl'); } break; default: $this->setBreadcrumbs(); $templateMgr->display($this->getTemplatePath() . 'index.tpl'); } }
/** * Save the new library file * @param $userId int The current user ID (for validation purposes) */ function execute($userId) { // Fetch the temporary file storing the uploaded library file $temporaryFileDao =& DAORegistry::getDAO('TemporaryFileDAO'); $temporaryFile =& $temporaryFileDao->getTemporaryFile($this->getData('temporaryFileId'), $userId); $libraryFileDao =& DAORegistry::getDAO('LibraryFileDAO'); $libraryFileManager = new LibraryFileManager($this->pressId); // Convert the temporary file to a library file and store $libraryFile =& $libraryFileManager->copyFromTemporaryFile($temporaryFile); assert($libraryFile); $libraryFile->setPressId($this->pressId); $libraryFile->setName($this->getData('libraryFileName'), null); // Localized $libraryFile->setType($this->fileType); $libraryFileDao->insertObject($libraryFile); // Clean up the temporary file import('classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFileManager->deleteFile($this->getData('temporaryFileId'), $userId); }
/** * Save the new library file. * @param $userId int The current user ID (for validation purposes). * @return $fileId int The new library file id. */ function execute($userId) { // Fetch the temporary file storing the uploaded library file $temporaryFileDao = DAORegistry::getDAO('TemporaryFileDAO'); $temporaryFile = $temporaryFileDao->getTemporaryFile($this->getData('temporaryFileId'), $userId); $libraryFileDao = DAORegistry::getDAO('LibraryFileDAO'); $libraryFileManager = new LibraryFileManager($this->contextId); // Convert the temporary file to a library file and store $libraryFile = $libraryFileManager->copyFromTemporaryFile($temporaryFile, $this->getData('fileType')); assert(isset($libraryFile)); $libraryFile->setContextId($this->contextId); $libraryFile->setName($this->getData('libraryFileName'), null); // Localized $libraryFile->setType($this->getData('fileType')); $fileId = $libraryFileDao->insertObject($libraryFile); // Clean up the temporary file import('lib.pkp.classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFileManager->deleteFile($this->getData('temporaryFileId'), $userId); return $fileId; }
/** * Save the metadata and store the catalog data for this published * monograph. */ function execute($request) { parent::execute(); $monograph = $this->getMonograph(); $monographDao = DAORegistry::getDAO('MonographDAO'); $publishedMonographDao = DAORegistry::getDAO('PublishedMonographDAO'); $publishedMonograph = $publishedMonographDao->getById($monograph->getId(), null, false); /* @var $publishedMonograph PublishedMonograph */ $isExistingEntry = $publishedMonograph ? true : false; if (!$publishedMonograph) { $publishedMonograph = $publishedMonographDao->newDataObject(); $publishedMonograph->setId($monograph->getId()); } // Populate the published monograph with the cataloging metadata $publishedMonograph->setAudience($this->getData('audience')); $publishedMonograph->setAudienceRangeQualifier($this->getData('audienceRangeQualifier')); $publishedMonograph->setAudienceRangeFrom($this->getData('audienceRangeFrom')); $publishedMonograph->setAudienceRangeTo($this->getData('audienceRangeTo')); $publishedMonograph->setAudienceRangeExact($this->getData('audienceRangeExact')); // If a cover image was uploaded, deal with it. if ($temporaryFileId = $this->getData('temporaryFileId')) { // Fetch the temporary file storing the uploaded library file $temporaryFileDao = DAORegistry::getDAO('TemporaryFileDAO'); $temporaryFile = $temporaryFileDao->getTemporaryFile($temporaryFileId, $this->_userId); $temporaryFilePath = $temporaryFile->getFilePath(); import('classes.file.SimpleMonographFileManager'); $simpleMonographFileManager = new SimpleMonographFileManager($monograph->getPressId(), $publishedMonograph->getId()); $basePath = $simpleMonographFileManager->getBasePath(); // Delete the old file if it exists $oldSetting = $publishedMonograph->getCoverImage(); if ($oldSetting) { $simpleMonographFileManager->deleteFile($basePath . $oldSetting['thumbnailName']); $simpleMonographFileManager->deleteFile($basePath . $oldSetting['catalogName']); $simpleMonographFileManager->deleteFile($basePath . $oldSetting['name']); } // The following variables were fetched in validation assert($this->_sizeArray && $this->_imageExtension); // Load the cover image for surrogate production $cover = null; // Scrutinizer switch ($this->_imageExtension) { case '.jpg': $cover = imagecreatefromjpeg($temporaryFilePath); break; case '.png': $cover = imagecreatefrompng($temporaryFilePath); break; case '.gif': $cover = imagecreatefromgif($temporaryFilePath); break; } assert(isset($cover)); // Copy the new file over (involves creating the appropriate subdirectory too) $filename = 'cover' . $this->_imageExtension; $simpleMonographFileManager->copyFile($temporaryFile->getFilePath(), $basePath . $filename); // Generate surrogate images (thumbnail and catalog image) $press = $request->getPress(); $coverThumbnailsMaxWidth = $press->getSetting('coverThumbnailsMaxWidth'); $coverThumbnailsMaxHeight = $press->getSetting('coverThumbnailsMaxHeight'); $thumbnailImageInfo = $this->_buildSurrogateImage($cover, $basePath, SUBMISSION_IMAGE_TYPE_THUMBNAIL, $coverThumbnailsMaxWidth, $coverThumbnailsMaxHeight); $catalogImageInfo = $this->_buildSurrogateImage($cover, $basePath, SUBMISSION_IMAGE_TYPE_CATALOG); // Clean up imagedestroy($cover); $publishedMonograph->setCoverImage(array('name' => $filename, 'width' => $this->_sizeArray[0], 'height' => $this->_sizeArray[1], 'thumbnailName' => $thumbnailImageInfo['filename'], 'thumbnailWidth' => $thumbnailImageInfo['width'], 'thumbnailHeight' => $thumbnailImageInfo['height'], 'catalogName' => $catalogImageInfo['filename'], 'catalogWidth' => $catalogImageInfo['width'], 'catalogHeight' => $catalogImageInfo['height'], 'uploadName' => $temporaryFile->getOriginalFileName(), 'dateUploaded' => Core::getCurrentDate())); // Clean up the temporary file import('lib.pkp.classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFileManager->deleteFile($temporaryFileId, $this->_userId); } if ($this->getData('attachPermissions')) { $monograph->setCopyrightYear($this->getData('copyrightYear')); $monograph->setCopyrightHolder($this->getData('copyrightHolder'), null); // Localized $monograph->setLicenseURL($this->getData('licenseURL')); } else { $monograph->setCopyrightYear(null); $monograph->setCopyrightHolder(null, null); $monograph->setLicenseURL(null); } $monographDao->updateObject($monograph); // Update the modified fields or insert new. if ($isExistingEntry) { $publishedMonographDao->updateObject($publishedMonograph); } else { $publishedMonographDao->insertObject($publishedMonograph); } import('classes.publicationFormat.PublicationFormatTombstoneManager'); $publicationFormatTombstoneMgr = new PublicationFormatTombstoneManager(); $publicationFormatDao = DAORegistry::getDAO('PublicationFormatDAO'); $publicationFormatFactory = $publicationFormatDao->getBySubmissionId($monograph->getId()); $publicationFormats = $publicationFormatFactory->toAssociativeArray(); $notificationMgr = new NotificationManager(); if ($this->getData('confirm')) { // Update the monograph status. $monograph->setStatus(STATUS_PUBLISHED); $monographDao->updateObject($monograph); $publishedMonograph->setDatePublished(Core::getCurrentDate()); $publishedMonographDao->updateObject($publishedMonograph); $notificationMgr->updateNotification($request, array(NOTIFICATION_TYPE_APPROVE_SUBMISSION), null, ASSOC_TYPE_MONOGRAPH, $publishedMonograph->getId()); // Remove publication format tombstones. $publicationFormatTombstoneMgr->deleteTombstonesByPublicationFormats($publicationFormats); // Update the search index for this published monograph. import('classes.search.MonographSearchIndex'); MonographSearchIndex::indexMonographMetadata($monograph); // Log the publication event. import('lib.pkp.classes.log.SubmissionLog'); SubmissionLog::logEvent($request, $monograph, SUBMISSION_LOG_METADATA_PUBLISH, 'submission.event.metadataPublished'); } else { if ($isExistingEntry) { // Update the monograph status. $monograph->setStatus(STATUS_QUEUED); $monographDao->updateObject($monograph); // Unpublish monograph. $publishedMonograph->setDatePublished(null); $publishedMonographDao->updateObject($publishedMonograph); $notificationMgr->updateNotification($request, array(NOTIFICATION_TYPE_APPROVE_SUBMISSION), null, ASSOC_TYPE_MONOGRAPH, $publishedMonograph->getId()); // Create tombstones for each publication format. $publicationFormatTombstoneMgr->insertTombstonesByPublicationFormats($publicationFormats, $request->getContext()); // Log the unpublication event. import('lib.pkp.classes.log.SubmissionLog'); SubmissionLog::logEvent($request, $monograph, SUBMISSION_LOG_METADATA_UNPUBLISH, 'submission.event.metadataUnpublished'); } } }
/** * Save settings. */ function execute() { $articleDao =& DAORegistry::getDAO('ArticleDAO'); $signoffDao =& DAORegistry::getDAO('SignoffDAO'); $sectionEditorSubmissionDao =& DAORegistry::getDAO('SectionEditorSubmissionDAO'); $application =& PKPApplication::getApplication(); $request =& $application->getRequest(); $user =& $request->getUser(); $router =& $request->getRouter(); $journal =& $router->getContext($request); $article = new Article(); $article->setLocale($journal->getPrimaryLocale()); // FIXME in bug #5543 $article->setUserId($user->getId()); $article->setJournalId($journal->getId()); $article->setSectionId($this->getData('sectionId')); $article->setLanguage(String::substr($journal->getPrimaryLocale(), 0, 2)); $article->setTitle($this->getData('title'), null); // Localized $article->setAbstract($this->getData('abstract'), null); // Localized $article->setDiscipline($this->getData('discipline'), null); // Localized $article->setSubjectClass($this->getData('subjectClass'), null); // Localized $article->setSubject($this->getData('subject'), null); // Localized $article->setCoverageGeo($this->getData('coverageGeo'), null); // Localized $article->setCoverageChron($this->getData('coverageChron'), null); // Localized $article->setCoverageSample($this->getData('coverageSample'), null); // Localized $article->setType($this->getData('type'), null); // Localized $article->setSponsor($this->getData('sponsor'), null); // Localized $article->setCitations($this->getData('citations')); $article->setPages($this->getData('pages')); // Set some default values so the ArticleDAO doesn't complain when adding this article $article->setDateSubmitted(Core::getCurrentDate()); $article->setStatus(STATUS_PUBLISHED); $article->setSubmissionProgress(0); $article->stampStatusModified(); $article->setCurrentRound(1); $article->setFastTracked(1); $article->setHideAuthor(0); $article->setCommentsStatus(0); // Insert the article to get it's ID $articleDao->insertArticle($article); $articleId = $article->getId(); // Add authors $authors = $this->getData('authors'); for ($i = 0, $count = count($authors); $i < $count; $i++) { if ($authors[$i]['authorId'] > 0) { // Update an existing author $author =& $article->getAuthor($authors[$i]['authorId']); $isExistingAuthor = true; } else { // Create a new author $author = new Author(); $isExistingAuthor = false; } if ($author != null) { $author->setSubmissionId($articleId); $author->setFirstName($authors[$i]['firstName']); $author->setMiddleName($authors[$i]['middleName']); $author->setLastName($authors[$i]['lastName']); if (array_key_exists('affiliation', $authors[$i])) { $author->setAffiliation($authors[$i]['affiliation'], null); } $author->setCountry($authors[$i]['country']); $author->setEmail($authors[$i]['email']); $author->setUrl($authors[$i]['url']); if (array_key_exists('competingInterests', $authors[$i])) { $author->setCompetingInterests($authors[$i]['competingInterests'], null); } $author->setBiography($authors[$i]['biography'], null); $author->setPrimaryContact($this->getData('primaryContact') == $i ? 1 : 0); $author->setSequence($authors[$i]['seq']); if ($isExistingAuthor == false) { $article->addAuthor($author); } } } // Add the submission files as galleys import('classes.file.TemporaryFileManager'); import('classes.file.ArticleFileManager'); $tempFileIds = $this->getData('tempFileId'); $temporaryFileManager = new TemporaryFileManager(); $articleFileManager = new ArticleFileManager($articleId); foreach (array_keys($tempFileIds) as $locale) { $temporaryFile = $temporaryFileManager->getFile($tempFileIds[$locale], $user->getId()); $fileId = null; if ($temporaryFile) { $fileId = $articleFileManager->temporaryFileToArticleFile($temporaryFile, ARTICLE_FILE_SUBMISSION); $fileType = $temporaryFile->getFileType(); if (strstr($fileType, 'html')) { import('classes.article.ArticleHTMLGalley'); $galley = new ArticleHTMLGalley(); } else { import('classes.article.ArticleGalley'); $galley = new ArticleGalley(); } $galley->setArticleId($articleId); $galley->setFileId($fileId); $galley->setLocale($locale); if ($galley->isHTMLGalley()) { $galley->setLabel('HTML'); } else { if (strstr($fileType, 'pdf')) { $galley->setLabel('PDF'); } else { if (strstr($fileType, 'postscript')) { $galley->setLabel('Postscript'); } else { if (strstr($fileType, 'xml')) { $galley->setLabel('XML'); } else { $galley->setLabel(__('common.untitled')); } } } } $galleyDao =& DAORegistry::getDAO('ArticleGalleyDAO'); $galleyDao->insertGalley($galley); } if ($locale == $journal->getPrimaryLocale()) { $article->setSubmissionFileId($fileId); $article->SetReviewFileId($fileId); } // Update file search index import('classes.search.ArticleSearchIndex'); if (isset($galley)) { ArticleSearchIndex::updateFileIndex($galley->getArticleId(), ARTICLE_SEARCH_GALLEY_FILE, $galley->getFileId()); } } // Designate this as the review version by default. $authorSubmissionDao =& DAORegistry::getDAO('AuthorSubmissionDAO'); $authorSubmission =& $authorSubmissionDao->getAuthorSubmission($articleId); import('classes.submission.author.AuthorAction'); AuthorAction::designateReviewVersion($authorSubmission, true); // Accept the submission $sectionEditorSubmission =& $sectionEditorSubmissionDao->getSectionEditorSubmission($articleId); $articleFileManager = new ArticleFileManager($articleId); $sectionEditorSubmission->setReviewFile($articleFileManager->getFile($article->getSubmissionFileId())); import('classes.submission.sectionEditor.SectionEditorAction'); SectionEditorAction::recordDecision($sectionEditorSubmission, SUBMISSION_EDITOR_DECISION_ACCEPT); // Create signoff infrastructure $copyeditInitialSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_INITIAL', ASSOC_TYPE_ARTICLE, $articleId); $copyeditAuthorSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_AUTHOR', ASSOC_TYPE_ARTICLE, $articleId); $copyeditFinalSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_FINAL', ASSOC_TYPE_ARTICLE, $articleId); $copyeditInitialSignoff->setUserId(0); $copyeditAuthorSignoff->setUserId($user->getId()); $copyeditFinalSignoff->setUserId(0); $signoffDao->updateObject($copyeditInitialSignoff); $signoffDao->updateObject($copyeditAuthorSignoff); $signoffDao->updateObject($copyeditFinalSignoff); $layoutSignoff = $signoffDao->build('SIGNOFF_LAYOUT', ASSOC_TYPE_ARTICLE, $articleId); $layoutSignoff->setUserId(0); $signoffDao->updateObject($layoutSignoff); $proofAuthorSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_AUTHOR', ASSOC_TYPE_ARTICLE, $articleId); $proofProofreaderSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_PROOFREADER', ASSOC_TYPE_ARTICLE, $articleId); $proofLayoutEditorSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_LAYOUT', ASSOC_TYPE_ARTICLE, $articleId); $proofAuthorSignoff->setUserId($user->getId()); $proofProofreaderSignoff->setUserId(0); $proofLayoutEditorSignoff->setUserId(0); $signoffDao->updateObject($proofAuthorSignoff); $signoffDao->updateObject($proofProofreaderSignoff); $signoffDao->updateObject($proofLayoutEditorSignoff); import('classes.author.form.submit.AuthorSubmitForm'); AuthorSubmitForm::assignEditors($article); $articleDao->updateArticle($article); // Add to end of editing queue import('classes.submission.editor.EditorAction'); if (isset($galley)) { EditorAction::expediteSubmission($article); } if ($this->getData('destination') == "issue") { // Add to an existing issue $issueId = $this->getData('issueId'); $this->scheduleForPublication($articleId, $issueId); } // Index article. import('classes.search.ArticleSearchIndex'); ArticleSearchIndex::indexArticleMetadata($article); // Import the references list. $citationDao =& DAORegistry::getDAO('CitationDAO'); $rawCitationList = $article->getCitations(); $citationDao->importCitations($request, ASSOC_TYPE_ARTICLE, $articleId, $rawCitationList); }
/** * Display the plugin. * @param $args array * @param $request PKPRequest */ function display($args, $request) { $templateMgr = TemplateManager::getManager($request); $context = $request->getContext(); parent::display($args, $request); $templateMgr->assign('plugin', $this); switch (array_shift($args)) { case 'index': case '': $templateMgr->display($this->getTemplatePath() . 'index.tpl'); break; case 'uploadImportXML': $user = $request->getUser(); import('lib.pkp.classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFile = $temporaryFileManager->handleUpload('uploadedFile', $user->getId()); if ($temporaryFile) { $json = new JSONMessage(true); $json->setAdditionalAttributes(array('temporaryFileId' => $temporaryFile->getId())); } else { $json = new JSONMessage(false, __('common.uploadFailed')); } return $json->getString(); case 'importBounce': $json = new JSONMessage(true); $json->setEvent('addTab', array('title' => __('plugins.importexport.users.results'), 'url' => $request->url(null, null, null, array('plugin', $this->getName(), 'import'), array('temporaryFileId' => $request->getUserVar('temporaryFileId'))))); return $json->getString(); case 'import': $temporaryFileId = $request->getUserVar('temporaryFileId'); $temporaryFileDao = DAORegistry::getDAO('TemporaryFileDAO'); $user = $request->getUser(); $temporaryFile = $temporaryFileDao->getTemporaryFile($temporaryFileId, $user->getId()); if (!$temporaryFile) { $json = new JSONMessage(true, __('plugins.importexport.users.uploadFile')); return $json->getString(); } $temporaryFilePath = $temporaryFile->getFilePath(); $users = $this->importUsers(file_get_contents($temporaryFilePath), $context, $user); $templateMgr->assign('users', $users); $json = new JSONMessage(true, $templateMgr->fetch($this->getTemplatePath() . 'results.tpl')); return $json->getString(); case 'export': $exportXml = $this->exportUsers((array) $request->getUserVar('selectedUsers'), $request->getContext(), $request->getUser()); header('Content-type: application/xml'); echo $exportXml; break; case 'exportAllUsers': $exportXml = $this->exportAllUsers($request->getContext(), $request->getUser()); header('Content-type: application/xml'); echo $exportXml; break; default: $dispatcher = $request->getDispatcher(); $dispatcher->handle404(); } }
/** * Save settings. */ function execute($editArticleId) { $this->editArticleID = $editArticleId; $articleDao =& DAORegistry::getDAO('ArticleDAO'); $signoffDao =& DAORegistry::getDAO('SignoffDAO'); $sectionEditorSubmissionDao =& DAORegistry::getDAO('SectionEditorSubmissionDAO'); $application =& PKPApplication::getApplication(); $request =& $application->getRequest(); $user =& $request->getUser(); $router =& $request->getRouter(); $journal =& $router->getContext($request); $article = new Article(); $article->setLocale($journal->getPrimaryLocale()); // FIXME in bug #5543 $article->setUserId($user->getId()); $article->setJournalId($journal->getId()); $article->setSectionId($this->getData('sectionId')); $article->setLanguage(String::substr($journal->getPrimaryLocale(), 0, 2)); $article->setTitle($this->getData('title'), null); // Localized //add Original Journal to Abstract $orig_journal = $this->getData('originalJournal'); $abstr = $this->getData('abstract'); foreach (array_keys($abstr) as $abs_key) { $abstr[$abs_key] .= ' <p id="originalPub"> ' . $orig_journal . ' </p> '; // $abstr[$abs_key] .= ' <p id="originalPub"> ' . $orig_journal[$abs_key]. ' </p> '; //OriginalJournal in EditPlugin only a string and not an array... $this->setData('abstract', $abstr); } $article->setAbstract($this->getData('abstract'), null); // Localized $article->setDiscipline($this->getData('discipline'), null); // Localized $article->setSubjectClass($this->getData('subjectClass'), null); // Localized $article->setSubject($this->getData('subject'), null); // Localized $article->setCoverageGeo($this->getData('coverageGeo'), null); // Localized $article->setCoverageChron($this->getData('coverageChron'), null); // Localized $article->setCoverageSample($this->getData('coverageSample'), null); // Localized $article->setType($this->getData('type'), null); // Localized $article->setSponsor($this->getData('sponsor'), null); // Localized $article->setCitations($this->getData('citations')); $article->setPages($this->getData('pages')); // Set some default values so the ArticleDAO doesn't complain when adding this article $article->setDateSubmitted(Core::getCurrentDate()); $article->setStatus(STATUS_PUBLISHED); $article->setSubmissionProgress(0); $article->stampStatusModified(); $article->setCurrentRound(1); $article->setFastTracked(1); $article->setHideAuthor(0); $article->setCommentsStatus(0); // As article has an ID already set it $article->setId($this->editArticleID); $articleId = $this->editArticleID; //delete prior Authors to prevent from double saving the same authors $authorDao =& DAORegistry::getDAO('AuthorDAO'); $authorDao->deleteAuthorsByArticle($articleId); // Add authors $authors = $this->getData('authors'); for ($i = 0, $count = count($authors); $i < $count; $i++) { if ($authors[$i]['authorId'] > 0) { // Update an existing author $author =& $article->getAuthor($authors[$i]['authorId']); $isExistingAuthor = true; } else { // Create a new author $author = new Author(); $isExistingAuthor = false; } if ($author != null) { $author->setSubmissionId($articleId); $author->setFirstName($authors[$i]['firstName']); $author->setMiddleName($authors[$i]['middleName']); $author->setLastName($authors[$i]['lastName']); if (array_key_exists('affiliation', $authors[$i])) { $author->setAffiliation($authors[$i]['affiliation'], null); } $author->setCountry($authors[$i]['country']); $author->setEmail($authors[$i]['email']); $author->setUrl($authors[$i]['url']); if (array_key_exists('competingInterests', $authors[$i])) { $author->setCompetingInterests($authors[$i]['competingInterests'], null); } $author->setBiography($authors[$i]['biography'], null); $author->setPrimaryContact($this->getData('primaryContact') == $i ? 1 : 0); $author->setSequence($authors[$i]['seq']); if ($isExistingAuthor == false) { $article->addAuthor($author); } } } // Check whether the user gave a handle and create a handleSubmissionFile in case $submissionHandle = $this->getData('submissionHandle'); $handleSubmissionFileId; $handleCheck = FALSE; //import FileManager before creating files because otherwise naming of the copied files failes import('classes.file.ArticleFileManager'); foreach (array_keys($submissionHandle) as $locale) { if (!empty($submissionHandle[$locale])) { $this->deleteOldFile("submission/original", $articleId); // $this->deleteOldFile("submission/copyedit", $articleId); $handleCheck = TRUE; $handleSubmissionId = $this->createHandleTXTFile($submissionHandle[$locale], $articleId, 'submission'); $handleSubmissionPDFId = $this->createHandlePDF($submissionHandle[$locale], $articleId, 'submission'); //Add the handle submission files as galley $this->setGalley($articleId, $handleSubmissionPDFId, $locale, 'application/pdf'); } if ($handleCheck == TRUE) { if ($locale == $journal->getPrimaryLocale()) { $article->setSubmissionFileId($handleSubmissionPDFId); $article->SetReviewFileId($handleSubmissionPDFId); } // Update file search index import('classes.search.ArticleSearchIndex'); if (isset($galley)) { ArticleSearchIndex::updateFileIndex($galley->getArticleId(), ARTICLE_SEARCH_GALLEY_FILE, $galley->getFileId()); } } } // Add the submission files as galleys import('classes.file.TemporaryFileManager'); import('classes.file.ArticleFileManager'); $tempFileIds = $this->getData('tempFileId'); $temporaryFileManager = new TemporaryFileManager(); $articleFileManager = new ArticleFileManager($articleId); $tempFileCheck = FALSE; foreach (array_keys($tempFileIds) as $locale) { $temporaryFile = $temporaryFileManager->getFile($tempFileIds[$locale], $user->getId()); $fileId = null; if ($temporaryFile) { $this->deleteOldFile("submission/original", $articleId); $this->deleteOldFile("submission/copyedit", $articleId); $tempFileCheck = TRUE; $fileId = $articleFileManager->temporaryFileToArticleFile($temporaryFile, ARTICLE_FILE_SUBMISSION); $fileType = $temporaryFile->getFileType(); $this->setGalley($articleId, $fileId, $locale, $fileType); // $galley =& $this->setGalley($articleId, $fileId, $locale, $fileType); } if ($tempFileCheck == TRUE) { if ($locale == $journal->getPrimaryLocale()) { $article->setSubmissionFileId($fileId); $article->SetReviewFileId($fileId); } // Update file search index import('classes.search.ArticleSearchIndex'); if (isset($galley)) { ArticleSearchIndex::updateFileIndex($galley->getArticleId(), ARTICLE_SEARCH_GALLEY_FILE, $galley->getFileId()); } } } //Check whether the user gave a handle and create handleSupplFile in case $supplHandle = $this->getData('supplHandle'); $handleSuppFileId = null; foreach (array_keys($supplHandle) as $locale) { if (!empty($supplHandle[$locale])) { $this->deleteOldFile("supp", $articleId); $handleSuppFileId = $this->createHandleTXTFile($supplHandle[$locale], $articleId, 'supplementary'); $handleSupplPDFFileID = $this->createHandlePDF($submissionHandle[$locale], $articleId, 'supplementary'); } } //Add uploaded Supplementary file $tempSupplFileIds = $this->getData('tempSupplFileId'); foreach (array_keys($tempSupplFileIds) as $locale) { $temporaryFile = $temporaryFileManager->getFile($tempSupplFileIds[$locale], $user->getId()); $fileId = null; if ($temporaryFile) { $this->deleteOldFile("supp", $articleId); $fileId = $articleFileManager->temporaryFileToArticleFile($temporaryFile, ARTICLE_FILE_SUPP); $fileType = $temporaryFile->getFileType(); } } // Designate this as the review version by default. /*$authorSubmissionDao =& DAORegistry::getDAO('AuthorSubmissionDAO'); $authorSubmission =& $authorSubmissionDao->getAuthorSubmission($articleId); import('classes.submission.author.AuthorAction'); AuthorAction::designateReviewVersion($authorSubmission, true); */ // Accept the submission /*$sectionEditorSubmission =& $sectionEditorSubmissionDao->getSectionEditorSubmission($articleId); $articleFileManager = new ArticleFileManager($articleId); $sectionEditorSubmission->setReviewFile($articleFileManager->getFile($article->getSubmissionFileId())); import('classes.submission.sectionEditor.SectionEditorAction'); SectionEditorAction::recordDecision($sectionEditorSubmission, SUBMISSION_EDITOR_DECISION_ACCEPT); */ // Create signoff infrastructure $copyeditInitialSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_INITIAL', ASSOC_TYPE_ARTICLE, $articleId); $copyeditAuthorSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_AUTHOR', ASSOC_TYPE_ARTICLE, $articleId); $copyeditFinalSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_FINAL', ASSOC_TYPE_ARTICLE, $articleId); $copyeditInitialSignoff->setUserId(0); $copyeditAuthorSignoff->setUserId($user->getId()); $copyeditFinalSignoff->setUserId(0); $signoffDao->updateObject($copyeditInitialSignoff); $signoffDao->updateObject($copyeditAuthorSignoff); $signoffDao->updateObject($copyeditFinalSignoff); $layoutSignoff = $signoffDao->build('SIGNOFF_LAYOUT', ASSOC_TYPE_ARTICLE, $articleId); $layoutSignoff->setUserId(0); $signoffDao->updateObject($layoutSignoff); $proofAuthorSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_AUTHOR', ASSOC_TYPE_ARTICLE, $articleId); $proofProofreaderSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_PROOFREADER', ASSOC_TYPE_ARTICLE, $articleId); $proofLayoutEditorSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_LAYOUT', ASSOC_TYPE_ARTICLE, $articleId); $proofAuthorSignoff->setUserId($user->getId()); $proofProofreaderSignoff->setUserId(0); $proofLayoutEditorSignoff->setUserId(0); $signoffDao->updateObject($proofAuthorSignoff); $signoffDao->updateObject($proofProofreaderSignoff); $signoffDao->updateObject($proofLayoutEditorSignoff); import('classes.author.form.submit.AuthorSubmitForm'); AuthorSubmitForm::assignEditors($article); $articleDao->updateArticle($article); // Add to end of editing queue import('classes.submission.editor.EditorAction'); if (isset($galley)) { EditorAction::expediteSubmission($article); } // As the article already has an issue, just get it from database $issueDao =& DAORegistry::getDAO('IssueDAO'); $issue =& $issueDao->getIssueByArticleId($this->editArticleID); $issueId = $issue->getIssueId(); //$this->scheduleForPublication($articleId, $issueId); // Index article. import('classes.search.ArticleSearchIndex'); ArticleSearchIndex::indexArticleMetadata($article); // Import the references list. $citationDao =& DAORegistry::getDAO('CitationDAO'); $rawCitationList = $article->getCitations(); $citationDao->importCitations($request, ASSOC_TYPE_ARTICLE, $articleId, $rawCitationList); }
/** * Handle a child of the revision element * @param $node DOMElement * @param $submission Submission * @param $submissionFile SubmissionFile * @return string Filename for new file */ function handleRevisionChildElement($node, $submission, $submissionFile) { $deployment = $this->getDeployment(); $context = $deployment->getContext(); switch ($node->tagName) { case 'id': $this->parseIdentifier($node, $submissionFile); break; case 'name': $locale = $node->getAttribute('locale'); if (empty($locale)) { $locale = $context->getPrimaryLocale(); } $submissionFile->setName($node->textContent, $locale); break; case 'href': $submissionFile->setFileType($node->getAttribute('mime_type')); // Allow wrappers to handle URLs return $node->getAttribute('src'); break; case 'embed': $submissionFile->setFileType($node->getAttribute('mime_type')); if (($e = $node->getAttribute('encoding')) != 'base64') { fatalError('Unknown encoding "' . $e . '"!'); } $temporaryFileManager = new TemporaryFileManager(); $temporaryFilename = tempnam($temporaryFileManager->getBasePath(), 'embed'); file_put_contents($temporaryFilename, base64_decode($node->textContent)); return $temporaryFilename; break; } }
/** * Handle a child of the revision element * @param $node DOMElement * @param $submission Submission * @param $submissionFile SubmissionFile * @return string Filename for new file */ function handleRevisionChildElement($node, $submission, $submissionFile) { switch ($node->tagName) { case 'name': $submissionFile->setName($node->textContent, $node->getAttribute('locale')); break; case 'remote': $submissionFile->setFileType($node->getAttribute('mime_type')); $src = $node->getAttribute('src'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFilename = tempnam($temporaryFileManager->getBasePath(), 'remote'); $temporaryFileManager->copyFile($src, $temporaryFilename); return $temporaryFilename; break; case 'href': $submissionFile->setFileType($node->getAttribute('mime_type')); // Allow wrappers to handle URLs return $node->getAttribute('src'); break; case 'embed': $submissionFile->setFileType($node->getAttribute('mime_type')); if (($e = $node->getAttribute('encoding')) != 'base64') { fatalError('Unknown encoding "' . $e . '"!'); } $temporaryFileManager = new TemporaryFileManager(); $temporaryFilename = tempnam($temporaryFileManager->getBasePath(), 'embed'); file_put_contents($temporaryFilename, base64_decode($node->textContent)); return $temporaryFilename; break; } }
/** * Execute import/export tasks using the command-line interface. * @param $args Parameters to the plugin */ function executeCLI($scriptName, &$args) { AppLocale::requireComponents(LOCALE_COMPONENT_APP_COMMON); $filename = array_shift($args); $username = array_shift($args); if (!$filename || !$username) { $this->usage($scriptName); exit; } if (!file_exists($filename)) { echo __('plugins.importexport.csv.fileDoesNotExist', array('filename' => $filename)) . "\n"; exit; } $data = file($filename); if (is_array($data) && count($data) > 0) { $userDao = DAORegistry::getDAO('UserDAO'); $user = $userDao->getByUsername($username); if (!$user) { echo __('plugins.importexport.csv.unknownUser', array('username' => $username)) . "\n"; exit; } $submissionDao = Application::getSubmissionDAO(); $authorDao = DAORegistry::getDAO('AuthorDAO'); $pressDao = Application::getContextDAO(); $userGroupDao = DAORegistry::getDAO('UserGroupDAO'); $seriesDao = DAORegistry::getDAO('SeriesDAO'); $publicationFormatDao = DAORegistry::getDAO('PublicationFormatDAO'); $submissionFileDao = DAORegistry::getDAO('SubmissionFileDAO'); import('lib.pkp.classes.submission.SubmissionFile'); // constants. $genreDao = DAORegistry::getDAO('GenreDAO'); $publicationDateDao = DAORegistry::getDAO('PublicationDateDAO'); foreach ($data as $csvLine) { // Format is: // Press Path, Author string, title, series path, year, is_edited_volume, locale, URL to PDF, doi (optional) list($pressPath, $authorString, $title, $seriesPath, $year, $isEditedVolume, $locale, $pdfUrl, $doi) = preg_split('/\\t/', $csvLine); $press = $pressDao->getByPath($pressPath); if ($press) { $supportedLocales = $press->getSupportedSubmissionLocales(); if (!is_array($supportedLocales) || count($supportedLocales) < 1) { $supportedLocales = array($press->getPrimaryLocale()); } $authorGroup = $userGroupDao->getDefaultByRoleId($press->getId(), ROLE_ID_AUTHOR); // we need a Genre for the files. Assume a key of MANUSCRIPT as a default. $genre = $genreDao->getByKey('MANUSCRIPT', $press->getId()); if (!$genre) { echo __('plugins.importexport.csv.noGenre') . "\n"; exit; } if (!$authorGroup) { echo __('plugins.importexport.csv.noAuthorGroup', array('press' => $pressPath)) . "\n"; continue; } if (in_array($locale, $supportedLocales)) { $submission = $submissionDao->newDataObject(); $submission->setContextId($press->getId()); $submission->setUserId($user->getId()); $submission->stampStatusModified(); $submission->setStatus(STATUS_PUBLISHED); $submission->setWorkType($isEditedVolume == 1 ? WORK_TYPE_EDITED_VOLUME : WORK_TYPE_AUTHORED_WORK); $submission->setCopyrightNotice($press->getLocalizedSetting('copyrightNotice'), $locale); $submission->setLocale($locale); $series = $seriesDao->getByPath($seriesPath, $press->getId()); if ($series) { $submission->setSeriesId($series->getId()); } else { echo __('plugins.importexport.csv.noSeries', array('seriesPath' => $seriesPath)) . "\n"; } $submissionId = $submissionDao->insertObject($submission); $contactEmail = $press->getContactEmail(); $authorString = trim($authorString, '"'); // remove double quotes if present. $authors = preg_split('/,\\s*/', $authorString); $firstAuthor = true; foreach ($authors as $authorString) { // Examine the author string. Best case is: First1 Last1 <*****@*****.**>, First2 Last2 <*****@*****.**>, etc // But default to press email address based on press path if not present. $firstName = $lastName = $emailAddress = null; $authorString = trim($authorString); // whitespace. if (preg_match('/^(\\w+)(\\s+\\w+)?\\s*(<([^>]+)>)?$/', $authorString, $matches)) { $firstName = $matches[1]; // Mandatory if (count($matches) > 2) { $lastName = $matches[2]; } if (count($matches) == 5) { $emailAddress = $matches[4]; } else { $emailAddress = $contactEmail; } } $author = $authorDao->newDataObject(); $author->setSubmissionId($submissionId); $author->setUserGroupId($authorGroup->getId()); $author->setFirstName($firstName); $author->setLastName($lastName); $author->setEmail($emailAddress); if ($firstAuthor) { $author->setPrimaryContact(1); $firstAuthor = false; } $authorDao->insertObject($author); } // Authors done. $submission->setTitle($title, $locale); $submissionDao->updateObject($submission); // Submission is done. Create a publication format for it. $publicationFormat = $publicationFormatDao->newDataObject(); $publicationFormat->setPhysicalFormat(false); $publicationFormat->setIsApproved(true); $publicationFormat->setIsAvailable(true); $publicationFormat->setSubmissionId($submissionId); $publicationFormat->setProductAvailabilityCode('20'); // ONIX code for Available. $publicationFormat->setEntryKey('DA'); // ONIX code for Digital $publicationFormat->setData('name', 'PDF', $submission->getLocale()); $publicationFormat->setSequence(REALLY_BIG_NUMBER); $publicationFormatId = $publicationFormatDao->insertObject($publicationFormat); if ($doi) { $publicationFormat->setStoredPubId('doi', $doi); } $publicationFormatDao->updateObject($publicationFormat); // Create a publication format date for this publication format. $publicationDate = $publicationDateDao->newDataObject(); $publicationDate->setDateFormat('05'); // List55, YYYY $publicationDate->setRole('01'); // List163, Publication Date $publicationDate->setDate($year); $publicationDate->setPublicationFormatId($publicationFormatId); $publicationDateDao->insertObject($publicationDate); // Submission File. import('lib.pkp.classes.file.TemporaryFileManager'); import('lib.pkp.classes.file.FileManager'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFilename = tempnam($temporaryFileManager->getBasePath(), 'remote'); $temporaryFileManager->copyFile($pdfUrl, $temporaryFilename); $submissionFile = $submissionFileDao->newDataObjectByGenreId($genre->getId()); $submissionFile->setSubmissionId($submissionId); $submissionFile->setGenreId($genre->getId()); $submissionFile->setFileStage(SUBMISSION_FILE_PROOF); $submissionFile->setDateUploaded(Core::getCurrentDate()); $submissionFile->setDateModified(Core::getCurrentDate()); $submissionFile->setAssocType(ASSOC_TYPE_REPRESENTATION); $submissionFile->setAssocId($publicationFormatId); $submissionFile->setFileType('application/pdf'); // Assume open access, no price. $submissionFile->setDirectSalesPrice(0); $submissionFile->setSalesType('openAccess'); $submissionFileDao->insertObject($submissionFile, $temporaryFilename); $fileManager = new FileManager(); $fileManager->deleteFile($temporaryFilename); echo __('plugins.importexport.csv.import.submission', array('title' => $title)) . "\n"; } else { echo __('plugins.importexport.csv.unknownLocale', array('locale' => $locale)) . "\n"; } } else { echo __('plugins.importexport.csv.unknownPress', array('pressPath' => $pressPath)) . "\n"; } } } }
/** * Output PDF generated from the XML/XSL/FO source to browser * This function performs any necessary filtering, like image URL replacement. * @return string */ function viewFileContents() { import('lib.pkp.classes.file.FileManager'); $fileManager = new FileManager(); $pdfFileName = CacheManager::getFileCachePath() . DIRECTORY_SEPARATOR . 'fc-xsltGalley-' . str_replace($fileManager->parseFileExtension($this->getFileName()), 'pdf', $this->getFileName()); // if file does not exist or is outdated, regenerate it from FO if (!$fileManager->fileExists($pdfFileName) || filemtime($pdfFileName) < filemtime($this->getFilePath())) { // render XML into XSL-FO $cache =& $this->_getXSLTCache($this->getFileName() . '-' . $this->getId()); $contents = $cache->getContents(); if ($contents == "") { return false; } // if for some reason the XSLT failed, show original file // Replace image references $images =& $this->getImageFiles(); if ($images !== null) { // TODO: this should "smart replace" the file path ($this->getFilePath()) in the XSL-FO // in lieu of requiring XSL parameters, and transparently for FO that are hardcoded foreach ($images as $image) { $contents = preg_replace('/src\\s*=\\s*"([^"]*)' . preg_quote($image->getOriginalFileName()) . '([^"]*)"/i', 'src="${1}' . dirname($this->getFilePath()) . DIRECTORY_SEPARATOR . $image->getFileName() . '$2"', $contents); } } // Replace supplementary file references $this->suppFileDao =& DAORegistry::getDAO('SuppFileDAO'); $suppFiles = $this->suppFileDao->getSuppFilesByArticle($this->getArticleId()); if ($suppFiles) { $journal =& Request::getJournal(); foreach ($suppFiles as $supp) { $suppUrl = Request::url(null, 'article', 'downloadSuppFile', array($this->getArticleId(), $supp->getBestSuppFileId($journal))); $contents = preg_replace('/external-destination\\s*=\\s*"([^"]*)' . preg_quote($supp->getOriginalFileName()) . '([^"]*)"/i', 'external-destination="' . $suppUrl . '"', $contents); } } // create temporary FO file and write the contents import('classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $tempFoName = $temporaryFileManager->filesDir . $this->getFileName() . '-' . $this->getId() . '.fo'; $temporaryFileManager->writeFile($tempFoName, $contents); // perform %fo and %pdf replacements for fully-qualified shell command $journal =& Request::getJournal(); $xmlGalleyPlugin =& PluginRegistry::getPlugin('generic', $this->parentPluginName); $fopCommand = str_replace(array('%fo', '%pdf'), array($tempFoName, $pdfFileName), $xmlGalleyPlugin->getSetting($journal->getId(), 'externalFOP')); // check for safe mode and escape the shell command if (!ini_get('safe_mode')) { $fopCommand = escapeshellcmd($fopCommand); } // run the shell command and get the results exec($fopCommand . ' 2>&1', $contents, $status); // if there is an error, spit out the shell results to aid debugging if ($status != false) { if ($contents != '') { echo implode("\n", $contents); $cache->flush(); // clear the XSL cache in case it's a FO error return true; } else { return false; } } // clear the temporary FO file $fileManager->deleteFile($tempFoName); } // use FileManager to send file to browser $fileManager->downloadFile($pdfFileName, $this->getFileType(), true); return true; }
/** * Display the plugin. * @param $args array * @param $request PKPRequest */ function display($args, $request) { $templateMgr = TemplateManager::getManager($request); $press = $request->getPress(); parent::display($args, $request); $templateMgr->assign('plugin', $this); switch (array_shift($args)) { case 'index': case '': $templateMgr->display($this->getTemplatePath() . 'index.tpl'); break; case 'uploadImportXML': $user = $request->getUser(); import('lib.pkp.classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFile = $temporaryFileManager->handleUpload('uploadedFile', $user->getId()); if ($temporaryFile) { $json = new JSONMessage(true); $json->setAdditionalAttributes(array('temporaryFileId' => $temporaryFile->getId())); } else { $json = new JSONMessage(false, __('common.uploadFailed')); } return $json->getString(); case 'importBounce': $json = new JSONMessage(true); $json->setEvent('addTab', array('title' => __('plugins.importexport.native.results'), 'url' => $request->url(null, null, null, array('plugin', $this->getName(), 'import'), array('temporaryFileId' => $request->getUserVar('temporaryFileId'))))); return $json->getString(); case 'import': AppLocale::requireComponents(LOCALE_COMPONENT_PKP_SUBMISSION); $temporaryFileId = $request->getUserVar('temporaryFileId'); $temporaryFileDao = DAORegistry::getDAO('TemporaryFileDAO'); $user = $request->getUser(); $temporaryFile = $temporaryFileDao->getTemporaryFile($temporaryFileId, $user->getId()); if (!$temporaryFile) { $json = new JSONMessage(true, __('plugins.inportexport.native.uploadFile')); return $json->getString(); } $temporaryFilePath = $temporaryFile->getFilePath(); $deployment = new NativeImportExportDeployment($press, $user); libxml_use_internal_errors(true); $submissions = $this->importSubmissions(file_get_contents($temporaryFilePath), $deployment); $templateMgr->assign('submissions', $submissions); $validationErrors = array_filter(libxml_get_errors(), create_function('$a', 'return $a->level == LIBXML_ERR_ERROR || $a->level == LIBXML_ERR_FATAL;')); $templateMgr->assign('validationErrors', $validationErrors); libxml_clear_errors(); // Are there any submissions import errors $processedSubmissionsIds = $deployment->getProcessedObjectsIds(ASSOC_TYPE_SUBMISSION); if (!empty($processedSubmissionsIds)) { $submissionsErrors = array_filter($processedSubmissionsIds, create_function('$a', 'return !empty($a);')); if (!empty($submissionsErrors)) { $templateMgr->assign('submissionsErrors', $processedSubmissionsIds); } } // If there are any submissions or validataion errors // delete imported submissions. if (!empty($submissionsErrors) || !empty($validationErrors)) { // remove all imported sumissions $deployment->removeImportedObjects(ASSOC_TYPE_SUBMISSION); } // Display the results $json = new JSONMessage(true, $templateMgr->fetch($this->getTemplatePath() . 'results.tpl')); return $json->getString(); case 'export': $exportXml = $this->exportSubmissions((array) $request->getUserVar('selectedSubmissions'), $request->getContext(), $request->getUser()); import('lib.pkp.classes.file.FileManager'); $fileManager = new FileManager(); $exportFileName = $this->getExportFileName($this->getExportPath(), 'monographs', $press, '.xml'); $fileManager->writeFile($exportFileName, $exportXml); $fileManager->downloadFile($exportFileName); $fileManager->deleteFile($exportFileName); break; default: $dispatcher = $request->getDispatcher(); $dispatcher->handle404(); } }
/** * Save series. * @param $args array * @param $request PKPRequest */ function execute($args, $request) { $seriesDao = DAORegistry::getDAO('SeriesDAO'); $press = $request->getPress(); // Get or create the series object if ($this->getSeriesId()) { $series = $seriesDao->getById($this->getSeriesId(), $press->getId()); } else { $series = $seriesDao->newDataObject(); $series->setPressId($press->getId()); } // Populate/update the series object from the form $series->setPath($this->getData('path')); $series->setFeatured($this->getData('featured')); $series->setTitle($this->getData('title'), null); // Localized $series->setDescription($this->getData('description'), null); // Localized $series->setPrefix($this->getData('prefix'), null); // Localized $series->setSubtitle($this->getData('subtitle'), null); // Localized $series->setEditorRestricted($this->getData('restricted')); $series->setOnlineISSN($this->getData('onlineIssn')); $series->setPrintISSN($this->getData('printIssn')); $series->setSortOption($this->getData('sortOption')); // Insert or update the series in the DB if ($this->getSeriesId()) { $seriesDao->updateObject($series); } else { $this->setSeriesId($seriesDao->insertObject($series)); } // Handle the image upload if there was one. if ($temporaryFileId = $this->getData('temporaryFileId')) { // Fetch the temporary file storing the uploaded library file $temporaryFileDao = DAORegistry::getDAO('TemporaryFileDAO'); $temporaryFile = $temporaryFileDao->getTemporaryFile($temporaryFileId, $this->_userId); $temporaryFilePath = $temporaryFile->getFilePath(); import('lib.pkp.classes.file.ContextFileManager'); $pressFileManager = new ContextFileManager($press->getId()); $basePath = $pressFileManager->getBasePath() . '/series/'; // Delete the old file if it exists $oldSetting = $series->getImage(); if ($oldSetting) { $pressFileManager->deleteFile($basePath . $oldSetting['thumbnailName']); $pressFileManager->deleteFile($basePath . $oldSetting['name']); } // The following variables were fetched in validation assert($this->_sizeArray && $this->_imageExtension); // Generate the surrogate image. switch ($this->_imageExtension) { case '.jpg': $image = imagecreatefromjpeg($temporaryFilePath); break; case '.png': $image = imagecreatefrompng($temporaryFilePath); break; case '.gif': $image = imagecreatefromgif($temporaryFilePath); break; default: $image = null; // Suppress warn } assert($image); $coverThumbnailsMaxWidth = $press->getSetting('coverThumbnailsMaxWidth'); $coverThumbnailsMaxHeight = $press->getSetting('coverThumbnailsMaxHeight'); $thumbnailFilename = $series->getId() . '-series-thumbnail' . $this->_imageExtension; $xRatio = min(1, $coverThumbnailsMaxWidth / $this->_sizeArray[0]); $yRatio = min(1, $coverThumbnailsMaxHeight / $this->_sizeArray[1]); $ratio = min($xRatio, $yRatio); $thumbnailWidth = round($ratio * $this->_sizeArray[0]); $thumbnailHeight = round($ratio * $this->_sizeArray[1]); $thumbnail = imagecreatetruecolor($thumbnailWidth, $thumbnailHeight); imagecopyresampled($thumbnail, $image, 0, 0, 0, 0, $thumbnailWidth, $thumbnailHeight, $this->_sizeArray[0], $this->_sizeArray[1]); // Copy the new file over $filename = $series->getId() . '-series' . $this->_imageExtension; $pressFileManager->copyFile($temporaryFile->getFilePath(), $basePath . $filename); switch ($this->_imageExtension) { case '.jpg': imagejpeg($thumbnail, $basePath . $thumbnailFilename); break; case '.png': imagepng($thumbnail, $basePath . $thumbnailFilename); break; case '.gif': imagegif($thumbnail, $basePath . $thumbnailFilename); break; } imagedestroy($thumbnail); imagedestroy($image); $series->setImage(array('name' => $filename, 'width' => $this->_sizeArray[0], 'height' => $this->_sizeArray[1], 'thumbnailName' => $thumbnailFilename, 'thumbnailWidth' => $thumbnailWidth, 'thumbnailHeight' => $thumbnailHeight, 'uploadName' => $temporaryFile->getOriginalFileName(), 'dateUploaded' => Core::getCurrentDate())); // Clean up the temporary file import('lib.pkp.classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFileManager->deleteFile($temporaryFileId, $this->_userId); } // Update series object to store image information. $seriesDao->updateObject($series); import('lib.pkp.classes.controllers.listbuilder.ListbuilderHandler'); // Save the series editor associations. ListbuilderHandler::unpack($request, $this->getData('subEditors'), array(&$this, 'deleteSubEditorEntry'), array(&$this, 'insertSubEditorEntry'), array(&$this, 'updateSubEditorEntry')); // Save the category associations. ListbuilderHandler::unpack($request, $this->getData('categories'), array(&$this, 'deleteCategoryEntry'), array(&$this, 'insertCategoryEntry'), array(&$this, 'updateCategoryEntry')); return true; }
/** * Upload a plugin file. * @param $args array * @param $request PKPRequest * @return JSONMessage JSON object */ function uploadPluginFile($args, $request) { import('lib.pkp.classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $user = $request->getUser(); // Return the temporary file id. if ($temporaryFile = $temporaryFileManager->handleUpload('uploadedFile', $user->getId())) { $json = new JSONMessage(true); $json->setAdditionalAttributes(array('temporaryFileId' => $temporaryFile->getId())); return $json; } else { return new JSONMessage(false, __('manager.plugins.uploadError')); } }
/** * @see Form::execute() */ function execute($request) { $categoryId = $this->getCategoryId(); $categoryDao = DAORegistry::getDAO('CategoryDAO'); // Get a category object to edit or create if ($categoryId == null) { $category = $categoryDao->newDataObject(); $category->setPressId($this->getPressId()); } else { $category = $categoryDao->getById($categoryId, $this->getPressId()); } // Set the editable properties of the category object $category->setTitle($this->getData('name'), null); // Localized $category->setDescription($this->getData('description'), null); // Localized $category->setParentId($this->getData('parentId')); $category->setPath($this->getData('path')); $category->setSortOption($this->getData('sortOption')); // Update or insert the category object if ($categoryId == null) { $category->setId($categoryDao->insertObject($category)); } else { $category->setSequence(REALLY_BIG_NUMBER); $categoryDao->updateObject($category); $categoryDao->resequenceCategories($this->getPressId()); } // Handle the image upload if there was one. if ($temporaryFileId = $this->getData('temporaryFileId')) { // Fetch the temporary file storing the uploaded library file $temporaryFileDao = DAORegistry::getDAO('TemporaryFileDAO'); $temporaryFile = $temporaryFileDao->getTemporaryFile($temporaryFileId, $this->_userId); $temporaryFilePath = $temporaryFile->getFilePath(); import('lib.pkp.classes.file.ContextFileManager'); $pressFileManager = new ContextFileManager($this->getPressId()); $basePath = $pressFileManager->getBasePath() . '/categories/'; // Delete the old file if it exists $oldSetting = $category->getImage(); if ($oldSetting) { $pressFileManager->deleteFile($basePath . $oldSetting['thumbnailName']); $pressFileManager->deleteFile($basePath . $oldSetting['name']); } // The following variables were fetched in validation assert($this->_sizeArray && $this->_imageExtension); // Generate the surrogate images. switch ($this->_imageExtension) { case '.jpg': $image = imagecreatefromjpeg($temporaryFilePath); break; case '.png': $image = imagecreatefrompng($temporaryFilePath); break; case '.gif': $image = imagecreatefromgif($temporaryFilePath); break; default: $image = null; // Suppress warn } assert($image); $press = $request->getPress(); $coverThumbnailsMaxWidth = $press->getSetting('coverThumbnailsMaxWidth'); $coverThumbnailsMaxHeight = $press->getSetting('coverThumbnailsMaxHeight'); $thumbnailFilename = $category->getId() . '-category-thumbnail' . $this->_imageExtension; $xRatio = min(1, $coverThumbnailsMaxWidth / $this->_sizeArray[0]); $yRatio = min(1, $coverThumbnailsMaxHeight / $this->_sizeArray[1]); $ratio = min($xRatio, $yRatio); $thumbnailWidth = round($ratio * $this->_sizeArray[0]); $thumbnailHeight = round($ratio * $this->_sizeArray[1]); $thumbnail = imagecreatetruecolor($thumbnailWidth, $thumbnailHeight); imagecopyresampled($thumbnail, $image, 0, 0, 0, 0, $thumbnailWidth, $thumbnailHeight, $this->_sizeArray[0], $this->_sizeArray[1]); // Copy the new file over $filename = $category->getId() . '-category' . $this->_imageExtension; $pressFileManager->copyFile($temporaryFile->getFilePath(), $basePath . $filename); switch ($this->_imageExtension) { case '.jpg': imagejpeg($thumbnail, $basePath . $thumbnailFilename); break; case '.png': imagepng($thumbnail, $basePath . $thumbnailFilename); break; case '.gif': imagegif($thumbnail, $basePath . $thumbnailFilename); break; } imagedestroy($thumbnail); imagedestroy($image); $category->setImage(array('name' => $filename, 'width' => $this->_sizeArray[0], 'height' => $this->_sizeArray[1], 'thumbnailName' => $thumbnailFilename, 'thumbnailWidth' => $thumbnailWidth, 'thumbnailHeight' => $thumbnailHeight, 'uploadName' => $temporaryFile->getOriginalFileName(), 'dateUploaded' => Core::getCurrentDate())); // Clean up the temporary file import('lib.pkp.classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFileManager->deleteFile($temporaryFileId, $this->_userId); } // Update category object to store image information. $categoryDao->updateObject($category); return $category; }
/** * Decompress uploaded plugin and install in the correct plugin directory. * $param function string type of operation to perform after upload ('upgrade' or 'install') */ function uploadPlugin($function) { $templateMgr =& TemplateManager::getManager(); $this->setupTemplate(true); $templateMgr->assign('error', false); $templateMgr->assign('uploaded', false); $templateMgr->assign('path', $function); $templateMgr->assign('pageHierarchy', PluginManagementHandler::setBreadcrumbs(true)); if (Request::getUserVar('uploadPlugin')) { import('file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $user =& Request::getUser(); if ($temporaryFile = $temporaryFileManager->handleUpload('newPlugin', $user->getId())) { // tar archive basename must equal plugin directory name, and plugin files must be in root directory $pluginName = basename($temporaryFile->getOriginalFileName(), '.tar.gz'); $pluginDir = dirname($temporaryFile->getFilePath()); exec('tar -xzf ' . escapeshellarg($temporaryFile->getFilePath()) . ' -C ' . escapeshellarg($pluginDir)); if ($function == 'install') { PluginManagementHandler::installPlugin($pluginDir . DIRECTORY_SEPARATOR . $pluginName, $templateMgr); } else { if ($function == 'upgrade') { PluginManagementHandler::upgradePlugin($pluginDir . DIRECTORY_SEPARATOR . $pluginName, $templateMgr); } } } else { $templateMgr->assign('error', true); $templateMgr->assign('message', 'manager.plugins.uploadError'); } } else { if (Request::getUserVar('installPlugin')) { if (Request::getUserVar('pluginUploadLocation') == '') { $templateMgr->assign('error', true); $templateMgr->assign('message', 'manager.plugins.fileSelectError'); } } } $templateMgr->display('manager/plugins/managePlugins.tpl'); }
/** * Email editor decision comment * @param $sectionEditorSubmission object * @param $send boolean */ function emailEditorDecisionComment($sectionEditorSubmission, $send) { $userDao =& DAORegistry::getDAO('UserDAO'); $articleCommentDao =& DAORegistry::getDAO('ArticleCommentDAO'); $sectionEditorSubmissionDao =& DAORegistry::getDAO('SectionEditorSubmissionDAO'); $journal =& Request::getJournal(); $user =& Request::getUser(); import('classes.mail.ArticleMailTemplate'); $decisionTemplateMap = array(SUBMISSION_SECTION_DECISION_APPROVED => 'SECTION_DECISION_APPROVED', SUBMISSION_SECTION_DECISION_RESUBMIT => 'SECTION_DECISION_RESUBMIT', SUBMISSION_SECTION_DECISION_INCOMPLETE => 'SECTION_DECISION_INCOMPLETE', SUBMISSION_SECTION_DECISION_DECLINED => 'SECTION_DECISION_DECLINE', SUBMISSION_SECTION_DECISION_EXEMPTED => 'SECTION_DECISION_EXEMPT'); $decision = $sectionEditorSubmission->getLastSectionDecision(); if ($decision->getDecision() == SUBMISSION_SECTION_DECISION_APPROVED && $decision->getReviewType() == REVIEW_TYPE_FR) { $email = new ArticleMailTemplate($sectionEditorSubmission, null, 'SECTION_DECISION_FR_APPROVED'); } elseif ($decision->getDecision() == SUBMISSION_SECTION_DECISION_EXEMPTED && $decision->getComments() == null) { return true; } else { $email = new ArticleMailTemplate($sectionEditorSubmission, null, isset($decisionTemplateMap[$decision->getDecision()]) ? $decisionTemplateMap[$decision->getDecision()] : null); } $copyeditor = $sectionEditorSubmission->getUserBySignoffType('SIGNOFF_COPYEDITING_INITIAL'); if ($send && !$email->hasErrors()) { HookRegistry::call('SectionEditorAction::emailEditorDecisionComment', array(&$sectionEditorSubmission, &$send)); $email->send(); $articleComment = new ArticleComment(); $articleComment->setCommentType(COMMENT_TYPE_SECTION_DECISION); $articleComment->setRoleId(Validation::isEditor() ? ROLE_ID_EDITOR : ROLE_ID_SECTION_EDITOR); $articleComment->setArticleId($sectionEditorSubmission->getArticleId()); $articleComment->setAuthorId($user->getUserId()); $articleComment->setCommentTitle($email->getSubject()); $articleComment->setComments($email->getBody()); $articleComment->setDatePosted(Core::getCurrentDate()); $articleComment->setViewable(true); $articleComment->setAssocId($sectionEditorSubmission->getArticleId()); $articleCommentDao->insertArticleComment($articleComment); return true; } else { if (!Request::getUserVar('continued')) { $authorUser =& $userDao->getUser($sectionEditorSubmission->getUserId()); $authorEmail = $authorUser->getEmail(); $email->assignParams(array('editorialContactSignature' => $user->getContactSignature(), 'authorName' => $authorUser->getFullName(), 'urlOngoing' => Request::url(null, 'author', 'index', 'ongoingResearches'), 'urlDrafts' => Request::url(null, 'author', 'index', 'proposalsToSubmit'), 'url' => Request::url(null, 'author', 'submissionReview', $sectionEditorSubmission->getArticleId()), 'reviewType' => Locale::translate($decision->getReviewTypeKey()), 'journalTitle' => $journal->getLocalizedTitle())); $email->addRecipient($authorEmail, $authorUser->getFullName()); if ($journal->getSetting('notifyAllAuthorsOnDecision')) { foreach ($sectionEditorSubmission->getAuthors() as $author) { if ($author->getEmail() != $authorEmail) { $email->addCc($author->getEmail(), $author->getFullName()); } } } import('classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $decisionFiles =& $decision->getDecisionFiles(); foreach ($decisionFiles as $file) { if ($file) { $temporaryFile = $temporaryFileManager->articleToTemporaryFile($file, $user->getId()); $email->addPersistAttachment($temporaryFile); } } } elseif (Request::getUserVar('importPeerReviews')) { $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO'); $reviewAssignments =& $reviewAssignmentDao->getByDecisionId($sectionEditorSubmission->getLastSectionDecisionId()); $reviewIndexes =& $reviewAssignmentDao->getReviewIndexesForDecision($sectionEditorSubmission->getLastSectionDecisionId()); $body = ''; foreach ($reviewAssignments as $reviewAssignment) { // If the reviewer has completed the assignment, then import the review. if ($reviewAssignment->getDateCompleted() != null && !$reviewAssignment->getCancelled()) { // Get the comments associated with this review assignment $articleComments =& $articleCommentDao->getArticleComments($sectionEditorSubmission->getArticleId(), COMMENT_TYPE_PEER_REVIEW, $reviewAssignment->getId()); if ($articleComments) { $body .= "------------------------------------------------------\n"; $body .= Locale::translate('submission.comments.importPeerReviews.reviewerLetter', array('reviewerLetter' => chr(ord('A') + $reviewIndexes[$reviewAssignment->getId()]))) . "\n"; if (is_array($articleComments)) { foreach ($articleComments as $comment) { // If the comment is viewable by the author, then add the comment. if ($comment->getViewable()) { $body .= String::html2text($comment->getComments()) . "\n\n"; } } } $body .= "------------------------------------------------------\n\n"; } if ($reviewFormId = $reviewAssignment->getReviewFormId()) { $reviewId = $reviewAssignment->getId(); $reviewFormResponseDao =& DAORegistry::getDAO('ReviewFormResponseDAO'); $reviewFormElementDao =& DAORegistry::getDAO('ReviewFormElementDAO'); $reviewFormElements =& $reviewFormElementDao->getReviewFormElements($reviewFormId); if (!$articleComments) { $body .= "------------------------------------------------------\n"; $body .= Locale::translate('submission.comments.importPeerReviews.reviewerLetter', array('reviewerLetter' => chr(ord('A') + $reviewIndexes[$reviewAssignment->getId()]))) . "\n\n"; } foreach ($reviewFormElements as $reviewFormElement) { if ($reviewFormElement->getIncluded()) { $body .= String::html2text($reviewFormElement->getLocalizedQuestion()) . ": \n"; $reviewFormResponse = $reviewFormResponseDao->getReviewFormResponse($reviewId, $reviewFormElement->getId()); if ($reviewFormResponse) { $possibleResponses = $reviewFormElement->getLocalizedPossibleResponses(); if (in_array($reviewFormElement->getElementType(), $reviewFormElement->getMultipleResponsesElementTypes())) { if ($reviewFormElement->getElementType() == REVIEW_FORM_ELEMENT_TYPE_CHECKBOXES) { foreach ($reviewFormResponse->getValue() as $value) { $body .= "\t" . String::html2text($possibleResponses[$value - 1]['content']) . "\n"; } } else { $body .= "\t" . String::html2text($possibleResponses[$reviewFormResponse->getValue() - 1]['content']) . "\n"; } $body .= "\n"; } else { $body .= "\t" . String::html2text($reviewFormResponse->getValue()) . "\n\n"; } } } } $body .= "------------------------------------------------------\n\n"; } } } $oldBody = $email->getBody(); if (!empty($oldBody)) { $oldBody .= "\n"; } $email->setBody($oldBody . $body); } $email->displayEditForm(Request::url(null, null, 'emailEditorDecisionComment', 'send'), array('articleId' => $sectionEditorSubmission->getArticleId()), 'submission/comment/editorDecisionEmail.tpl', array('isAnEditor' => true)); return false; } }
function display(&$args) { $templateMgr =& TemplateManager::getManager(); $request =& $this->getRequest(); parent::display($args); $conference =& $request->getConference(); $schedConf =& $request->getSchedConf(); switch (array_shift($args)) { case 'exportPaper': $paperIds = array(array_shift($args)); $result = array_shift(PaperSearch::formatResults($paperIds)); $this->exportPaper($schedConf, $result['track'], $result['publishedPaper']); break; case 'exportPapers': $paperIds = $request->getUserVar('paperId'); if (!isset($paperIds)) { $paperIds = array(); } $results =& PaperSearch::formatResults($paperIds); $this->exportPapers($results); break; case 'papers': // Display a list of papers for export $this->setBreadcrumbs(array(), true); $publishedPaperDao = DAORegistry::getDAO('PublishedPaperDAO'); $rangeInfo = Handler::getRangeInfo($request, 'papers'); $paperIds = $publishedPaperDao->getPublishedPaperIdsAlphabetizedBySchedConf($conference->getId(), $schedConf->getId()); $totalPapers = count($paperIds); if ($rangeInfo->isValid()) { $paperIds = array_slice($paperIds, $rangeInfo->getCount() * ($rangeInfo->getPage() - 1), $rangeInfo->getCount()); } import('lib.pkp.classes.core.VirtualArrayIterator'); $iterator = new VirtualArrayIterator(PaperSearch::formatResults($paperIds), $totalPapers, $rangeInfo->getPage(), $rangeInfo->getCount()); $templateMgr->assign_by_ref('papers', $iterator); $templateMgr->display($this->getTemplatePath() . 'papers.tpl'); break; case 'import': import('classes.file.TemporaryFileManager'); $trackDao = DAORegistry::getDAO('TrackDAO'); $user =& $request->getUser(); $temporaryFileManager = new TemporaryFileManager(); if ($existingFileId = $request->getUserVar('temporaryFileId')) { // The user has just entered more context. Fetch an existing file. $temporaryFile = $temporaryFileManager->getFile($existingFileId, $user->getId()); } else { $temporaryFile = $temporaryFileManager->handleUpload('importFile', $user->getId()); } $context = array('conference' => $conference, 'schedConf' => $schedConf, 'user' => $user); if ($trackId = $request->getUserVar('trackId')) { $context['track'] = $trackDao->getTrack($trackId); } if (!$temporaryFile) { $templateMgr->assign('error', 'plugins.importexport.native.error.uploadFailed'); return $templateMgr->display($this->getTemplatePath() . 'importError.tpl'); } $doc =& $this->getDocument($temporaryFile->getFilePath()); if (substr($this->getRootNodeName($doc), 0, 5) === 'paper') { // Ensure the user has supplied enough valid information to // import papers within an appropriate context. If not, // prompt them for the. if (!isset($context['track'])) { AppLocale::requireComponents(LOCALE_COMPONENT_APP_AUTHOR); $templateMgr->assign('trackOptions', array('0' => __('author.submit.selectTrack')) + $trackDao->getTrackTitles($schedConf->getId(), false)); $templateMgr->assign('temporaryFileId', $temporaryFile->getId()); return $templateMgr->display($this->getTemplatePath() . 'paperContext.tpl'); } } @set_time_limit(0); if ($this->handleImport($context, $doc, $errors, $papers, false)) { $templateMgr->assign_by_ref('papers', $papers); return $templateMgr->display($this->getTemplatePath() . 'importSuccess.tpl'); } else { $templateMgr->assign_by_ref('errors', $errors); return $templateMgr->display($this->getTemplatePath() . 'importError.tpl'); } break; default: $this->setBreadcrumbs(); $templateMgr->display($this->getTemplatePath() . 'index.tpl'); } }
/** * Notifies a reviewer about a review assignment. * @param $sectionEditorSubmission object * @param $reviewId int * @param $send boolean * @param $request object * @return boolean true iff ready for redirect */ function notifyReviewer($sectionEditorSubmission, $reviewId, $send, $request) { $sectionEditorSubmissionDao =& DAORegistry::getDAO('SectionEditorSubmissionDAO'); $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO'); $userDao =& DAORegistry::getDAO('UserDAO'); $journal =& $request->getJournal(); $user =& $request->getUser(); $reviewAssignment =& $reviewAssignmentDao->getById($reviewId); $isEmailBasedReview = $journal->getSetting('mailSubmissionsToReviewers') == 1 ? true : false; $reviewerAccessKeysEnabled = $journal->getSetting('reviewerAccessKeysEnabled'); // If we're using access keys, disable the address fields // for this message. (Prevents security issue: section editor // could CC or BCC someone else, or change the reviewer address, // in order to get the access key.) $preventAddressChanges = $reviewerAccessKeysEnabled; import('classes.mail.ArticleMailTemplate'); // Determine which email template to use based on journal settings and current round switch (true) { case $isEmailBasedReview && $reviewAssignment->getRound() == 1: $emailTemplate = 'REVIEW_REQUEST_ATTACHED'; break; case $isEmailBasedReview && $reviewAssignment->getRound() > 1: $emailTemplate = 'REVIEW_REQUEST_ATTACHED_SUBSEQUENT'; break; case $reviewerAccessKeysEnabled && $reviewAssignment->getRound() == 1: $emailTemplate = 'REVIEW_REQUEST_ONECLICK'; break; case $reviewerAccessKeysEnabled && $reviewAssignment->getRound() > 1: $emailTemplate = 'REVIEW_REQUEST_ONECLICK_SUBSEQUENT'; break; case $reviewAssignment->getRound() == 1: $emailTemplate = 'REVIEW_REQUEST'; break; case $reviewAssignment->getRound() > 1: $emailTemplate = 'REVIEW_REQUEST_SUBSEQUENT'; break; } $email = new ArticleMailTemplate($sectionEditorSubmission, $emailTemplate, null, $isEmailBasedReview ? true : null); if ($preventAddressChanges) { $email->setAddressFieldsEnabled(false); } if ($reviewAssignment->getSubmissionId() == $sectionEditorSubmission->getId() && $reviewAssignment->getReviewFileId()) { $reviewer =& $userDao->getUser($reviewAssignment->getReviewerId()); if (!isset($reviewer)) { return true; } if (!$email->isEnabled() || $send && !$email->hasErrors()) { HookRegistry::call('SectionEditorAction::notifyReviewer', array(&$sectionEditorSubmission, &$reviewAssignment, &$email)); if ($email->isEnabled()) { if ($reviewerAccessKeysEnabled) { import('lib.pkp.classes.security.AccessKeyManager'); import('pages.reviewer.ReviewerHandler'); $accessKeyManager = new AccessKeyManager(); // Key lifetime is the typical review period plus four weeks $keyLifetime = ($journal->getSetting('numWeeksPerReview') + 4) * 7; $email->addPrivateParam('ACCESS_KEY', $accessKeyManager->createKey('ReviewerContext', $reviewer->getId(), $reviewId, $keyLifetime)); } if ($preventAddressChanges) { // Ensure that this messages goes to the reviewer, and the reviewer ONLY. $email->clearAllRecipients(); $email->addRecipient($reviewer->getEmail(), $reviewer->getFullName()); } $email->send($request); } $reviewAssignment->setDateNotified(Core::getCurrentDate()); $reviewAssignment->setCancelled(0); $reviewAssignment->stampModified(); $reviewAssignmentDao->updateReviewAssignment($reviewAssignment); return true; } else { if (!$request->getUserVar('continued') || $preventAddressChanges) { $email->addRecipient($reviewer->getEmail(), $reviewer->getFullName()); } if (!$request->getUserVar('continued')) { $weekLaterDate = strftime(Config::getVar('general', 'date_format_short'), strtotime('+1 week')); if ($reviewAssignment->getDateDue() != null) { $reviewDueDate = strftime(Config::getVar('general', 'date_format_short'), strtotime($reviewAssignment->getDateDue())); } else { $numWeeks = max((int) $journal->getSetting('numWeeksPerReview'), 2); $reviewDueDate = strftime(Config::getVar('general', 'date_format_short'), strtotime('+' . $numWeeks . ' week')); } $submissionUrl = $request->url(null, 'reviewer', 'submission', $reviewId, $reviewerAccessKeysEnabled ? array('key' => 'ACCESS_KEY') : array()); $paramArray = array('reviewerName' => $reviewer->getFullName(), 'weekLaterDate' => $weekLaterDate, 'reviewDueDate' => $reviewDueDate, 'reviewerUsername' => $reviewer->getUsername(), 'reviewerPassword' => $reviewer->getPassword(), 'editorialContactSignature' => $user->getContactSignature(), 'reviewGuidelines' => String::html2text($journal->getLocalizedSetting('reviewGuidelines')), 'submissionReviewUrl' => $submissionUrl, 'abstractTermIfEnabled' => $sectionEditorSubmission->getLocalizedAbstract() == '' ? '' : __('article.abstract'), 'passwordResetUrl' => $request->url(null, 'login', 'resetPassword', $reviewer->getUsername(), array('confirm' => Validation::generatePasswordResetHash($reviewer->getId())))); $email->assignParams($paramArray); if ($isEmailBasedReview) { // An email-based review process was selected. Attach // the current review version. import('classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $reviewVersion =& $sectionEditorSubmission->getReviewFile(); if ($reviewVersion) { $temporaryFile = $temporaryFileManager->articleToTemporaryFile($reviewVersion, $user->getId()); $email->addPersistAttachment($temporaryFile); } } } $email->displayEditForm($request->url(null, null, 'notifyReviewer'), array('reviewId' => $reviewId, 'articleId' => $sectionEditorSubmission->getId())); return false; } } return true; }
/** * Upload a new library file. * @param $args array * @param $request PKPRequest * @return string */ function uploadFile($args, &$request) { $router =& $request->getRouter(); $context = $request->getContext(); $user =& $request->getUser(); import('classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFile = $temporaryFileManager->handleUpload('uploadedFile', $user->getId()); if ($temporaryFile) { $json = new JSON(true); $json->setAdditionalAttributes(array('temporaryFileId' => $temporaryFile->getId())); } else { $json = new JSON(false, Locale::translate('common.uploadFailed')); } return $json->getString(); }
/** * Decompress uploaded plugin and install in the correct plugin directory. * @param $function string type of operation to perform after upload ('upgrade' or 'install') * @param $category string the category of the uploaded plugin (upgrade only) * @param $plugin string the name of the uploaded plugin (upgrade only) */ function uploadPlugin($function, $category = null, $plugin = null) { $this->validate(); $templateMgr =& TemplateManager::getManager(); $this->setupTemplate(true); $templateMgr->assign('error', false); $templateMgr->assign('uploaded', false); $templateMgr->assign('path', $function); $errorMsg = ''; if (Request::getUserVar('uploadPlugin')) { import('classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $user =& Request::getUser(); } else { $errorMsg = 'manager.plugins.fileSelectError'; } if (empty($errorMsg)) { if ($temporaryFile = $temporaryFileManager->handleUpload('newPlugin', $user->getId())) { // tar archive basename (less potential version number) must equal plugin directory name // and plugin files must be in a directory named after the plug-in. $matches = array(); String::regexp_match_get('/^[a-zA-Z0-9]+/', basename($temporaryFile->getOriginalFileName(), '.tar.gz'), $matches); $pluginName = array_pop($matches); // Create random dirname to avoid symlink attacks. $pluginDir = dirname($temporaryFile->getFilePath()) . DIRECTORY_SEPARATOR . $pluginName . substr(md5(mt_rand()), 0, 10); mkdir($pluginDir); } else { $errorMsg = 'manager.plugins.uploadError'; } } if (empty($errorMsg)) { // Test whether the tar binary is available for the export to work $tarBinary = Config::getVar('cli', 'tar'); if (!empty($tarBinary) && file_exists($tarBinary)) { exec($tarBinary . ' -xzf ' . escapeshellarg($temporaryFile->getFilePath()) . ' -C ' . escapeshellarg($pluginDir)); } else { $errorMsg = 'manager.plugins.tarCommandNotFound'; } } if (empty($errorMsg)) { // We should now find a directory named after the // plug-in within the extracted archive. $pluginDir .= DIRECTORY_SEPARATOR . $pluginName; if (is_dir($pluginDir)) { if ($function == 'install') { $this->installPlugin($pluginDir, $templateMgr); } else { if ($function == 'upgrade') { $this->upgradePlugin($pluginDir, $templateMgr, $category, $plugin); } } } else { $errorMsg = 'manager.plugins.invalidPluginArchive'; } } if (!empty($errorMsg)) { $templateMgr->assign('error', true); $templateMgr->assign('message', $errorMsg); } $templateMgr->display('manager/plugins/managePlugins.tpl'); }
function display(&$args, $request) { $templateMgr =& TemplateManager::getManager(); parent::display($args, $request); $issueDao =& DAORegistry::getDAO('IssueDAO'); $journal =& $request->getJournal(); switch (array_shift($args)) { case 'exportIssues': $issueIds = $request->getUserVar('issueId'); if (!isset($issueIds)) { $issueIds = array(); } $issues = array(); foreach ($issueIds as $issueId) { $issue =& $issueDao->getIssueById($issueId, $journal->getId()); if (!$issue) { $request->redirect(); } $issues[] =& $issue; unset($issue); } $this->exportIssues($journal, $issues); break; case 'exportIssue': $issueId = array_shift($args); $issue =& $issueDao->getIssueById($issueId, $journal->getId()); if (!$issue) { $request->redirect(); } $this->exportIssue($journal, $issue); break; case 'exportArticle': $articleIds = array(array_shift($args)); $result = array_shift(ArticleSearch::formatResults($articleIds)); $this->exportArticle($journal, $result['issue'], $result['section'], $result['publishedArticle']); break; case 'exportArticles': $articleIds = $request->getUserVar('articleId'); if (!isset($articleIds)) { $articleIds = array(); } $results =& ArticleSearch::formatResults($articleIds); $this->exportArticles($results); break; case 'issues': // Display a list of issues for export $this->setBreadcrumbs(array(), true); AppLocale::requireComponents(LOCALE_COMPONENT_OJS_EDITOR); $issueDao =& DAORegistry::getDAO('IssueDAO'); $issues =& $issueDao->getIssues($journal->getId(), Handler::getRangeInfo('issues')); $templateMgr->assign_by_ref('issues', $issues); $templateMgr->display($this->getTemplatePath() . 'issues.tpl'); break; case 'articles': // Display a list of articles for export $this->setBreadcrumbs(array(), true); $publishedArticleDao =& DAORegistry::getDAO('PublishedArticleDAO'); $rangeInfo = Handler::getRangeInfo('articles'); $articleIds = $publishedArticleDao->getPublishedArticleIdsAlphabetizedByJournal($journal->getId(), false); $totalArticles = count($articleIds); if ($rangeInfo->isValid()) { $articleIds = array_slice($articleIds, $rangeInfo->getCount() * ($rangeInfo->getPage() - 1), $rangeInfo->getCount()); } import('lib.pkp.classes.core.VirtualArrayIterator'); $iterator = new VirtualArrayIterator(ArticleSearch::formatResults($articleIds), $totalArticles, $rangeInfo->getPage(), $rangeInfo->getCount()); $templateMgr->assign_by_ref('articles', $iterator); $templateMgr->display($this->getTemplatePath() . 'articles.tpl'); break; case 'import': AppLocale::requireComponents(LOCALE_COMPONENT_OJS_EDITOR, LOCALE_COMPONENT_OJS_AUTHOR); import('classes.file.TemporaryFileManager'); $issueDao =& DAORegistry::getDAO('IssueDAO'); $sectionDao =& DAORegistry::getDAO('SectionDAO'); $user =& $request->getUser(); $temporaryFileManager = new TemporaryFileManager(); if ($existingFileId = $request->getUserVar('temporaryFileId')) { // The user has just entered more context. Fetch an existing file. $temporaryFile = $temporaryFileManager->getFile($existingFileId, $user->getId()); } else { $temporaryFile = $temporaryFileManager->handleUpload('importFile', $user->getId()); } $context = array('journal' => $journal, 'user' => $user); if ($sectionId = $request->getUserVar('sectionId')) { $context['section'] = $sectionDao->getSection($sectionId); } if ($issueId = $request->getUserVar('issueId')) { $context['issue'] = $issueDao->getIssueById($issueId, $journal->getId()); } if (!$temporaryFile) { $templateMgr->assign('error', 'plugins.importexport.native.error.uploadFailed'); return $templateMgr->display($this->getTemplatePath() . 'importError.tpl'); } $doc =& $this->getDocument($temporaryFile->getFilePath()); if (substr($this->getRootNodeName($doc), 0, 7) === 'article') { // Ensure the user has supplied enough valid information to // import articles within an appropriate context. If not, // prompt them for the. if (!isset($context['issue']) || !isset($context['section'])) { $issues =& $issueDao->getIssues($journal->getId(), Handler::getRangeInfo('issues')); $templateMgr->assign_by_ref('issues', $issues); $templateMgr->assign('sectionOptions', array('0' => __('author.submit.selectSection')) + $sectionDao->getSectionTitles($journal->getId(), false)); $templateMgr->assign('temporaryFileId', $temporaryFile->getId()); return $templateMgr->display($this->getTemplatePath() . 'articleContext.tpl'); } } @set_time_limit(0); if ($this->handleImport($context, $doc, $errors, $issues, $articles, false)) { $templateMgr->assign_by_ref('issues', $issues); $templateMgr->assign_by_ref('articles', $articles); return $templateMgr->display($this->getTemplatePath() . 'importSuccess.tpl'); } else { $templateMgr->assign_by_ref('errors', $errors); return $templateMgr->display($this->getTemplatePath() . 'importError.tpl'); } break; default: $this->setBreadcrumbs(); $templateMgr->display($this->getTemplatePath() . 'index.tpl'); } }
/** * Upload the file and add it to the database. * @param $fileName string index into the $_FILES array * @param $userId int * @return object The new TemporaryFile or false on failure */ function handleUpload($fileName, $userId) { // Get the file extension, then rename the file. $fileExtension = $this->parseFileExtension($this->getUploadedFileName($fileName)); if (!$this->fileExists($this->filesDir, 'dir')) { // Try to create destination directory $this->mkdirtree($this->filesDir); } $newFileName = basename(tempnam($this->filesDir, $fileExtension)); if (!$newFileName) { return false; } if ($this->uploadFile($fileName, $this->filesDir . $newFileName)) { $temporaryFileDao =& DAORegistry::getDAO('TemporaryFileDAO'); $temporaryFile = new TemporaryFile(); $temporaryFile->setUserId($userId); $temporaryFile->setFileName($newFileName); $temporaryFile->setFileType(String::mime_content_type($this->filesDir . $newFileName)); $temporaryFile->setFileSize($_FILES[$fileName]['size']); $temporaryFile->setOriginalFileName(TemporaryFileManager::truncateFileName($_FILES[$fileName]['name'], 127)); $temporaryFile->setDateUploaded(Core::getCurrentDate()); $temporaryFileDao->insertTemporaryFile($temporaryFile); return $temporaryFile; } else { return false; } }
/** * Delete all attachments associated with this message. * Called from send(). * @param $userId int */ function _clearAttachments($userId) { import('file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $persistAttachments = Request::getUserVar('persistAttachments'); if (is_array($persistAttachments)) { foreach ($persistAttachments as $fileId) { $temporaryFile = $temporaryFileManager->getFile($fileId, $userId); if (!empty($temporaryFile)) { $temporaryFileManager->deleteFile($temporaryFile->getId(), $userId); } } } }
/** * @see ImportExportPlugin::display() */ function display(&$args, $request) { $templateMgr = TemplateManager::getManager($request); parent::display($args, $request); $issueDao = DAORegistry::getDAO('IssueDAO'); $journal = $request->getJournal(); switch (array_shift($args)) { case 'exportIssues': $issueIds = $request->getUserVar('issueId'); if (!isset($issueIds)) { $issueIds = array(); } $issues = array(); foreach ($issueIds as $issueId) { $issue = $issueDao->getById($issueId, $journal->getId()); if (!$issue) { $request->redirect(); } $issues[] = $issue; } $this->exportPubIdsForIssues($journal, $issues); break; case 'exportIssue': $issueId = array_shift($args); $issue = $issueDao->getById($issueId, $journal->getId()); if (!$issue) { $request->redirect(); } $issues = array($issue); $this->exportPubIdsForIssues($journal, $issues); break; case 'selectIssue': // Display a list of issues for export AppLocale::requireComponents(array(LOCALE_COMPONENT_APP_EDITOR)); $issueDao = DAORegistry::getDAO('IssueDAO'); $issues = $issueDao->getIssues($journal->getId(), Handler::getRangeInfo($this->getRequest(), 'issues')); $templateMgr->assign('issues', $issues); $templateMgr->display($this->getTemplatePath() . 'selectIssue.tpl'); break; case 'import': import('lib.pkp.classes.file.TemporaryFileManager'); $user = $request->getUser(); $temporaryFileManager = new TemporaryFileManager(); if ($existingFileId = $request->getUserVar('temporaryFileId')) { // The user has just entered more context. Fetch an existing file. $temporaryFile = $temporaryFileManager->getFile($existingFileId, $user->getId()); } else { $temporaryFile = $temporaryFileManager->handleUpload('importFile', $user->getId()); } if (!$temporaryFile) { $templateMgr->assign('error', 'plugins.importexport.pubIds.import.error.uploadFailed'); return $templateMgr->display($this->getTemplatePath() . 'importResults.tpl'); } $context = array('journal' => $journal); $doc =& $this->getDocument($temporaryFile->getFilePath()); @set_time_limit(0); $this->handleImport($context, $doc, $errors, $pubIds, false); $templateMgr->assign('errors', $errors); $templateMgr->assign('pubIds', $pubIds); return $templateMgr->display($this->getTemplatePath() . 'importResults.tpl'); break; default: $templateMgr->display($this->getTemplatePath() . 'importExportIndex.tpl'); } }
/** * Save settings. */ function execute() { $articleDao = DAORegistry::getDAO('ArticleDAO'); $signoffDao = DAORegistry::getDAO('SignoffDAO'); $sectionEditorSubmissionDao = DAORegistry::getDAO('SectionEditorSubmissionDAO'); $application = PKPApplication::getApplication(); $request = $this->request; $user = $request->getUser(); $router = $request->getRouter(); $journal = $router->getContext($request); $article = $articleDao->newDataObject(); $article->setLocale($journal->getPrimaryLocale()); // FIXME in bug #5543 $article->setUserId($user->getId()); $article->setJournalId($journal->getId()); $article->setSectionId($this->getData('sectionId')); $article->setLanguage($this->getData('language')); $article->setTitle($this->getData('title'), null); // Localized $article->setAbstract($this->getData('abstract'), null); // Localized $article->setDiscipline($this->getData('discipline'), null); // Localized $article->setSubjectClass($this->getData('subjectClass'), null); // Localized $article->setSubject($this->getData('subject'), null); // Localized $article->setCoverageGeo($this->getData('coverageGeo'), null); // Localized $article->setCoverageChron($this->getData('coverageChron'), null); // Localized $article->setCoverageSample($this->getData('coverageSample'), null); // Localized $article->setType($this->getData('type'), null); // Localized $article->setSponsor($this->getData('sponsor'), null); // Localized $article->setCitations($this->getData('citations')); $article->setPages($this->getData('pages')); // Set some default values so the ArticleDAO doesn't complain when adding this article $article->setDateSubmitted(Core::getCurrentDate()); $article->setStatus(STATUS_PUBLISHED); $article->setSubmissionProgress(0); $article->stampStatusModified(); $article->setCurrentRound(1); $article->setFastTracked(1); $article->setHideAuthor(0); $article->setCommentsStatus(0); // Insert the article to get it's ID $articleDao->insertObject($article); $articleId = $article->getId(); // Add authors $authors = $this->getData('authors'); for ($i = 0, $count = count($authors); $i < $count; $i++) { if ($authors[$i]['authorId'] > 0) { // Update an existing author $author =& $authorDao->getAuthor($authors[$i]['authorId'], $articleId); $isExistingAuthor = true; } else { // Create a new author $author = new Author(); $isExistingAuthor = false; } if ($author != null) { $author->setSubmissionId($articleId); $author->setFirstName($authors[$i]['firstName']); $author->setMiddleName($authors[$i]['middleName']); $author->setLastName($authors[$i]['lastName']); if (array_key_exists('affiliation', $authors[$i])) { $author->setAffiliation($authors[$i]['affiliation'], null); } $author->setCountry($authors[$i]['country']); $author->setEmail($authors[$i]['email']); $author->setUrl($authors[$i]['url']); if (array_key_exists('competingInterests', $authors[$i])) { $author->setCompetingInterests($authors[$i]['competingInterests'], null); } $author->setBiography($authors[$i]['biography'], null); $author->setPrimaryContact($this->getData('primaryContact') == $i ? 1 : 0); $author->setSequence($authors[$i]['seq']); if ($isExistingAuthor == false) { $authorDao = DAORegistry::getDAO('AuthorDAO'); /* @var $authorDao AuthorDAO */ $authorDao->insertObject($author); } } } // Add the submission files as galleys import('lib.pkp.classes.file.TemporaryFileManager'); import('classes.file.ArticleFileManager'); $tempFileIds = $this->getData('tempFileId'); $temporaryFileManager = new TemporaryFileManager(); $articleFileManager = new ArticleFileManager($articleId); $designatedPrimary = false; foreach (array_keys($tempFileIds) as $locale) { $temporaryFile = $temporaryFileManager->getFile($tempFileIds[$locale], $user->getId()); $fileId = null; if ($temporaryFile) { $fileId = $articleFileManager->temporaryFileToArticleFile($temporaryFile, SUBMISSION_FILE_SUBMISSION); $fileType = $temporaryFile->getFileType(); if (strstr($fileType, 'html')) { import('classes.article.ArticleHTMLGalley'); $galley = new ArticleHTMLGalley(); } else { import('classes.article.ArticleGalley'); $galley = new ArticleGalley(); } $galley->setArticleId($articleId); $galley->setFileId($fileId); $galley->setLocale($locale); if ($galley->isHTMLGalley()) { $galley->setLabel('HTML'); } else { if (strstr($fileType, 'pdf')) { $galley->setLabel('PDF'); } else { if (strstr($fileType, 'postscript')) { $galley->setLabel('Postscript'); } else { if (strstr($fileType, 'xml')) { $galley->setLabel('XML'); } else { $galley->setLabel(__('common.untitled')); } } } } $galleyDao = DAORegistry::getDAO('ArticleGalleyDAO'); $galleyDao->insertGalley($galley); if (!$designatedPrimary) { $article->setSubmissionFileId($fileId); if ($locale == $journal->getPrimaryLocale()) { // Used to make sure that *some* file // is designated Review Version, but // preferrably the primary locale. $designatedPrimary = true; } } } // Update file search index import('classes.search.ArticleSearchIndex'); $articleSearchIndex = new ArticleSearchIndex(); if (isset($galley)) { $articleSearchIndex->articleFileChanged($galley->getArticleId(), SUBMISSION_SEARCH_GALLEY_FILE, $galley->getFileId()); } $articleSearchIndex->articleChangesFinished(); } // Designate this as the review version by default. $authorSubmissionDao = DAORegistry::getDAO('AuthorSubmissionDAO'); $authorSubmission =& $authorSubmissionDao->getAuthorSubmission($articleId); import('classes.submission.author.AuthorAction'); AuthorAction::designateReviewVersion($authorSubmission, true); // Accept the submission $sectionEditorSubmission =& $sectionEditorSubmissionDao->getSectionEditorSubmission($articleId); $articleFileManager = new ArticleFileManager($articleId); import('classes.submission.sectionEditor.SectionEditorAction'); assert(false); // FIXME: $decisionLabels missing from call below. SectionEditorAction::recordDecision($this->request, $sectionEditorSubmission, SUBMISSION_EDITOR_DECISION_ACCEPT); import('classes.author.form.submit.AuthorSubmitForm'); AuthorSubmitForm::assignEditors($article); $articleDao->updateObject($article); // Add to end of editing queue import('classes.submission.editor.EditorAction'); if (isset($galley)) { EditorAction::expediteSubmission($article, $this->request); } if ($this->getData('destination') == "issue") { // Add to an existing issue $issueId = $this->getData('issueId'); $this->scheduleForPublication($articleId, $issueId); } // Import the references list. $citationDao = DAORegistry::getDAO('CitationDAO'); $rawCitationList = $article->getCitations(); $citationDao->importCitations($request, ASSOC_TYPE_ARTICLE, $articleId, $rawCitationList); // Index article. import('classes.search.ArticleSearchIndex'); $articleSearchIndex = new ArticleSearchIndex(); $articleSearchIndex->articleMetadataChanged($article); $articleSearchIndex->articleChangesFinished(); }
/** * Upload a temporary file. * @param $request Request */ function uploadFile($request) { $user = $request->getUser(); import('lib.pkp.classes.file.TemporaryFileManager'); $temporaryFileManager = new TemporaryFileManager(); $temporaryFile = $temporaryFileManager->handleUpload('uploadedFile', $user->getId()); if ($temporaryFile) { return $temporaryFile->getId(); } return false; }