ChapterGridHandler.inc.php

<?php
 
// import grid base classes
import('lib.pkp.classes.controllers.grid.CategoryGridHandler');
import('lib.pkp.classes.controllers.grid.DataObjectGridCellProvider');
 
// import chapter grid specific classes
import('lib.pkp.controllers.grid.users.author.PKPAuthorGridCellProvider');
import('controllers.grid.users.chapter.ChapterGridCategoryRow');
 
// Link action & modal classes
import('lib.pkp.classes.linkAction.request.AjaxModal');
 
class ChapterGridHandler extends CategoryGridHandler {
   var $_readOnly;
 
   function __construct() {
      parent::__construct();
      $this->addRoleAssignment(
         array(ROLE_ID_AUTHOR, ROLE_ID_SUB_EDITOR, ROLE_ID_MANAGER, ROLE_ID_ASSISTANT),
         array(
            'fetchGrid', 'fetchRow', 'fetchCategory', 'saveSequence',
            'addChapter', 'editChapter', 'editChapterTab', 'updateChapter', 'deleteChapter',
            'addAuthor', 'editAuthor', 'updateAuthor', 'deleteAuthor'
         )
      );
      $this->addRoleAssignment(
         array(ROLE_ID_SUB_EDITOR, ROLE_ID_MANAGER, ROLE_ID_ASSISTANT),
         array('identifiers', 'updateIdentifiers', 'clearPubId',)
      );
      $this->addRoleAssignment(ROLE_ID_REVIEWER, array('fetchGrid', 'fetchRow'));
   }
 
 
   //
   // Getters and Setters
   //
   function getMonograph() {
      return $this->getAuthorizedContextObject(ASSOC_TYPE_MONOGRAPH);
   }
 
   function getPublication() {
      return $this->getAuthorizedContextObject(ASSOC_TYPE_PUBLICATION);
   }
 
   function getReadOnly() {
      return $this->_readOnly;
   }
 
   function setReadOnly($readOnly) {
      $this->_readOnly = $readOnly;
   }
 
 
   //
   // Implement template methods from PKPHandler
   //
   function authorize($request, &$args, $roleAssignments) {
      import('lib.pkp.classes.security.authorization.PublicationAccessPolicy');
      $this->addPolicy(new PublicationAccessPolicy($request, $args, $roleAssignments));
      return parent::authorize($request, $args, $roleAssignments);
   }
 
   function initialize($request, $args = null) {
      parent::initialize($request, $args);
 
      $this->setTitle('submission.chapters');
 
      AppLocale::requireComponents(LOCALE_COMPONENT_APP_DEFAULT, LOCALE_COMPONENT_PKP_DEFAULT, LOCALE_COMPONENT_APP_SUBMISSION, LOCALE_COMPONENT_PKP_SUBMISSION);
 
      if ($this->getPublication()->getData('status') === STATUS_PUBLISHED) {
         $this->setReadOnly(true);
      }
 
      if (!$this->getReadOnly()) {
         // Grid actions
         $router = $request->getRouter();
         $actionArgs = $this->getRequestArgs();
 
         $this->addAction(
            new LinkAction(
               'addChapter',
               new AjaxModal(
                  $router->url($request, null, null, 'addChapter', null, $actionArgs),
                  __('submission.chapter.addChapter'),
                  'modal_add_item'
               ),
               __('submission.chapter.addChapter'),
               'add_item'
            )
         );
      }
 
      // Columns
      // reuse the cell providers for the AuthorGrid
      $cellProvider = new PKPAuthorGridCellProvider($this->getPublication());
      $this->addColumn(
         new GridColumn(
            'name',
            'author.users.contributor.name',
            null,
            null,
            $cellProvider,
            array('width' => 50, 'alignment' => COLUMN_ALIGNMENT_LEFT)
         )
      );
      $this->addColumn(
         new GridColumn(
            'email',
            'author.users.contributor.email',
            null,
            null,
            $cellProvider
         )
      );
      $this->addColumn(
         new GridColumn(
            'role',
            'author.users.contributor.role',
            null,
            null,
            $cellProvider
         )
      );
   }
 
   function initFeatures($request, $args) {
      if ($this->canAdminister($request->getUser())) {
         $this->setReadOnly(false);
         import('lib.pkp.classes.controllers.grid.feature.OrderCategoryGridItemsFeature');
         return array(new OrderCategoryGridItemsFeature(ORDER_CATEGORY_GRID_CATEGORIES_AND_ROWS, true, $this));
      } else {
         $this->setReadOnly(true);
         return array();
      }
   }
 
