class.AsyncPagingController.php

Go to the documentation of this file.

<?php
/**
 * wCMF - wemove Content Management Framework
 * Copyright (C) 2005-2014 wemove digital solutions GmbH
 *
 * Licensed under the terms of any of the following licenses
 * at your choice:
 *
 * - GNU Lesser General Public License (LGPL)
 *   http://www.gnu.org/licenses/lgpl.html
 * - Eclipse Public License (EPL)
 *   http://www.eclipse.org/org/documents/epl-v10.php
 *
 * See the license.txt file distributed with this work for
 * additional information.
 *
 * $Id: class.AsyncPagingController.php 1462 2014-02-04 23:52:27Z iherwig $
 */
require_once(BASE."wcmf/lib/presentation/class.Controller.php");
require_once(BASE."wcmf/lib/util/class.SessionData.php");
require_once(BASE."wcmf/lib/output/class.ArrayOutputStrategy.php");
require_once(BASE."wcmf/lib/visitor/class.OutputVisitor.php");
require_once(BASE."wcmf/lib/util/class.Obfuscator.php");

/**
 * @class AsyncPagingController
 * @ingroup Controller
 * @brief AsyncPagingController is a controller that allows to navigate lists.
 *
 * <b>Input actions:</b>
 * - unspecified: List nodes
 *
 * <b>Output actions:</b>
 * - @em ok In any case
 *
 * @param[in] type The entity type to list
 * @param[in] filter A query passed to ObjectQuery::executeString()
 * @param[in] limit The page size of the used PagingInfo
 * @param[in] start The start index used to initialize the used PagingInfo
 * @param[in] sort The attribute to order the entities by
 * @param[in] dir The direction to use to order (ASC|DESC)
 * @param[in] poid The parent object id of the entities if any (this is used to set relation information on the result)
 * @param[in] renderValues True/False wether to render the values using NodeUtil::renderValues or not
 *              (optional, default: false)
 * @param[in] completeObjects True/False wether to return all object attributes objects or only the display values
 *              using NodeUtil::removeNonDisplayValues (optional, default: false)
 * @param[out] totalCount The total number of all entities that match the criteria
 * @param[out] objects An array of entities of the specified type
 * Additional properties are 'realSubject', 'realSubjectType' and 'composition' for many-to-many entities
 * and 'clientOID'
 *
 * @author      ingo herwig <ingo@wemove.com>
 */
class AsyncPagingController extends Controller
{
  var $_sortProperties = null;

