class.NodeUtil.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.NodeUtil.php 1462 2014-02-04 23:52:27Z iherwig $
 */
require_once(BASE."wcmf/lib/core/class.WCMFException.php");
require_once(BASE."wcmf/lib/util/class.Log.php");
require_once(BASE."wcmf/lib/util/class.StringUtil.php");
require_once(BASE."wcmf/lib/util/class.FormUtil.php");
require_once(BASE."wcmf/lib/model/class.Node.php");
require_once(BASE."wcmf/lib/model/class.NodeIterator.php");
require_once(BASE."wcmf/lib/model/class.NodeProcessor.php");
require_once(BASE."wcmf/lib/persistence/class.PersistenceFacade.php");

/**
 * Globals .
 */
// create only one instance of ValueRenderer
$gValueRenderer = null;

/**
 * @class NodeUtil
 * @ingroup Model
 * @brief NodeUtil provides services for the Node class. All methods are static.
 *
 * @author ingo herwig <ingo@wemove.com>
 */
class NodeUtil
{
  var $_formUtil = null;

  /**
   * Constructor
   */
  public function NodeUtil()
  {
    $this->_formUtil = new FormUtil();
  }

  /**
   * Get the path to a given Node (from a root node).
   * @param node The Node to find the path for
   * @return An array containing the nodes in the path
   */
  function getPath(&$node)
  {
    $path = array();
    $persistenceFacade = &PersistenceFacade::getInstance();
    $parentOIDs = $node->getProperty('parentoids');
    $parentOID = $parentOIDs[0];
    while ($parentOID != '' && PersistenceFacade::isValidOID($parentOID))
    {
      $nodeInPath = &$persistenceFacade->load($parentOID, BUILDDEPTH_SINGLE);
      if ($nodeInPath)
      {
        array_push($path, $nodeInPath);
        $parentOIDs = $nodeInPath->getProperty('parentoids');
        $parentOID = $parentOIDs[0];
      }
      else {
        $parentOID = '';
      }
    }
    return $path;
  }
  /**
   * Get the node types that connect a type to a ancestor type.
   * @param tplNode The node to start from
   * @param ancestorType The type to connect to
   * @param nodes Internal use only
   * @return An array of connecting nodes or null (if no connection exists)
   */
  function getConnectionToAncestor(&$tplNode, $ancestorType, $nodes=null)
  {
    if ($nodes == null) {
      $nodes = array();
    }
    $parentOIDs = $tplNode->getProperty('parentoids');
    if (sizeof($parentOIDs) > 0)
    {
      $persistenceFacade = &PersistenceFacade::getInstance();
      $parents = array();
      // check parents
      foreach ($parentOIDs as $oid)
      {
        $parent = &$persistenceFacade->create(PersistenceFacade::getOIDParameter($oid, 'type'), 1);
        if ($parent->getType() == $ancestorType)
        {
          $nodes[sizeof($nodes)] = &$parent;
          return $nodes;
        }
        $parents[sizeof($parents)] = &$parent;
      }
      // nothing found -> proceed with grandparents
      foreach ($parents as $parent)
      {
        $parentOIDs = $parent->getProperty('parentoids');
        if (sizeof($parentOIDs) > 0)
        {
          $nodes[sizeof($nodes)] = &$parent;
          NodeUtil::getConnectionToAncestor($parent, $ancestorType, $nodes);
        }
      }
    }
    return $nodes;
  }
  /**
   * Get the node types that connect a type to a descendant type.
   * @note tplNode must be loaded/created with at least BUILDDEPTH = 1
   * @param tplNode The node to start from
   * @param descendantType The type to connect to
   * @param nodes Internal use only
   * @return An array of connecting nodes or null (if no connection exists)
   */
  function getConnectionToDescendant(&$tplNode, $descendantType, $nodes=null)
  {
    if ($nodes == null) {
      $nodes = array();
    }
    $childOIDs = $tplNode->getProperty('childoids');
    if (sizeof($childOIDs) > 0)
    {
      $persistenceFacade = &PersistenceFacade::getInstance();
      $children = array();
      // check children
      foreach ($childOIDs as $oid)
      {
        $child = &$persistenceFacade->create(PersistenceFacade::getOIDParameter($oid, 'type'), 1);
        if ($child->getType() == $descendantType)
        {
          $nodes[sizeof($nodes)] = &$child;
          return $nodes;
        }
        $children[sizeof($children)] = &$child;
      }
      // nothing found -> proceed with grandparents
      foreach ($children as $child)
      {
        $childOIDs = $child->getProperty('childoids');
        if (sizeof($childOIDs) > 0)
        {
          $nodes[sizeof($nodes)] = &$child;
          NodeUtil::getConnectionToDescendant($child, $descendantType, $nodes);
        }
      }
    }
    return $nodes;
  }
  /**
   * Get the query used to select all Nodes of a type.
   * @param nodeType The Node type
   * @return The serialized query string to be used with ObjectQuery::executeString.
   */
  function getNodeQuery($nodeType)
  {
    $query = &PersistenceFacade::createObjectQuery($nodeType);
    return $query->toString();
  }
  /**
   * Get the query used to select a special Node.
   * @param nodeType The Node type
   * @param oid The object id of the node
   * @return The serialized query string to be used with ObjectQuery::executeString.
   */
  function getSelfQuery($nodeType, $oid)
  {
    $persistenceFacade = &PersistenceFacade::getInstance();
    $query = &PersistenceFacade::createObjectQuery($nodeType);
    $tpl = &$query->getObjectTemplate($nodeType);
    $mapper = &$tpl->getMapper();
    $oidParts = PersistenceFacade::decomposeOID($oid);
    $i = 0;
    foreach ($mapper->getPkNames() as $pkName => $pkValueType) {
      $tpl->setValue($pkName, '= '.$oidParts['id'][$i++], $pkValueType);
    }
    return $query->toString();
  }
  /**
   * Get the query used to select all parent Nodes of a given type.
   * @param parentType The parent type
   * @param childNode The Node to select the parents for
   * @return The serialized query string to be used with ObjectQuery::executeString.
   */
  function getParentQuery($parentType, &$childNode)
  {
    $persistenceFacade = &PersistenceFacade::getInstance();
    $query = &PersistenceFacade::createObjectQuery($parentType);
    $tpl = &$query->getObjectTemplate($parentType);
    // prepare the child: use a new one and set the primary key values
    $cTpl = &$query->getObjectTemplate($childNode->getType());
    $mapper = &$childNode->getMapper();
    foreach ($mapper->getPkNames() as $pkName => $pkValueType) {
      $cTpl->setValue($pkName, '= '.$childNode->getValue($pkName, $pkValueType), $pkValueType);
    }
    $tpl->addChild($cTpl);
    return $query->toString();
  }
  /**
   * Get the query used to select all child Nodes of a given type.
   * @param parentNode The Node to select the children for
   * @param childType The child type
   * @return The serialized query string to be used with ObjectQuery::executeString.
   */
  function getChildQuery(&$parentNode, $childType)
  {
    $query = &PersistenceFacade::createObjectQuery($childType);
    $tpl = &$query->getObjectTemplate($childType);
    // prepare the parent: use a new one and set the primary key values
    // always start from base type
    $pTpl = &$query->getObjectTemplate($parentNode->getBaseType());
    $mapper = &$parentNode->getMapper();
    foreach ($mapper->getPkNames() as $pkName => $pkValueType) {
      $pTpl->setValue($pkName, '= '.$parentNode->getValue($pkName, $pkValueType), $pkValueType);
    }
    $pTpl->addChild($tpl);
    return $query->toString();
  }
  /**
   * Get allowed parent types for a Node by comparing the existing parents of realNode with the possible parents of tplNode.
   * @param realNode A reference to the Node that defines the existing parents (property parentoids must be given)
   * @param tplNode A reference to the Node that defines the possible parents (property parentoids must be given)
   * @return An associative array with the parent type as key and a template of the parent as values.
   * @note: The template has the following extra properties (use Node::getProperty()):
   *        - parentOID gives the object id of the parent object if an instance already assigned to that parent type
   *          (per definition only one instance is assignable to a parent type)
   *        - canAssociate (boolean) indicating if an instance may be associated (depends on the navigability from the parent)
   *        - composition (boolean) indicating if the parent child relation is a composition
   */
  function getPossibleParents(&$realNode, &$tplNode)
  {
    $allowedParentTypes = array();
    if ($tplNode != null && $realNode != null)
    {
      $persistenceFacade = PersistenceFacade::getInstance();
      $possibleParentOIDs = $tplNode->getProperty('parentoids');
      for ($i=0; $i<sizeof($possibleParentOIDs); $i++)
      {
        $type = PersistenceFacade::getOIDParameter($possibleParentOIDs[$i], 'type');
        $possibleParent = &$persistenceFacade->create($type, 1);

        // check if the parent itself knows the type as children and if the relation is a composition
        $children = $possibleParent->getChildrenEx(null, $realNode->getType(), null, null);
        if (sizeof($children) > 0)
        {
          $possibleParent->setProperty('canAssociate', true);
          $possibleParent->setProperty('composition', $children[0]->getProperty('composition'));
        }
        else
        {
          $possibleParent->setProperty('canAssociate', false);
          $possibleParent->setProperty('composition', true);
        }

        // get the already assigned parent, if existing
        foreach ($realNode->getProperty('parentoids') as $parentOID)
        {
          if (PersistenceFacade::getOIDParameter($parentOID, 'type') == $type)
          {
            $possibleParent->setProperty('parentOID', $parentOID);
            break;
          }
        }

        $allowedParentTypes[$type] = &$possibleParent;
      }
    }
    return $allowedParentTypes;
  }
  /**
   * Get allowed child types for a Node by comparing the existing children of realNode with the possible children of tplNode.
   * @param realNode A reference to the Node that defines the existing children (property childoids must be given)
   * @param tplNode A reference to the Node that defines the possible children (children must be included already)
   * @param resolveManyToMany True/False wether for all many to many children the real subject types should be returned [default: true]
   * @return An associative array with the child type as key and a template of the child as values.
   * @note: The template has the following extra properties (use Node::getProperty()):
   *        - canCreate (boolean) indicating if an instance may be created (depends on the multiplicity)
   *        - realSubjectType the type of the real subject if the template is acting as proxy (many to many instance)
   */
  function getPossibleChildren(&$realNode, &$tplNode, $resolveManyToMany=true)
  {
    $allowedChildTypes = array();
    if ($tplNode != null && $realNode != null && $tplNode->getNumChildren() > 0)
    {
      $persistenceFacade = PersistenceFacade::getInstance();
      $possibleChildren = $tplNode->getChildren();
      for ($i=0; $i<sizeof($possibleChildren); $i++)
      {
        $possibleChild = &$possibleChildren[$i];

        // get the number of existing children
        $occurs = 0;
        $childOIDs = $realNode->getProperty('childoids');
        foreach($childOIDs as $childOID)
        {
          if (PersistenceFacade::getOIDParameter($childOID, 'type') == $possibleChild->getType()) {
            $occurs++;
          }
        }
        if ($possibleChild->getProperty('maxOccurs') == 'unbounded' || ($occurs < $possibleChild->getProperty('maxOccurs'))) {
           $possibleChild->setProperty('canCreate', true);
        }
        else {
           $possibleChild->setProperty('canCreate', false);
        }
        // check if we have an association object
        // if yes we set the composition property to false (instances are deleted with the parent)
        // and get the display name from the associated type
        $type = $possibleChild->getType();
        $realSubjectType = NodeUtil::getRealSubjectType($possibleChild, $realNode->getType());
        if ($realSubjectType != null)
        {
          $associatedNode = &$persistenceFacade->create($realSubjectType, BUILDTYPE_SINGLE);
          $possibleChild->setProperty('composition', false);
          $possibleChild->setProperty('realSubject', $associatedNode);
        }

        if ($realSubjectType != null && $resolveManyToMany) {
          $type = $realSubjectType;
        }
        else {
          $type = $possibleChild->getType();
        }
        $allowedChildTypes[$type] = &$possibleChild;
      }
    }
    return $allowedChildTypes;
  }
  /**
   * Get the real subject type for a proxy node, that is a many to many instance. A many to many instance
   * serves as proxy between a client and a real subject, where the client is the parent node in this case
   * and the proxy is the child node.
   * @param proxy The (many to many) proxy node
   * @param parentType The parent type
   * @return The type
   */
  function getRealSubjectType(&$proxy, $parentType)
  {
    $manyToMany = $proxy->getProperty('manyToMany');
    if (is_array($manyToMany))
    {
      if (sizeof($manyToMany) == 2)
      {
        // get the type of the real subject from the manyToMany property
        foreach($proxy->getProperty('manyToMany') as $curParentType)
        {
          if ($curParentType != $parentType) {
            return $curParentType;
          }
        }
      }
      else
      {
        // try to call custom implementation in Mapper class
        $mapper = $proxy->getMapper();
        if (method_exists($mapper, 'getRealSubjectType')) {
          return $mapper->getRealSubjectType($proxy, $parentType);
        }
      }
    }
    return null;
  }
  /**
   * Get the display value names of a Node.
   * @param node The Node instance
   * @return An array of value names
   */
  function getDisplayValueNames(&$node)
  {
    $displayValueStr = $node->getProperty('display_value');
    if (!strPos($displayValueStr, '|')) {
      $displayValues = array($displayValueStr);
    }
    else {
      $displayValues = split('\|', $displayValueStr);
    }
    return $displayValues;
  }
  /**
   * Get the display value for a Node defined by the 'display_value' property that may reference values of subnodes.
   * If the 'display_value' is an array ('|' separated strings) the pieces will be put together with ' - '.
   * If search for 'display_value' gives no result the function returns an empty string.
   * Example: 'name|Comment/text' shows the name of the Node together with the text of the first Comment child
   * @note If display_value is ambiguous because a parent has more than one children of a given type than the first child of
   *       that type will be chosen for display.
   * @param node A reference to the Node to display
   * @param useDisplayType True/False wether to use the display types that are associated with the values which the display value contains [default: false]
   * @param language The lanugage if values should be localized. Optional, default is Localization::getDefaultLanguage()
   * @param values An assoziative array holding key value pairs that the display node's values should match [maybe null].
   * @note The display type is configured via the display_type property of a value. It describes how the value should be displayed.
   *       The description is of the form @code type @endcode or @code type[attributes] @endcode
   *       - type: text|image
   *       - attributes: a string of attributes used in the HTML definition (e.g. 'height="50"')
   * @return The display string
   * @see DefaultValueRenderer::renderValue
   */
  function getDisplayValue(&$node, $useDisplayType=false, $language=null, $values=null)
  {
    return join(' - ', array_values(NodeUtil::getDisplayValues($node, $useDisplayType, $language, $values)));
  }
  /**
   * Does the same as DefaultValueRenderer::getDisplayValue() but returns the display value as associative array
   * @param node A reference to the Node to display
   * @param useDisplayType True/False wether to use the display types that are associated with the values which the display value contains [default: false]
   * @param language The lanugage if values should be localized. Optional, default is Localization::getDefaultLanguage()
   * @param values An assoziative array holding key value pairs that the display node's values should match [maybe null].
   * @return The display array
   */
  function getDisplayValues(&$node, $useDisplayType=false, $language=null, $values=null)
  {
    // localize node if requested
    $localization = &Localization::getInstance();
    if ($language != null) {
      $localization->loadTranslation($node, $language);
    }

    $displayArray = array();
    $persistenceFacade = &PersistenceFacade::getInstance();
    $formUtil = new FormUtil($language);
    $pathToShow = $node->getProperty('display_value');
    if (!strPos($pathToShow, '|')) {
      $pathToShowPieces = array($pathToShow);
    }
    else {
      $pathToShowPieces = split('\|', $pathToShow);
    }
    foreach($pathToShowPieces as $pathToShowPiece)
    {
      $tmpDisplay = '';
      $inputType = ''; // needed for the translation of a list value
      if ($pathToShowPiece != '')
      {
        $curNode = $node;
        $pieces = split('/', $pathToShowPiece);
        foreach ($pieces as $curPiece)
        {
          if (in_array($curPiece, $curNode->getValueNames()))
          {
            // we found a matching attribute/element
            $tmpDisplay = $curNode->getValue($curPiece);
            $properties = $curNode->getValueProperties($curPiece);
            $inputType = $properties['input_type'];
            $displayType = $properties['display_type'];
            break;
          }
          else
          {
            // see if a child type matches
            // see if the $value is valid for the child to look for
            if ($values != null)
            {
              if (PersistenceFacade::isKnownType($curPiece))
              {
                $template = &$persistenceFacade->create($curPiece, BUILDDEPTH_SINGLE);
                $possibleValues = $template->getValueNames();
                foreach ($values as $key => $value) {
                  if (!in_array($key, $possibleValues)) {
                    unset($values[$key]);
                  }
                }
                if (sizeOf($values) == 0) {
                  $values = null;
                }
              }
            }

            // the child is loaded -> take it
            $curNodeArray = $curNode->getChildrenEx(null, $curPiece, $values, null);
            if (sizeOf($curNodeArray) > 0) {
              $curNode = $curNodeArray[0];
            }
            // the child is not loaded -> try to load it
            else
            {
              $loaded = false;
              if (PersistenceFacade::isKnownType($curPiece))
              {
                $nodesOfTypePiece = $persistenceFacade->getOIDs($curPiece);
                foreach($curNode->getProperty('childoids') as $childOID)
                {
                  if (in_array($childOID, $nodesOfTypePiece))
                  {
                    $curNode = &$persistenceFacade->load($childOID, BUILDDEPTH_SINGLE);
                    // localize node if requested
                    if ($language != null) {
                      $localization->loadTranslation($curNode, $language);
                    }
                    $matches = true;
                    if ($values != null)
                    {
                      // check values
                      foreach($values as $key => $value)
                      {
                        if ($curNode->getValue($key) != $value)
                        {
                          $matches = false;
                          break;
                        }
                      }
                    }
                    if ($matches)
                    {
                      $loaded = true;
                      break;
                    }
                  }
                }
              }
              if (!$loaded) {
                break;
              }
            }
          }
        }
      }
      $tmpDisplay = $formUtil->translateValue($tmpDisplay, $inputType);
      if (strlen($tmpDisplay) == 0) {
        $tmpDisplay = $node->getOID();
      }
      if ($useDisplayType)
      {
        // apply display type if desired
        if (!is_object($GLOBALS['gValueRenderer']))
        {
          $objectFactory = &ObjectFactory::getInstance();
          $GLOBALS['gValueRenderer'] = &$objectFactory->createInstanceFromConfig('implementation', 'ValueRenderer');
          if ($GLOBALS['gValueRenderer'] == null) {
            WCMFException::throwEx('ValueRenderer not defined in section implementation.', __FILE__, __LINE__);
          }
        }

        // get type and attributes from definition
        preg_match_all("/[\w][^\[\]]+/", $displayType, $matches);
        if (sizeOf($matches[0]) > 0) {
          list($type, $attributes) = $matches[0];
        }
        if (!$type || $type == '') {
          $type = 'text';
        }
        $tmpDisplay = $GLOBALS['gValueRenderer']->renderValue($type, $tmpDisplay, $attributes);
      }

      $displayArray[$pathToShowPiece] = $tmpDisplay;
    }
    return $displayArray;
  }
  /**
   * Get the display name for a Node type.
   * @param type The name of the type
   * @return The display string
   */
  function getDisplayNameFromType($type)
  {
    $persistenceFacade = &PersistenceFacade::getInstance();
    $typeNode = $persistenceFacade->create($type, BUILDDEPTH_SINGLE);
    return $typeNode->getObjectDisplayName();
  }
  /**
   * Get the description for a Node type.
   * @param type The name of the type
   * @return The description
   */
  function getDescriptionFromType($type)
  {
    $persistenceFacade = &PersistenceFacade::getInstance();
    $typeNode = $persistenceFacade->create($type, BUILDDEPTH_SINGLE);
    return $typeNode->getObjectDescription();
  }
  /**
   * Get a HTML input control for a given node value. The control is defined by the
   * 'input_type' property of the value. The property 'is_editable' is used to determine
   * wether the control should be enabled or not.
   * @param node A reference to the Node which contains the value
   * @param name The name of the value to construct the control for
   * @param dataType The type of the value [optional]
   *        (if type is omitted the first value of any type that matches will be used)
   * @param templateNode A Node which contains the value definition
   *        (if not given the definition will be taken from the node parameter) [optional]
   * @param addEmptyValue True/False if this is set true, an additional empty value is added to the input control
   *        (if not given no empty value will be added) [optional]
   * @return The HTML control string (see FormUtil::getInputControl())
   */
  function getInputControl(&$node, $name, $dataType=null, $templateNode=null, $addEmptyValue=false)
  {
    // set the datatype if not given (to the fist one found)
    if ($dataType == null)
    {
      $dataTypes = $node->getValueTypes($name);
      if (sizeof($dataTypes) > 0) {
        $dataType = $dataTypes[0];
      }
    }
    $controlName = NodeUtil::getInputControlName($node, $name, $dataType);
    if ($templateNode != null) {
      $properties = $templateNode->getValueProperties($name, $dataType);
    }
    else {
      $properties = $node->getValueProperties($name, $dataType);
      if (!$properties)
      {
        $persistenceFacade = &PersistenceFacade::getInstance();
        $templateNode = $persistenceFacade->create($node->getType(), BUILDDEPTH_SINGLE);
        $properties = $templateNode->getValueProperties($name, $dataType);
      }
    }
    $value = $node->getValue($name, $dataType);
    // use member formUtil, because some controls may change the state while being rendered one after another
    return $this->_formUtil->getInputControl($controlName, $properties['input_type'], $value, $properties['is_editable'], $addEmptyValue);
  }
  /**
   * Get a HTML input control name for a given node value (see FormUtil::getInputControl()).
   * @param node A reference to the Node which contains the value
   * @param name The name of the value to construct the control for
   * @param dataType The type of the value [optional]
   *        (if type is omitted the first value of any type that matches will be used)
   * @return The HTML control name string in the form value-<datatype>-<name>-<oid>
   */
  function getInputControlName(&$node, $name, $dataType=null)
  {
    $fieldDelimiter = FormUtil::getInputFieldDelimiter();
    return 'value'.$fieldDelimiter.$dataType.$fieldDelimiter.$name.$fieldDelimiter.$node->getOID();
  }
  /**
   * Get the node value definition from a HTML input control name.
   * @param name The name of input control in the format defined by getInputControlName
   * @return An associative array with keys 'oid', 'name', 'dataType' or null if the name is not valid
   * If the dataType is empty, it defaults to DATATYPE_ATTRIBUTE
   */
  function getValueDefFromInputControlName($name)
  {
    if (!(strpos($name, 'value') === 0)) {
      return null;
    }
    $def = array();
    $fieldDelimiter = FormUtil::getInputFieldDelimiter();
    $pieces = split($fieldDelimiter, $name);
    if (!sizeof($pieces) == 4) {
      return null;
    }
    $forget = array_shift($pieces);
    $dataType = array_shift($pieces);
    if (strlen($dataType) > 0) {
      $def['dataType'] = intval($dataType);
    }
    else {
      $def['dataType'] = DATATYPE_ATTRIBUTE;
    }
    $def['name'] = array_shift($pieces);
    $def['oid'] = array_shift($pieces);

    return $def;
  }
  /**
   * Add the missing attributes to a Node. The state remains the same.
   * @param node A reference to the Node to complete
   */
  function completeNode(&$node)
  {
    // remember old state
    $oldState = $node->getState();
    // construct a template node and add the missing attributes to the node to save
    $persistenceFacade = &PersistenceFacade::getInstance();
    $tmpNode = &$persistenceFacade->create($node->getType(), BUILDDEPTH_SINGLE);
    foreach ($tmpNode->getValueNames(DATATYPE_ATTRIBUTE) as $attribute)
      if($node->getValue($attribute, DATATYPE_ATTRIBUTE) == null)
      {
        $node->setValue($attribute, '', DATATYPE_ATTRIBUTE, true);
        $node->setValueProperties($attribute, $tmpNode->getValueProperties($attribute, DATATYPE_ATTRIBUTE), DATATYPE_ATTRIBUTE);
      }
    // reset old state
    $node->setState($oldState, false);
  }
  /**
   * Sort a list of Nodes and set the sort properties on Nodes of a given list. The two attributes (DATATPE_IGNORE)
   * 'hasSortUp', 'hasSortDown' (values (false,true)) will be added to each Node depending on
   * its list position. If applicable the attributes (DATATPE_IGNORE) 'prevoid'
   * and 'nextoid' resp. will be added to denote the neighboured Nodes.
   * The attributes will only be added if a Node has a sortkey value (DATATPE_IGNORE).
   * @param nodeList A reference to the list of Nodes
   */
  function setSortProperties(&$nodeList)
  {
    if(sizeof($nodeList) > 0 && $nodeList[0]->hasValue('sortkey', DATATYPE_IGNORE)) {
      Node::sort($nodeList, 'sortkey');
    }
    for ($i=0; $i<sizeof($nodeList); $i++)
    {
      if ($nodeList[$i]->hasValue('sortkey', DATATYPE_IGNORE))
      {
        $nodeList[$i]->setValue('hasSortUp', true, DATATYPE_IGNORE);
        $nodeList[$i]->setValue('hasSortDown', true, DATATYPE_IGNORE);

        if ($i == 0) {
          $nodeList[$i]->setValue('hasSortUp', false, DATATYPE_IGNORE);
        }
        else {
          $nodeList[$i]->setValue('prevoid', $nodeList[$i-1]->getOID(), DATATYPE_IGNORE);
        }
        if ($i == sizeof($nodeList)-1) {
          $nodeList[$i]->setValue('hasSortDown', false, DATATYPE_IGNORE);
        }
        else {
          $nodeList[$i]->setValue('nextoid', $nodeList[$i+1]->getOID(), DATATYPE_IGNORE);
        }
      }
    }
  }
  /**
   * Make all urls matching a given base url in a Node relative.
   * @param node A reference to the Node the holds the value
   * @param baseUrl The baseUrl to which matching urls will be made relative
   * @param recursive True/False wether to recurse into child Nodes or not (default: true)
   */
  function makeNodeUrlsRelative(&$node, $baseUrl, $recursive=true)
  {
    // use NodeProcessor to iterate over all Node values
    // and call the global convert function on each
    $processor = new NodeProcessor('makeValueUrlsRelative', array($baseUrl), new NodeUtil());
    $processor->run($node, $recursive);
  }
  /**
   * Make the urls matching a given base url in a Node value relative.
   * @param node A reference to the Node the holds the value
   * @param valueName The name of the value
   * @param dataType The dataType of the value
   * @param baseUrl The baseUrl to which matching urls will be made relative
   */
  function makeValueUrlsRelative(&$node, $valueName, $dataType, $baseUrl)
  {
    $value = $node->getValue($valueName, $dataType);

    // find urls in texts
    $urls = StringUtil::getUrls($value);
    // find direct attribute urls
    if (strpos($value, 'http://') === 0 || strpos($value, 'https://') === 0) {
      array_push($urls, $value);
    }
    // process urls
    foreach ($urls as $url)
    {
      // convert absolute urls matching baseUrl
      $urlConv = $url;
      if (strpos($url, $baseUrl) === 0) {
        $urlConv = str_replace($baseUrl, '', $url);
      }
      // replace url
      $value = str_replace($url, $urlConv, $value);
    }
    $node->setValue($valueName, $value, $dataType);
  }
  /**
   * Render all values in a list of Nodes using the DefaultValueRenderer.
   * @note Values will be translated before rendering using FormUtil::translateValue
   * @param nodes A reference to the array of Nodes
   * @param language The language code, if the translated values should be localized.
   *                 Optional, default is Localization::getDefaultLanguage()
   */
  function renderValues(&$nodes, $language=null)
  {
    // render the node values
    $nodeUtil = new NodeUtil();
    $formUtil = new FormUtil($language);
    $processor = new NodeProcessor('renderValue', array($formUtil), $nodeUtil);
    for($i=0; $i<sizeof($nodes); $i++)
    {
      // render values
      $processor->run($nodes[$i], false);
    }
  }
  /**
   * Callback to render a Node value
   * @see NodeProcessor
   * @note This method is used internally only
   */
  function renderValue(&$node, $valueName, $dataType, $formUtil)
  {
    if ($dataType == DATATYPE_ATTRIBUTE)
    {
      $value = $node->getValue($valueName, $dataType);
      // translate list values
      $value = $formUtil->translateValue($value, $node->getValueProperty($valueName, 'input_type', $dataType), true);
      // render the value to html
      $displayType = $node->getValueProperty($valueName, 'display_type', $dataType);
      if (strlen($displayType) == 0) {
        $displayType = 'text';
      }
      $renderer = new DefaultValueRenderer();
      $value = $renderer->renderValue($displayType, $value, $renderAttribs);
      // force set (the rendered value may not be satisfy validation rules)
      $node->setValue($valueName, $value, $dataType, true);
    }
  }
  /**
   * Translate all values in a list of Nodes using the DefaultValueRenderer.
   * @note Translation in this case refers to mapping list values from the key to the value
   * and should not be confused with localization, although values maybe localized using the
   * language parameter.
   * @param nodes A reference to the array of Nodes
   * @param language The language code, if the translated values should be localized.
   *                 Optional, default is Localization::getDefaultLanguage()
   */
  function translateValues(&$nodes, $language=null)
  {
    // translate the node values
    $nodeUtil = new NodeUtil();
    $formUtil = new FormUtil($language);
    $processor = new NodeProcessor('translateValue', array($formUtil), $nodeUtil);
    for($i=0; $i<sizeof($nodes); $i++)
    {
      // render values
      $processor->run($nodes[$i], false);
    }
  }
  /**
   * Callback to translate a Node value
   * @see NodeProcessor
   * @note This method is used internally only
   */
  function translateValue(&$node, $valueName, $dataType, $formUtil)
  {
    if ($dataType == DATATYPE_ATTRIBUTE)
    {
      $value = $node->getValue($valueName, $dataType);

      // translate list values
      $value = $formUtil->translateValue($value, $node->getValueProperty($valueName, 'input_type', $dataType), true, $node->getBaseOid());
      // force set (the rendered value may not be satisfy validation rules)
      $node->setValue($valueName, $value, $dataType, true);
    }
  }
  /**
   * Remove all values from a Node that are not a display value and don't have DATATYPE_IGNORE.
   * @param node The Node instance
   */
  function removeNonDisplayValues(&$node)
  {
    $displayValues = NodeUtil::getDisplayValueNames($node);
    $valueNames = $node->getValueNames();
    foreach($valueNames as $name) {
      if (!in_array($name, $displayValues)) {
        $node->removeValue($name);
      }
    }
  }
}
?>