   function getRequestArgs() {
      return array_merge(
         parent::getRequestArgs(),
         array(
            'submissionId' => $this->getMonograph()->getId(),
            'publicationId' => $this->getPublication()->getId(),
         )
      );
   }
 
   function canAdminister($user) {
      $submission = $this->getMonograph();
      $publication = $this->getPublication();
      $userRoles = $this->getAuthorizedContextObject(ASSOC_TYPE_USER_ROLES);
 
      if ($publication->getData('status') === STATUS_PUBLISHED) {
         return false;
      }
 
      if (in_array(ROLE_ID_SITE_ADMIN, $userRoles)) {
         return true;
      }
 
      // Incomplete submissions can be edited. (Presumably author.)
      if ($submission->getDateSubmitted() == null) return true;
 
      // The user may not be allowed to edit the metadata
      if (Services::get('submission')->canEditPublication($submission->getId(), $user->getId())) {
         return true;
      }
 
      // Default: Read-only.
      return false;
   }
 
   function getCategoryRowIdParameterName() {
      return 'chapterId';
   }
 
 
   function loadData($request, $filter) {
      return DAORegistry::getDAO('ChapterDAO')
         ->getByPublicationId($this->getPublication()->getId())
         ->toAssociativeArray();
   }
 
 
   //
   // Extended methods from GridHandler
   //
   function getDataElementSequence($gridDataElement) {
      return $gridDataElement->getSequence();
   }
 
   function setDataElementSequence($request, $chapterId, $chapter, $newSequence) {
      if (!$this->canAdminister($request->getUser())) return;
 
      $chapterDao = DAORegistry::getDAO('ChapterDAO'); /* @var $chapterDao ChapterDAO */
      $chapter->setSequence($newSequence);
      $chapterDao->updateObject($chapter);
   }
 
 
   //
   // Implement template methods from CategoryGridHandler
   //
   function getCategoryRowInstance() {
      $monograph = $this->getMonograph();
      $row = new ChapterGridCategoryRow($monograph, $this->getPublication(), $this->getReadOnly());
      import('controllers.grid.users.chapter.ChapterGridCategoryRowCellProvider');
      $row->setCellProvider(new ChapterGridCategoryRowCellProvider());
      return $row;
   }
 
   function loadCategoryData($request, &$chapter, $filter = null) {
      $authorFactory = $chapter->getAuthors(); /* @var $authorFactory DAOResultFactory */
      return $authorFactory->toAssociativeArray();
   }
 
   function getDataElementInCategorySequence($categoryId, &$author) {
      return $author->getSequence();
   }
 
   function setDataElementInCategorySequence($chapterId, &$author, $newSequence) {
      if (!$this->canAdminister(Application::get()->getRequest()->getUser())) return;
 
      $monograph = $this->getMonograph();
 
      // Remove the chapter author id.
      $chapterAuthorDao = DAORegistry::getDAO('ChapterAuthorDAO'); /* @var $chapterAuthorDao ChapterAuthorDAO */
      $chapterAuthorDao->deleteChapterAuthorById($author->getId(), $chapterId);
 
      // Add it again with the correct sequence value.
      // FIXME: primary authors not set for chapter authors.
      $chapterAuthorDao->insertChapterAuthor($author->getId(), $chapterId, false, $newSequence);
   }
 
 
   //
   // Public Chapter Grid Actions
   //
   function identifiers($args, $request) {
      $chapter = $this->_getChapterFromRequest($request);
 
      import('controllers.tab.pubIds.form.PublicIdentifiersForm');
      $form = new PublicIdentifiersForm($chapter);
      $form->initData();
      return new JSONMessage(true, $form->fetch($request));
   }
 
   function updateIdentifiers($args, $request) {
      if (!$this->canAdminister($request->getUser())) return new JSONMessage(false);
 
      $chapter = $this->_getChapterFromRequest($request);
 
      import('controllers.tab.pubIds.form.PublicIdentifiersForm');
      $form = new PublicIdentifiersForm($chapter);
      $form->readInputData();
      if ($form->validate()) {
         $form->execute();
         return DAO::getDataChangedEvent();
      } else {
         return new JSONMessage(true, $form->fetch($request));
      }
   }
 
