ListbuilderHandler.inc.php

<?php
 
import('lib.pkp.classes.controllers.grid.GridHandler');
import('lib.pkp.classes.controllers.listbuilder.ListbuilderGridRow');
import('lib.pkp.classes.controllers.listbuilder.ListbuilderGridColumn');
import('lib.pkp.classes.controllers.listbuilder.MultilingualListbuilderGridColumn');
 
/* Listbuilder source types: text-based, pulldown, ... */
define('LISTBUILDER_SOURCE_TYPE_TEXT', 0);
define('LISTBUILDER_SOURCE_TYPE_SELECT', 1);
 
/* Listbuilder save types */
define('LISTBUILDER_SAVE_TYPE_EXTERNAL', 0); // Outside the listbuilder handler
define('LISTBUILDER_SAVE_TYPE_INTERNAL', 1); // Using ListbuilderHandler::save
 
/* String to identify optgroup in the returning options data. If you want to use
 * optgroup in listbuilder select, return the options data in a multidimensional array
 * array[columnIndex][optgroupId][selectItemId] and also with
 * array[columnIndex][LISTBUILDER_OPTGROUP_LABEL][optgroupId] */
define('LISTBUILDER_OPTGROUP_LABEL', 'optGroupLabel');
 
class ListbuilderHandler extends GridHandler {
   var $_sourceType;
 
   var $_saveType = LISTBUILDER_SAVE_TYPE_INTERNAL;
 
   var $_saveFieldName = null;
 
   function initialize($request, $args = null) {
      parent::initialize($request, $args);
 
      if ($this->canAddItems()) {
         import('lib.pkp.classes.linkAction.request.NullAction');
         $this->addAction($this->getAddItemLinkAction(new NullAction()));
      }
   }
 
 
   //
   // Getters and Setters
   //
   function getTemplate() {
      if (is_null($this->_template)) {
         $this->setTemplate('controllers/listbuilder/listbuilder.tpl');
      }
 
      return $this->_template;
   }
 
   function setSourceType($sourceType) {
      $this->_sourceType = $sourceType;
   }
 
   function getSourceType() {
      return $this->_sourceType;
   }
 
   function setSaveType($saveType) {
      $this->_saveType = $saveType;
   }
 
   function getSaveType() {
      return $this->_saveType;
   }
 
   function setSaveFieldName($fieldName) {
      $this->_saveFieldName = $fieldName;
   }
 
   function getSaveFieldName() {
      assert(isset($this->_saveFieldName));
      return $this->_saveFieldName;
   }
 
   function getAddItemLinkAction($actionRequest) {
      return new LinkAction(
         'addItem',
         $actionRequest,
         __('grid.action.addItem'),
         'add_item'
      );
   }
 
   function getNewRowId($request) {
      return $request->getUserVar('newRowId');
   }
 
   function deleteEntry($request, $rowId) {
      fatalError('ABSTRACT METHOD');
   }
 
   function updateEntry($request, $rowId, $newRowId) {
      // This may well be overridden by a subclass to modify
      // an existing entry, e.g. to maintain referential integrity.
      // If not, we can simply delete and insert.
      if (!$this->deleteEntry($request, $rowId)) return false;
      return $this->insertEntry($request, $newRowId);
   }
 
   function insertEntry($request, $newRowId) {
      fatalError('ABSTRACT METHOD');
   }
 
   function getOptions($request) {
      return array();
   }
 
   //
   // Publicly (remotely) available listbuilder functions
   //
   function fetch($args, $request) {
      $templateMgr = TemplateManager::getManager($request);
      $options = $this->getOptions($request);
      $availableOptions = false;
      if (is_array($options) && !empty($options)) {
         $firstColumnOptions = current($options);
         $optionsCount = count($firstColumnOptions);
         if (is_array(current($firstColumnOptions))) { // Options with opt group, count only the selectable options.
            unset($firstColumnOptions[LISTBUILDER_OPTGROUP_LABEL]);
            $optionsCount--;
            $optionsCount = count($firstColumnOptions, COUNT_RECURSIVE) - $optionsCount;
         }
 
         $listElements = $this->getGridDataElements($request);
         if (count($listElements) < $optionsCount) {
            $availableOptions = true;
         }
      }
 
      $templateMgr->assign('availableOptions', $availableOptions);
 
      return $this->fetchGrid($args, $request);
   }
 
   static function unpack($request, $data, $deletionCallback, $insertionCallback, $updateCallback) {
      $data = json_decode($data);
      $status = true;
 
      // Handle deletions
      if (isset($data->deletions) && $data->deletions !== '') {
         foreach (explode(' ', trim($data->deletions)) as $rowId) {
            if (!call_user_func($deletionCallback, $request, $rowId, $data->numberOfRows)) {
               $status = false;
            }
         }
      }
 
      // Handle changes and insertions
      if (isset($data->changes)) foreach ($data->changes as $entry) {
         // Get the row ID, if any, from submitted data
         if (isset($entry->rowId)) {
            $rowId = $entry->rowId;
            unset($entry->rowId);
         } else {
            $rowId = null;
         }
 
         // $entry should now contain only submitted modified or new rows.
         // Go through each and unpack the data in prep for application.
         $changes = array();
         foreach ($entry as $key => $value) {
            // Match the column name and localization data, if any.
            if (!preg_match('/^newRowId\[([a-zA-Z]+)\](\[([a-z][a-z]_[A-Z][A-Z](@([A-Za-z0-9]{5,8}|\d[A-Za-z0-9]{3}))?)\])?$/', $key, $matches)) assert(false);
 
            // Get the column name
            $column = $matches[1];
 
            // If this is a multilingual input, fetch $locale; otherwise null
            $locale = isset($matches[3])?$matches[3]:null;
 
            if ($locale) $changes[$column][$locale] = $value;
            else $changes[$column] = $value;
         }
 
         // $changes should now contain e.g.:
         // array ('localizedColumnName' => array('en_US' => 'englishValue'),
         // 'nonLocalizedColumnName' => 'someNonLocalizedValue');
         if (is_null($rowId)) {
            if (!call_user_func($insertionCallback, $request, $changes)) $status = false;
         } else {
            if (!call_user_func($updateCallback, $request, $rowId, $changes)) $status = false;
         }
      }
      return $status;
   }
 
   function save($args, $request) {
      // The ListbuilderHandler will post a list of changed
      // data in the "data" post var. Need to go through it
      // and reconcile the data against this list, adding/
      // updating/deleting as needed.
      $data = $request->getUserVar('data');
      self::unpack(
         $request, $data,
         array($this, 'deleteEntry'),
         array($this, 'insertEntry'),
         array($this, 'updateEntry')
      );
   }
 
 
   function fetchOptions($args, $request) {
      $options = $this->getOptions($request);
      return new JSONMessage(true, $options);
   }
 
 
   public function canAddItems() {
      return true;
   }
 
   //
   // Overridden methods from GridHandler
   //
   protected function getRowInstance() {
      // Return a citation row
      return new ListbuilderGridRow();
   }
}