/**
* Unpublish a previously-published issue
* @param $args array
* @param $request PKPRequest
*/
function unpublishIssue($args, $request)
{
$issue = $this->getAuthorizedContextObject(ASSOC_TYPE_ISSUE);
$journal = $request->getJournal();
$issue->setCurrent(0);
$issue->setPublished(0);
$issue->setDatePublished(null);
$issueDao = DAORegistry::getDAO('IssueDAO');
$issueDao->updateObject($issue);
// insert article tombstones for all articles
import('classes.article.ArticleTombstoneManager');
$articleTombstoneManager = new ArticleTombstoneManager();
$publishedArticleDao = DAORegistry::getDAO('PublishedArticleDAO');
$publishedArticles = $publishedArticleDao->getPublishedArticles($issue->getId());
foreach ($publishedArticles as $article) {
$articleTombstoneManager->insertArticleTombstone($article, $journal);
}
$dispatcher = $request->getDispatcher();
// FIXME: Find a better way to reload the containing tabs.
// Without this, issues don't move between tabs properly.
return $request->redirectUrlJson($dispatcher->url($request, ROUTE_PAGE, null, 'manageIssues'));
}
/**
* Archive a submission.
* @param $sectionEditorSubmission object
*/
function archiveSubmission($sectionEditorSubmission, $request)
{
$sectionEditorSubmissionDao =& DAORegistry::getDAO('SectionEditorSubmissionDAO');
$user =& $request->getUser();
if (HookRegistry::call('SectionEditorAction::archiveSubmission', array(&$sectionEditorSubmission))) {
return;
}
$journal =& $request->getJournal();
if ($sectionEditorSubmission->getStatus() == STATUS_PUBLISHED) {
$publishedArticleDao =& DAORegistry::getDAO('PublishedArticleDAO');
$publishedArticle =& $publishedArticleDao->getPublishedArticleByArticleId($sectionEditorSubmission->getId());
$issueDao =& DAORegistry::getDAO('IssueDAO');
$issue =& $issueDao->getIssueById($publishedArticle->getIssueId(), $publishedArticle->getJournalId());
if ($issue->getPublished()) {
// Insert article tombstone
import('classes.article.ArticleTombstoneManager');
$articleTombstoneManager = new ArticleTombstoneManager();
$articleTombstoneManager->insertArticleTombstone($publishedArticle, $journal);
}
}
$sectionEditorSubmission->setStatus(STATUS_ARCHIVED);
$sectionEditorSubmission->stampStatusModified();
$sectionEditorSubmissionDao->updateSectionEditorSubmission($sectionEditorSubmission);
// Add log
import('classes.article.log.ArticleLog');
ArticleLog::logEvent($request, $sectionEditorSubmission, ARTICLE_LOG_EDITOR_ARCHIVE, 'log.editor.archived');
}
/**
* Remove an article from the issue.
* @param $args array
* @param $request PKPRequest
* @return JSONMessage JSON object
*/
function removeArticle($args, $request)
{
$journal = $request->getJournal();
$articleId = (int) $request->getUserVar('articleId');
$issue = $this->getAuthorizedContextObject(ASSOC_TYPE_ISSUE);
$issueDao = DAORegistry::getDAO('IssueDAO');
$publishedArticleDao = DAORegistry::getDAO('PublishedArticleDAO');
$article = $publishedArticleDao->getPublishedArticleByArticleId($articleId);
import('classes.article.ArticleTombstoneManager');
$articleTombstoneManager = new ArticleTombstoneManager();
if ($article && $article->getIssueId() == $issue->getId()) {
if ($issue->getPublished()) {
$articleTombstoneManager->insertArticleTombstone($article, $journal);
}
$article->setStatus(STATUS_QUEUED);
$article->stampStatusModified();
// If the article is the only one in the section, delete the section from custom issue ordering
$sectionId = $article->getSectionId();
$publishedArticleArray = $publishedArticleDao->getPublishedArticlesBySectionId($sectionId, $issue->getId());
if (sizeof($publishedArticleArray) == 1) {
$sectionDao = DAORegistry::getDAO('SectionDAO');
$sectionDao->deleteCustomSection($issue->getId(), $sectionId);
}
$publishedArticleDao->deletePublishedArticleByArticleId($articleId);
$publishedArticleDao->resequencePublishedArticles($article->getSectionId(), $issue->getId());
return DAO::getDataChangedEvent();
}
// If we've fallen through, it must be a badly-specified article
return new JSONMessage(false);
}
/**
* Unpublish a previously-published issue
*/
function unpublishIssue($args, $request)
{
$issueId = (int) array_shift($args);
$this->validate($issueId);
$issue =& $this->issue;
$journal =& $request->getJournal();
$issue->setCurrent(0);
$issue->setPublished(0);
$issue->setDatePublished(null);
$issueDao =& DAORegistry::getDAO('IssueDAO');
$issueDao->updateIssue($issue);
// insert article tombstones for all articles
import('classes.article.ArticleTombstoneManager');
$articleTombstoneManager = new ArticleTombstoneManager();
$publishedArticleDao =& DAORegistry::getDAO('PublishedArticleDAO');
$publishedArticles =& $publishedArticleDao->getPublishedArticles($issueId);
foreach ($publishedArticles as $article) {
$articleTombstoneManager->insertArticleTombstone($article, $journal);
}
$request->redirect(null, null, 'futureIssues');
}
/**
* Unpublish a previously-published issue
* @param $args array
* @param $request PKPRequest
*/
function unpublishIssue($args, $request)
{
$issue = $this->getAuthorizedContextObject(ASSOC_TYPE_ISSUE);
$journal = $request->getJournal();
if (!$request->checkCSRF()) {
return new JSONMessage(false);
}
$issue->setCurrent(0);
$issue->setPublished(0);
$issue->setDatePublished(null);
$issueDao = DAORegistry::getDAO('IssueDAO');
$issueDao->updateObject($issue);
// insert article tombstones for all articles
import('classes.article.ArticleTombstoneManager');
$articleTombstoneManager = new ArticleTombstoneManager();
$publishedArticleDao = DAORegistry::getDAO('PublishedArticleDAO');
$publishedArticles = $publishedArticleDao->getPublishedArticles($issue->getId());
foreach ($publishedArticles as $article) {
$articleTombstoneManager->insertArticleTombstone($article, $journal);
}
$dispatcher = $request->getDispatcher();
$json = new JSONMessage();
$json->setEvent('containerReloadRequested', array('tabsUrl' => $dispatcher->url($request, ROUTE_PAGE, null, 'manageIssues', 'index')));
return $json;
}
/**
* Save the metadata and store the catalog data for this published
* monograph.
*/
function execute($request)
{
parent::execute($request);
$submission = $this->getSubmission();
$context = $request->getContext();
$waivePublicationFee = $request->getUserVar('waivePublicationFee') ? true : false;
if ($waivePublicationFee) {
$markAsPaid = $request->getUserVar('markAsPaid');
import('classes.payment.ojs.OJSPaymentManager');
$paymentManager = new OJSPaymentManager($request);
$user = $request->getUser();
// Get a list of author user IDs
$authorUserIds = array();
$stageAssignmentDao = DAORegistry::getDAO('StageAssignmentDAO');
$submitterAssignments = $stageAssignmentDao->getBySubmissionAndRoleId($submission->getId(), ROLE_ID_AUTHOR);
$submitterAssignment = $submitterAssignments->next();
assert($submitterAssignment);
// At least one author should be assigned
$queuedPayment =& $paymentManager->createQueuedPayment($context->getId(), PAYMENT_TYPE_PUBLICATION, $markAsPaid ? $submitterAssignment->getUserId() : $user->getId(), $submission->getId(), $markAsPaid ? $context->getSetting('publicationFee') : 0, $markAsPaid ? $context->getSetting('currency') : '');
$paymentManager->queuePayment($queuedPayment);
// Since this is a waiver, fulfill the payment immediately
$paymentManager->fulfillQueuedPayment($request, $queuedPayment, $markAsPaid ? 'ManualPayment' : 'Waiver');
} else {
// Get the issue for publication.
$issueDao = DAORegistry::getDAO('IssueDAO');
$issueId = $this->getData('issueId');
$issue = $issueDao->getById($issueId, $context->getId());
$sectionDao = DAORegistry::getDAO('SectionDAO');
$publishedArticleDao = DAORegistry::getDAO('PublishedArticleDAO');
$publishedArticle = $publishedArticleDao->getPublishedArticleByArticleId($submission->getId(), null, false);
/* @var $publishedArticle PublishedArticle */
if ($publishedArticle) {
if (!$issue || !$issue->getPublished()) {
$fromIssue = $issueDao->getById($publishedArticle->getIssueId(), $context->getId());
if ($fromIssue->getPublished()) {
// Insert article tombstone
import('classes.article.ArticleTombstoneManager');
$articleTombstoneManager = new ArticleTombstoneManager();
$articleTombstoneManager->insertArticleTombstone($submission, $context);
}
}
}
import('classes.search.ArticleSearchIndex');
$articleSearchIndex = new ArticleSearchIndex();
// define the access status for the article if none is set.
$accessStatus = $this->getData('accessStatus') != '' ? $this->getData('accessStatus') : ARTICLE_ACCESS_ISSUE_DEFAULT;
$articleDao = DAORegistry::getDAO('ArticleDAO');
if (!is_null($this->getData('pages'))) {
$submission->setPages($this->getData('pages'));
}
if ($issue) {
// Schedule against an issue.
if ($publishedArticle) {
$publishedArticle->setIssueId($issueId);
$publishedArticle->setSequence(REALLY_BIG_NUMBER);
$publishedArticle->setDatePublished($this->getData('datePublished'));
$publishedArticle->setAccessStatus($accessStatus);
$publishedArticleDao->updatePublishedArticle($publishedArticle);
// Re-index the published article metadata.
$articleSearchIndex->articleMetadataChanged($publishedArticle);
} else {
$publishedArticle = $publishedArticleDao->newDataObject();
$publishedArticle->setId($submission->getId());
$publishedArticle->setIssueId($issueId);
$publishedArticle->setDatePublished(Core::getCurrentDate());
$publishedArticle->setSequence(REALLY_BIG_NUMBER);
$publishedArticle->setAccessStatus($accessStatus);
$publishedArticleDao->insertObject($publishedArticle);
// If we're using custom section ordering, and if this is the first
// article published in a section, make sure we enter a custom ordering
// for it. (Default at the end of the list.)
if ($sectionDao->customSectionOrderingExists($issueId)) {
if ($sectionDao->getCustomSectionOrder($issueId, $submission->getSectionId()) === null) {
$sectionDao->insertCustomSectionOrder($issueId, $submission->getSectionId(), REALLY_BIG_NUMBER);
$sectionDao->resequenceCustomSectionOrders($issueId);
}
}
// Index the published article metadata and files for the first time.
$articleSearchIndex->articleMetadataChanged($publishedArticle);
$articleSearchIndex->submissionFilesChanged($publishedArticle);
}
} else {
if ($publishedArticle) {
// This was published elsewhere; make sure we don't
// mess up sequencing information.
$issueId = $publishedArticle->getIssueId();
$publishedArticleDao->deletePublishedArticleByArticleId($submission->getId());
// Delete the article from the search index.
$articleSearchIndex->submissionFileDeleted($submission->getId());
}
}
if ($this->getData('attachPermissions')) {
$submission->setCopyrightYear($this->getData('copyrightYear'));
$submission->setCopyrightHolder($this->getData('copyrightHolder'), null);
// Localized
$submission->setLicenseURL($this->getData('licenseURL'));
} else {
$submission->setCopyrightYear(null);
$submission->setCopyrightHolder(null, null);
$submission->setLicenseURL(null);
}
// Resequence the articles.
$publishedArticleDao->resequencePublishedArticles($submission->getSectionId(), $issueId);
$submission->stampStatusModified();
if ($issue && $issue->getPublished()) {
$submission->setStatus(STATUS_PUBLISHED);
// delete article tombstone
$tombstoneDao = DAORegistry::getDAO('DataObjectTombstoneDAO');
$tombstoneDao->deleteByDataObjectId($submission->getId());
} else {
$submission->setStatus(STATUS_QUEUED);
}
$articleDao->updateObject($submission);
$articleSearchIndex->articleChangesFinished();
}
}
/**
* Schedule/unschedule an article for publication.
* @param $args array
* @param $request object
*/
function scheduleForPublication($args, $request)
{
$articleId = (int) array_shift($args);
$issueId = (int) $request->getUserVar('issueId');
$this->validate($articleId, SECTION_EDITOR_ACCESS_EDIT);
$journal =& $request->getJournal();
$submission =& $this->submission;
$sectionEditorSubmissionDao =& DAORegistry::getDAO('SectionEditorSubmissionDAO');
$publishedArticleDao =& DAORegistry::getDAO('PublishedArticleDAO');
$sectionDao =& DAORegistry::getDAO('SectionDAO');
$publishedArticle =& $publishedArticleDao->getPublishedArticleByArticleId($articleId);
$issueDao =& DAORegistry::getDAO('IssueDAO');
$issue =& $issueDao->getIssueById($issueId, $journal->getId());
if ($publishedArticle) {
if (!$issue || !$issue->getPublished()) {
$fromIssue =& $issueDao->getIssueById($publishedArticle->getIssueId(), $journal->getId());
if ($fromIssue->getPublished()) {
// Insert article tombstone
import('classes.article.ArticleTombstoneManager');
$articleTombstoneManager = new ArticleTombstoneManager();
$articleTombstoneManager->insertArticleTombstone($submission, $journal);
}
}
}
import('classes.search.ArticleSearchIndex');
$articleSearchIndex = new ArticleSearchIndex();
if ($issue) {
// Schedule against an issue.
if ($publishedArticle) {
$publishedArticle->setIssueId($issueId);
$publishedArticle->setSeq(REALLY_BIG_NUMBER);
$publishedArticleDao->updatePublishedArticle($publishedArticle);
// Re-index the published article metadata.
$articleSearchIndex->articleMetadataChanged($publishedArticle);
} else {
$publishedArticle = new PublishedArticle();
$publishedArticle->setId($submission->getId());
$publishedArticle->setIssueId($issueId);
$publishedArticle->setDatePublished(Core::getCurrentDate());
$publishedArticle->setSeq(REALLY_BIG_NUMBER);
$publishedArticle->setAccessStatus(ARTICLE_ACCESS_ISSUE_DEFAULT);
$publishedArticleDao->insertPublishedArticle($publishedArticle);
// If we're using custom section ordering, and if this is the first
// article published in a section, make sure we enter a custom ordering
// for it. (Default at the end of the list.)
if ($sectionDao->customSectionOrderingExists($issueId)) {
if ($sectionDao->getCustomSectionOrder($issueId, $submission->getSectionId()) === null) {
$sectionDao->insertCustomSectionOrder($issueId, $submission->getSectionId(), REALLY_BIG_NUMBER);
$sectionDao->resequenceCustomSectionOrders($issueId);
}
}
// Index the published article metadata and files for the first time.
$articleSearchIndex->articleMetadataChanged($publishedArticle);
$articleSearchIndex->articleFilesChanged($publishedArticle);
}
} else {
if ($publishedArticle) {
// This was published elsewhere; make sure we don't
// mess up sequencing information.
$issueId = $publishedArticle->getIssueId();
$publishedArticleDao->deletePublishedArticleByArticleId($articleId);
// Delete the article from the search index.
$articleSearchIndex->articleFileDeleted($articleId);
}
}
// Resequence the articles.
$publishedArticleDao->resequencePublishedArticles($submission->getSectionId(), $issueId);
$submission->stampStatusModified();
if ($issue && $issue->getPublished()) {
$submission->setStatus(STATUS_PUBLISHED);
// delete article tombstone
$tombstoneDao =& DAORegistry::getDAO('DataObjectTombstoneDAO');
$tombstoneDao->deleteByDataObjectId($submission->getId());
} else {
$submission->setStatus(STATUS_QUEUED);
}
$sectionEditorSubmissionDao->updateSectionEditorSubmission($submission);
// Call initialize permissions again to check if copyright year needs to be initialized.
$articleDao =& DAORegistry::getDAO('ArticleDAO');
$article = $articleDao->getArticle($articleId);
$article->initializePermissions();
$articleDao->updateLocaleFields($article);
$articleSearchIndex->articleChangesFinished();
$request->redirect(null, null, 'submissionEditing', array($articleId), null, 'scheduling');
}