   function clearPubId($args, $request) {
      if (!$request->checkCSRF()) return new JSONMessage(false);
      if (!$this->canAdminister($request->getUser())) return new JSONMessage(false);
 
      $chapter = $this->_getChapterFromRequest($request);
 
      import('controllers.tab.pubIds.form.PublicIdentifiersForm');
      $form = new PublicIdentifiersForm($chapter);
      $form->clearPubId($request->getUserVar('pubIdPlugIn'));
      return new JSONMessage(true);
   }
 
   function addChapter($args, $request) {
      if (!$this->canAdminister($request->getUser())) return new JSONMessage(false);
      // Calling editChapterTab() with an empty row id will add
      // a new chapter.
      return $this->editChapterTab($args, $request);
   }
 
   function editChapter($args, $request) {
      if (!$this->canAdminister($request->getUser())) return new JSONMessage(false);
      $chapter = $this->_getChapterFromRequest($request);
 
      // Check if this is a remote galley
      $templateMgr = TemplateManager::getManager($request);
      $templateMgr->assign(array(
         'submissionId' => $this->getMonograph()->getId(),
         'publicationId' => $this->getPublication()->getId(),
         'chapterId' => $chapter->getId(),
      ));
 
      if (array_intersect(array(ROLE_ID_MANAGER, ROLE_ID_SUB_EDITOR, ROLE_ID_ASSISTANT), $this->getAuthorizedContextObject(ASSOC_TYPE_USER_ROLES))) {
         $publisherIdEnabled = in_array('chapter', (array) $request->getContext()->getData('enablePublisherId'));
         $pubIdPlugins = PluginRegistry::getPlugins('pubIds');
         $pubIdEnabled = false;
         foreach ($pubIdPlugins as $pubIdPlugin) {
            if ($pubIdPlugin->isObjectTypeEnabled('Chapter', $request->getContext()->getId())) {
               $pubIdEnabled = true;
               break;
            }
         }
         $templateMgr->assign('showIdentifierTab', $publisherIdEnabled || $pubIdEnabled);
      }
 
      return new JSONMessage(true, $templateMgr->fetch('controllers/grid/users/chapter/editChapter.tpl'));
   }
 
   function editChapterTab($args, $request) {
      if (!$this->canAdminister($request->getUser())) return new JSONMessage(false);
      $chapter = $this->_getChapterFromRequest($request);
 
      // Form handling
      import('controllers.grid.users.chapter.form.ChapterForm');
      $chapterForm = new ChapterForm($this->getMonograph(), $this->getPublication(), $chapter);
      $chapterForm->initData();
 
      return new JSONMessage(true, $chapterForm->fetch($request));
   }
 
   function updateChapter($args, $request) {
      if (!$this->canAdminister($request->getUser())) return new JSONMessage(false);
      // Identify the chapter to be updated
      $chapter = $this->_getChapterFromRequest($request);
 
      // Form initialization
      import('controllers.grid.users.chapter.form.ChapterForm');
      $chapterForm = new ChapterForm($this->getMonograph(), $this->getPublication(), $chapter);
      $chapterForm->readInputData();
 
      // Form validation
      if ($chapterForm->validate()) {
         $notificationMgr = new NotificationManager();
         $notificationMgr->createTrivialNotification($request->getUser()->getId());
         $chapterForm->execute();
         return DAO::getDataChangedEvent($chapterForm->getChapter()->getId());
      } else {
         // Return an error
         return new JSONMessage(false);
      }
   }
 
   function deleteChapter($args, $request) {
      if (!$this->canAdminister($request->getUser())) return new JSONMessage(false);
      // Identify the chapter to be deleted
      $chapter = $this->_getChapterFromRequest($request);
      $chapterId = $chapter->getId();
 
      // remove Authors assigned to this chapter first
      $chapterAuthorDao = DAORegistry::getDAO('ChapterAuthorDAO'); /* @var $chapterAuthorDao ChapterAuthorDAO */
      $assignedAuthorIds = $chapterAuthorDao->getAuthorIdsByChapterId($chapterId);
 
      foreach ($assignedAuthorIds as $authorId) {
         $chapterAuthorDao->deleteChapterAuthorById($authorId, $chapterId);
      }
 
      $chapterDao = DAORegistry::getDAO('ChapterDAO'); /* @var $chapterDao ChapterDAO */
      $chapterDao->deleteById($chapterId);
      return DAO::getDataChangedEvent();
   }
 
   function _getChapterFromRequest($request) {
      return DAORegistry::getDAO('ChapterDAO')->getChapter(
            (int) $request->getUserVar('chapterId'),
            $this->getPublication()->getId()
         );
   }
}