  /**
   * @see Controller::hasView()
   */
  function hasView()
  {
    return false;
  }
  /**
   * Do processing and assign Node data to View.
   * @return False in every case.
   * @see Controller::executeKernel()
   */
  function executeKernel()
  {
    // unveil the filter value if it is ofuscated
    $filter = $this->_request->getValue('filter');
    $unveiled = Obfuscator::unveil($filter);
    if (strlen($filter) > 0 && strlen($unveiled) > 0) {
      $filter = $unveiled;
    }
    $rightsManager = &RightsManager::getInstance();

    // get objects using the paging parameters
    $pagingInfo = new PagingInfo($this->_request->getValue('limit'));
    $pagingInfo->setIndex($this->_request->getValue('start'));
    $type = $this->_request->getValue('type');

    // add sort term
    $sortArray = null;
    $sortProperties = $this->getSortingProperties();
    $sortType = $sortProperties['type'];
    $sortAttribute = $sortProperties['attribute'];
    $sortDir = $sortProperties['direction'];
    if ($sortAttribute != null) {
      $sortStr = $sortAttribute;
      if ($sortType != null) {
        $sortStr = $sortType.'.'.$sortStr;
      }
      if ($sortDir != null) {
        $sortStr .= ' '.$sortDir;
      }
      $sortArray = array($sortStr);
    }
    // get the object ids
    $objects = $this->getObjects($type, stripslashes($filter), $sortArray, $pagingInfo);

    // collect the nodes
    $nodes = array();
    for($i=0; $i<sizeof($objects); $i++)
    {
      $curObject = &$objects[$i];

      // check if we can read the object
      if ($rightsManager->authorize($curObject->getOID(), '', ACTION_READ)) {
        $nodes[sizeof($nodes)] = &$curObject;
      }
    }

    // translate all nodes to the requested language if requested
    if ($this->isLocalizedRequest())
    {
      $localization = Localization::getInstance();
      for ($i=0; $i<sizeof($nodes); $i++) {
        $localization->loadTranslation($nodes[$i], $this->_request->getValue('language'), true, true);
      }
    }

    // allow subclasses to modify the model
    $this->modifyModel($nodes);

    // assign response values
    $this->_response->setValue('totalCount', $pagingInfo->getTotalCount());
    $this->_response->setValue('objects', $nodes);

    // success
    $this->_response->setAction('ok');
    return false;
  }
  /**
   * Get the object to display. The default implementation uses ObjectQuery::executeString for the
   * object retrieval. Subclasses may override this. If filter is an empty string, all nodes of the given
   * type will be selected.
   * @param type The object type
   * @param filter The filter query passed from the view (a serialized ObjectQuery).
   * @param sortArray An array of attributes to order by (with an optional ASC|DESC appended)
   * @param pagingInfo A reference to the current paging information (Paginginfo instance)
   * @return An array of object instances
   */
  function getObjects($type, $filter, $sortArray, &$pagingInfo)
  {
    if(!PersistenceFacade::isKnownType($type)) {
      return array();
    }
    // check if sortArray is valid (if sortproperties type is null,
    // the sort attribute does not belong to it and will cause an error in ObjectQuery)
    $sortProperties = $this->getSortingProperties();
    if ($sortProperties['type'] == null) {
      $sortArray = null;
    }
    // if no filter is given, we select all nodes of the given type
    if (strlen($filter) == 0) {
      $filter = NodeUtil::getNodeQuery($type);
    }
    $objects = ObjectQuery::executeString($type, $filter, BUILDDEPTH_SINGLE, $sortArray, $pagingInfo);
    return $objects;
  }
  /**
   * @deprecated
   */
  function getOIDs($type, $filter, $sortArray, &$pagingInfo)
  {
    WCMFException::throwEx("This method is deprecated. Implement getObjects instead.", __FILE__, __LINE__);
  }
  /**
   * Get the sorting properties from the 'sort', 'dir' request parameters.
   * The type is guessed from the sort parameter (if it has the form type.attribute
   * or the attribute belongs to the type given in the 'type' request parameter)
   * @return Associative array with keys 'type', 'attribute', 'direction'
   */
  function getSortingProperties()
  {
    if ($this->_sortProperties == null) {
      $type = null;
      $attribute = null;
      $dir = $this->_request->hasValue('dir') ? $this->_request->getValue('dir') : null;

      $sort = $this->_request->getValue('sort');
      if (strlen($sort) > 0) {
        $orderParts = preg_split('/\./', $sort, 2);
        if (sizeof($orderParts) > 1) {
          $type = $orderParts[0];
          $attribute = $orderParts[1];
        }
        else {
          $attribute = $orderParts[0];
          // check if attribute belongs to type
          $persistenceFacade = PersistenceFacade::getInstance();
          $mapper = $persistenceFacade->getMapper($this->_request->getValue('type'));
          if ($mapper->isAttribute($attribute)) {
            $type = $this->_request->getValue('type');
          }
        }
      }
      $this->_sortProperties = array('type' => $type, 'attribute' => $attribute, 'direction' => $dir);
    }
    return $this->_sortProperties;
  }
  /**
   * Modify the model passed to the view.
   * @note subclasses will override this to implement special application requirements.
   * @param nodes A reference to the array of node references passed to the view
   */
  function modifyModel(&$nodes)
  {
    // @todo put this into subclass AsyncPagingController

    // remove all attributes except for display_values
    if ($this->_request->getBooleanValue('completeObjects', false) == false) {
      for($i=0; $i<sizeof($nodes); $i++) {
        NodeUtil::removeNonDisplayValues($nodes[$i]);
      }
    }
    // render values
    if ($this->_request->getBooleanValue('renderValues', false) == true) {
      NodeUtil::renderValues($nodes);
    }
    // set sort properties
    if (strlen($this->_request->getValue('sort')) == 0) {
      NodeUtil::setSortProperties($nodes);
    }
    // if the nodes are loaded as children of a parent, we set additional
    // properties describing the relation
    if (PersistenceFacade::isValidOID($this->_request->getValue('poid')))
    {
      $parentType = PersistenceFacade::getOIDParameter($this->_request->getValue('poid'), 'type');

      $persistenceFacade = &PersistenceFacade::getInstance();
      $parentTemplate = &$persistenceFacade->create($parentType, 1);
      for ($i=0; $i<sizeof($nodes); $i++)
      {
        $curNode = &$nodes[$i];

        // set the relation properties from childTemplate
        $childTemplate = &$parentTemplate->getFirstChild($curNode->getType());
        foreach ($childTemplate->getPropertyNames() as $property)
        {
          if ($property != 'childoids' && $property != 'parentoids') {
            $curNode->setProperty($property, $childTemplate->getProperty($property));
          }
        }

        // as manyToMany objects act as a proxy, we set a property 'realSubject',
        // which holds to the real subject.
        // we assume that the proxy connects exactly two objects, the client and the real subject
        if (in_array('manyToMany', $curNode->getPropertyNames()))
        {
          $realSubjectType = NodeUtil::getRealSubjectType($curNode, $parentType);
          // get the real subject from the parentoids property
          $realSubject = null;
          $clientOID = null;
          foreach($curNode->getProperty('parentoids') as $curParentOID)
          {
            if (PersistenceFacade::getOIDParameter($curParentOID, 'type') == $realSubjectType)
              $realSubject = &$persistenceFacade->load($curParentOID, BUILDDEPTH_SINGLE);
            else
              $clientOID = $curParentOID;
          }
          $curNode->setProperty('realSubject', $realSubject);
          $curNode->setProperty('realSubjectType', $realSubjectType);
          $curNode->setProperty('clientOID', $clientOID);
          $curNode->setProperty('composition', false);
        }
        // for normal nodes we set the clientOID parameter, to know the parent later
        else
        {
          $curNode->setProperty('clientOID', $this->_request->getValue('poid'));
        }
      }
    }

    // if the node's type is a manyToMany relation type, we need check if
    // the requested object order is belonging to the real subject
    if (sizeof($nodes) > 0) {
      $testNode = $nodes[0];
      if (in_array('manyToMany', $testNode->getPropertyNames())) {
        $sortProperties = $this->getSortingProperties();
        if ($sortProperties['type'] != $testNode->getType()) {
          // check if attribute belongs to realsubject
          $realSubject = $testNode->getProperty('realSubject');
          $persistenceFacade = PersistenceFacade::getInstance();
          $mapper = $persistenceFacade->getMapper($realSubject->getType());
          if ($mapper->isAttribute($sortProperties['attribute'])) {
            // attribute belongs to real subject -> sort
            Node::sort($nodes, null, false, false, array($this, 'sortByRealSubject'));
          }
        }
        // render realsubject values after sorting, because otherwise
        // date values may be unsortable
        if ($this->_request->getValue('renderValues'))
        {
          foreach ($nodes as $node) {
            $realSubject = $node->getProperty('realSubject');
            if ($realSubject) {
              $subjectList = array(&$realSubject);
              NodeUtil::renderValues($subjectList);
            }
            else {
              $realSubject = $persistenceFacade->create($node->getProperty('realSubjectType'), BUILDDEPTH_SINGLE);
            }
            $node->setProperty('realSubject', $realSubject);
          }
        }
      }
    }

  }

  function sortByRealSubject($a, $b)
  {
    $sortProperties = $this->getSortingProperties();
    $realSubjectA = $a->getProperty('realSubject');
    $realSubjectB = $b->getProperty('realSubject');
    $valueA = strtoupper($realSubjectA->getUnconvertedValue($sortProperties['attribute'], DATATYPE_ATTRIBUTE));
    $valueB = strtoupper($realSubjectB->getUnconvertedValue($sortProperties['attribute'], DATATYPE_ATTRIBUTE));
    if ($valueA == $valueB) return 0;
    if ($sortProperties['direction'] == 'ASC') {
      return ($valueA > $valueB) ? 1 : -1;
    }
    else {
      return ($valueA < $valueB) ? 1 : -1;
    }
  }
}
?>