interface/modules/zend_modules/library/Zend/Ldap/Node/AbstractNode.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Ldap\Node;
  11
  12 use ArrayAccess;
  13 use Countable;
  14 use Zend\Ldap;
  15 use Zend\Ldap\Exception;
  16
  17 /**
  18  * This class provides a base implementation for LDAP nodes
  19  */
  20 abstract class AbstractNode implements ArrayAccess, Countable
  21 {
  22     protected static $systemAttributes = array('createtimestamp', 'creatorsname',
  23                                                'entrycsn', 'entrydn', 'entryuuid', 'hassubordinates', 'modifiersname',
  24                                                'modifytimestamp', 'structuralobjectclass', 'subschemasubentry',
  25                                                'distinguishedname', 'instancetype', 'name', 'objectcategory',
  26                                                'objectguid',
  27                                                'usnchanged', 'usncreated', 'whenchanged', 'whencreated');
  28
  29     /**
  30      * Holds the node's DN.
  31      *
  32      * @var \Zend\Ldap\Dn
  33      */
  34     protected $dn;
  35
  36     /**
  37      * Holds the node's current data.
  38      *
  39      * @var array
  40      */
  41     protected $currentData;
  42
  43     /**
  44      * Constructor.
  45      *
  46      * Constructor is protected to enforce the use of factory methods.
  47      *
  48      * @param  \Zend\Ldap\Dn $dn
  49      * @param  array         $data
  50      * @param  bool       $fromDataSource
  51      */
  52     protected function __construct(Ldap\Dn $dn, array $data, $fromDataSource)
  53     {
  54         $this->dn = $dn;
  55         $this->loadData($data, $fromDataSource);
  56     }
  57
  58     /**
  59      * @param array   $data
  60      * @param  bool $fromDataSource
  61      */
  62     protected function loadData(array $data, $fromDataSource)
  63     {
  64         if (array_key_exists('dn', $data)) {
  65             unset($data['dn']);
  66         }
  67         ksort($data, SORT_STRING);
  68         $this->currentData = $data;
  69     }
  70
  71     /**
  72      * Reload node attributes from LDAP.
  73      *
  74      * This is an online method.
  75      *
  76      * @param  \Zend\Ldap\Ldap $ldap
  77      * @return AbstractNode Provides a fluid interface
  78      */
  79     public function reload(Ldap\Ldap $ldap = null)
  80     {
  81         if ($ldap !== null) {
  82             $data = $ldap->getEntry($this->_getDn(), array('*', '+'), true);
  83             $this->loadData($data, true);
  84         }
  85
  86         return $this;
  87     }
  88
  89     /**
  90      * Gets the DN of the current node as a Zend\Ldap\Dn.
  91      *
  92      * This is an offline method.
  93      *
  94      * @return \Zend\Ldap\Dn
  95      */
  96     protected function _getDn()
  97     {
  98         return $this->dn;
  99     }
 100
 101     /**
 102      * Gets the DN of the current node as a Zend\Ldap\Dn.
 103      * The method returns a clone of the node's DN to prohibit modification.
 104      *
 105      * This is an offline method.
 106      *
 107      * @return \Zend\Ldap\Dn
 108      */
 109     public function getDn()
 110     {
 111         $dn = clone $this->_getDn();
 112         return $dn;
 113     }
 114
 115     /**
 116      * Gets the DN of the current node as a string.
 117      *
 118      * This is an offline method.
 119      *
 120      * @param  string $caseFold
 121      * @return string
 122      */
 123     public function getDnString($caseFold = null)
 124     {
 125         return $this->_getDn()->toString($caseFold);
 126     }
 127
 128     /**
 129      * Gets the DN of the current node as an array.
 130      *
 131      * This is an offline method.
 132      *
 133      * @param  string $caseFold
 134      * @return array
 135      */
 136     public function getDnArray($caseFold = null)
 137     {
 138         return $this->_getDn()->toArray($caseFold);
 139     }
 140
 141     /**
 142      * Gets the RDN of the current node as a string.
 143      *
 144      * This is an offline method.
 145      *
 146      * @param  string $caseFold
 147      * @return string
 148      */
 149     public function getRdnString($caseFold = null)
 150     {
 151         return $this->_getDn()->getRdnString($caseFold);
 152     }
 153
 154     /**
 155      * Gets the RDN of the current node as an array.
 156      *
 157      * This is an offline method.
 158      *
 159      * @param  string $caseFold
 160      * @return array
 161      */
 162     public function getRdnArray($caseFold = null)
 163     {
 164         return $this->_getDn()->getRdn($caseFold);
 165     }
 166
 167     /**
 168      * Gets the objectClass of the node
 169      *
 170      * @return array
 171      */
 172     public function getObjectClass()
 173     {
 174         return $this->getAttribute('objectClass', null);
 175     }
 176
 177     /**
 178      * Gets all attributes of node.
 179      *
 180      * The collection contains all attributes.
 181      *
 182      * This is an offline method.
 183      *
 184      * @param  bool $includeSystemAttributes
 185      * @return array
 186      */
 187     public function getAttributes($includeSystemAttributes = true)
 188     {
 189         $data = array();
 190         foreach ($this->getData($includeSystemAttributes) as $name => $value) {
 191             $data[$name] = $this->getAttribute($name, null);
 192         }
 193         return $data;
 194     }
 195
 196     /**
 197      * Returns the DN of the current node. {@see getDnString()}
 198      *
 199      * @return string
 200      */
 201     public function toString()
 202     {
 203         return $this->getDnString();
 204     }
 205
 206     /**
 207      * Cast to string representation {@see toString()}
 208      *
 209      * @return string
 210      */
 211     public function __toString()
 212     {
 213         return $this->toString();
 214     }
 215
 216     /**
 217      * Returns an array representation of the current node
 218      *
 219      * @param  bool $includeSystemAttributes
 220      * @return array
 221      */
 222     public function toArray($includeSystemAttributes = true)
 223     {
 224         $attributes = $this->getAttributes($includeSystemAttributes);
 225         return array_merge(array('dn' => $this->getDnString()), $attributes);
 226     }
 227
 228     /**
 229      * Returns a JSON representation of the current node
 230      *
 231      * @param  bool $includeSystemAttributes
 232      * @return string
 233      */
 234     public function toJson($includeSystemAttributes = true)
 235     {
 236         return json_encode($this->toArray($includeSystemAttributes));
 237     }
 238
 239     /**
 240      * Gets node attributes.
 241      *
 242      * The array contains all attributes in its internal format (no conversion).
 243      *
 244      * This is an offline method.
 245      *
 246      * @param  bool $includeSystemAttributes
 247      * @return array
 248      */
 249     public function getData($includeSystemAttributes = true)
 250     {
 251         if ($includeSystemAttributes === false) {
 252             $data = array();
 253             foreach ($this->currentData as $key => $value) {
 254                 if (!in_array($key, static::$systemAttributes)) {
 255                     $data[$key] = $value;
 256                 }
 257             }
 258             return $data;
 259         }
 260
 261         return $this->currentData;
 262     }
 263
 264     /**
 265      * Checks whether a given attribute exists.
 266      *
 267      * If $emptyExists is false empty attributes (containing only array()) are
 268      * treated as non-existent returning false.
 269      * If $emptyExists is true empty attributes are treated as existent returning
 270      * true. In this case method returns false only if the attribute name is
 271      * missing in the key-collection.
 272      *
 273      * @param  string  $name
 274      * @param  bool $emptyExists
 275      * @return bool
 276      */
 277     public function existsAttribute($name, $emptyExists = false)
 278     {
 279         $name = strtolower($name);
 280         if (isset($this->currentData[$name])) {
 281             if ($emptyExists) {
 282                 return true;
 283             }
 284
 285             return count($this->currentData[$name]) > 0;
 286         }
 287
 288         return false;
 289     }
 290
 291     /**
 292      * Checks if the given value(s) exist in the attribute
 293      *
 294      * @param  string      $attribName
 295      * @param  mixed|array $value
 296      * @return bool
 297      */
 298     public function attributeHasValue($attribName, $value)
 299     {
 300         return Ldap\Attribute::attributeHasValue($this->currentData, $attribName, $value);
 301     }
 302
 303     /**
 304      * Gets a LDAP attribute.
 305      *
 306      * This is an offline method.
 307      *
 308      * @param  string  $name
 309      * @param  int $index
 310      * @return mixed
 311      * @throws \Zend\Ldap\Exception\LdapException
 312      */
 313     public function getAttribute($name, $index = null)
 314     {
 315         if ($name == 'dn') {
 316             return $this->getDnString();
 317         }
 318
 319         return Ldap\Attribute::getAttribute($this->currentData, $name, $index);
 320     }
 321
 322     /**
 323      * Gets a LDAP date/time attribute.
 324      *
 325      * This is an offline method.
 326      *
 327      * @param  string  $name
 328      * @param  int $index
 329      * @return array|int
 330      * @throws \Zend\Ldap\Exception\LdapException
 331      */
 332     public function getDateTimeAttribute($name, $index = null)
 333     {
 334         return Ldap\Attribute::getDateTimeAttribute($this->currentData, $name, $index);
 335     }
 336
 337     /**
 338      * Sets a LDAP attribute.
 339      *
 340      * This is an offline method.
 341      *
 342      * @param  string $name
 343      * @param  mixed  $value
 344      * @throws \Zend\Ldap\Exception\BadMethodCallException
 345      */
 346     public function __set($name, $value)
 347     {
 348         throw new Exception\BadMethodCallException();
 349     }
 350
 351     /**
 352      * Gets a LDAP attribute.
 353      *
 354      * This is an offline method.
 355      *
 356      * @param  string $name
 357      * @return mixed
 358      * @throws \Zend\Ldap\Exception\LdapException
 359      */
 360     public function __get($name)
 361     {
 362         return $this->getAttribute($name, null);
 363     }
 364
 365     /**
 366      * Deletes a LDAP attribute.
 367      *
 368      * This method deletes the attribute.
 369      *
 370      * This is an offline method.
 371      *
 372      * @param  $name
 373      * @throws \Zend\Ldap\Exception\BadMethodCallException
 374      */
 375     public function __unset($name)
 376     {
 377         throw new Exception\BadMethodCallException();
 378     }
 379
 380     /**
 381      * Checks whether a given attribute exists.
 382      *
 383      * Empty attributes will be treated as non-existent.
 384      *
 385      * @param  string $name
 386      * @return bool
 387      */
 388     public function __isset($name)
 389     {
 390         return $this->existsAttribute($name, false);
 391     }
 392
 393     /**
 394      * Sets a LDAP attribute.
 395      * Implements ArrayAccess.
 396      *
 397      * This is an offline method.
 398      *
 399      * @param  string $name
 400      * @param         $value
 401      * @throws \Zend\Ldap\Exception\BadMethodCallException
 402      * @param  mixed  $value
 403      * @throws \Zend\Ldap\Exception\BadMethodCallException
 404      */
 405     public function offsetSet($name, $value)
 406     {
 407         throw new Exception\BadMethodCallException();
 408     }
 409
 410     /**
 411      * Gets a LDAP attribute.
 412      * Implements ArrayAccess.
 413      *
 414      * This is an offline method.
 415      *
 416      * @param  string $name
 417      * @return mixed
 418      * @throws \Zend\Ldap\Exception\LdapException
 419      */
 420     public function offsetGet($name)
 421     {
 422         return $this->getAttribute($name, null);
 423     }
 424
 425     /**
 426      * Deletes a LDAP attribute.
 427      * Implements ArrayAccess.
 428      *
 429      * This method deletes the attribute.
 430      *
 431      * This is an offline method.
 432      *
 433      * @param  $name
 434      * @throws \Zend\Ldap\Exception\BadMethodCallException
 435      */
 436     public function offsetUnset($name)
 437     {
 438         throw new Exception\BadMethodCallException();
 439     }
 440
 441     /**
 442      * Checks whether a given attribute exists.
 443      * Implements ArrayAccess.
 444      *
 445      * Empty attributes will be treated as non-existent.
 446      *
 447      * @param  string $name
 448      * @return bool
 449      */
 450     public function offsetExists($name)
 451     {
 452         return $this->existsAttribute($name, false);
 453     }
 454
 455     /**
 456      * Returns the number of attributes in node.
 457      * Implements Countable
 458      *
 459      * @return int
 460      */
 461     public function count()
 462     {
 463         return count($this->currentData);
 464     }
 465 }