[Summary view]

   1  <?php
   2  
   3  /**
   4   * Implementation of Common Cartridge library based on
   5   * {@link http://www.imsglobal.org/cc/ IMS Common Cartridge Standard v1.2}
   6   *
   7   * @author Darko Miletic
   8   * @author Daniel Muhlrad (daniel.muhlrad@uvcms.com)
   9   * @version 1.0
  10   * @copyright 2009 {@link http://www.uvcms.com UVCMS e-learning}
  11   * @package cc_library
  12   *
  13   */
  14  
  15  require_once ('gral_lib/cssparser.php');
  16  
  17  /**
  18   * Base XML class
  19   *
  20   */
  21  class XMLGenericDocument {
  22      private $charset;
  23      /**
  24       * Document
  25       * @var DOMDocument
  26       */
  27      public $doc = null;
  28      /**
  29       *
  30       * Xpath
  31       * @var DOMXPath
  32       */
  33      protected $dxpath = null;
  34      protected $filename;
  35      private $filepath;
  36      private $isloaded = false;
  37      private $arrayPrefixNS = array();
  38      private $is_html = false;
  39  
  40      /**
  41       * @param string $value
  42       * @return string
  43       */
  44      public static function safexml($value) {
  45          $result = htmlspecialchars(html_entity_decode($value, ENT_QUOTES, 'UTF-8'),
  46                                     ENT_NOQUOTES,
  47                                     'UTF-8',
  48                                     false);
  49          return $result;
  50      }
  51  
  52      function __construct($ch = 'UTF-8', $validatenow = true) {
  53          $this->charset = $ch;
  54          $this->documentInit();
  55          $this->doc->validateOnParse = $validatenow;
  56      }
  57  
  58      function __destruct() {
  59          $this->dxpath = null;
  60          $this->doc    = null;
  61      }
  62  
  63      private function documentInit($withonCreate = true) {
  64          $hg = false;
  65          if ($this->isloaded) {
  66              $guardstate = $this->doc->validateOnParse;
  67              $hg = true;
  68              unset($this->dxpath);
  69              unset($this->doc);
  70              $this->isloaded = false;
  71            }
  72          $this->doc = new DOMDocument("1.0", $this->charset);
  73          $this->doc->strictErrorChecking = true;
  74          if ($hg) {
  75              $this->doc->validateOnParse = $guardstate;
  76          }
  77          $this->doc->formatOutput = true;
  78          $this->doc->preserveWhiteSpace = true;
  79          if ($withonCreate) {
  80              $this->on_create();
  81          }
  82      }
  83  
  84      public function viewXML() {
  85          return $this->doc->saveXML();
  86      }
  87  
  88      public function registerNS($prefix, $nsuri) {
  89          $this->arrayPrefixNS[$prefix] = $nsuri;
  90      }
  91  
  92      public function load($fname) {
  93          // Sine xml will remain loaded should the repeated load fail we should recreate document to be empty.
  94          $this->documentInit(false);
  95          $this->isloaded = $this->doc->load($fname);
  96          if ($this->isloaded) {
  97              $this->filename = $fname;
  98              $this->processPath();
  99              $this->is_html = false;
 100          }
 101          return $this->on_load();
 102      }
 103  
 104      public function loadUrl($url) {
 105          $this->documentInit();
 106          $this->isloaded = true;
 107          $this->doc->loadXML( file_get_contents($url) );
 108          $this->is_html = false;
 109          return $this->on_load();
 110      }
 111  
 112      public function loadHTML($content) {
 113          $this->documentInit();
 114          $this->doc->validateOnParse = false;
 115          $this->isloaded = true;
 116          $this->doc->loadHTML($content);
 117          $this->is_html = true;
 118          return $this->on_load();
 119      }
 120  
 121      public function loadXML($content) {
 122          $this->documentInit();
 123          $this->doc->validateOnParse = false;
 124          $this->isloaded = true;
 125          $this->doc->load($content);
 126          $this->is_html = true;
 127          return $this->on_load();
 128      }
 129  
 130      public function loadHTMLFile($fname) {
 131          // Sine xml will remain loaded should the repeated load fail
 132          // we should recreate document to be empty.
 133          $this->documentInit();
 134          $this->doc->validateOnParse = false;
 135          $this->isloaded = $this->doc->loadHTMLFile($fname);
 136          if ($this->isloaded) {
 137              $this->filename = $fname;
 138              $this->processPath();
 139              $this->is_html=true;
 140          }
 141          return $this->on_load();
 142      }
 143  
 144      public function loadXMLFile($fname) {
 145          // Sine xml will remain loaded should the repeated load fail
 146          // we should recreate document to be empty.
 147          $this->documentInit();
 148          $this->doc->validateOnParse = false;
 149          $this->isloaded = $this->doc->load($fname);
 150          if ($this->isloaded) {
 151              $this->filename = $fname;
 152              $this->processPath();
 153              $this->is_html = true;
 154          }
 155          return $this->on_load();
 156      }
 157  
 158  
 159      public function loadString($content) {
 160  
 161          $this->doc = new DOMDocument("1.0", $this->charset);
 162          $content = '<virtualtag>'.$content.'</virtualtag>';
 163          $this->doc->loadXML($content);
 164  
 165          return true;
 166      }
 167  
 168      public function save() {
 169          $this->saveTo($this->filename);
 170      }
 171  
 172      public function saveTo($fname) {
 173          $status = false;
 174          if ($this->on_save()) {
 175              if ($this->is_html) {
 176                  $this->doc->saveHTMLFile($fname);
 177              } else {
 178                  $this->doc->save($fname);
 179              }
 180              $this->filename = $fname;
 181              $this->processPath();
 182              $status = true;
 183          }
 184          return $status;
 185      }
 186  
 187      public function validate() {
 188          return $this->doc->validate();
 189      }
 190  
 191      public function attributeValue($path, $attrname, $node = null) {
 192          $this->chkxpath();
 193          $result = null;
 194          $resultlist = null;
 195          if (is_null($node)) {
 196              $resultlist = $this->dxpath->query($path);
 197          } else {
 198              $resultlist = $this->dxpath->query($path, $node);
 199          }
 200          if (is_object($resultlist) && ($resultlist->length > 0) && $resultlist->item(0)->hasAttribute($attrname)) {
 201              $result = $resultlist->item(0)->getAttribute($attrname);
 202          }
 203          return $result;
 204      }
 205  
 206      /**
 207       *
 208       * Get's text value of the node based on xpath query
 209       * @param string $path
 210       * @param DOMNode $node
 211       * @param int $count
 212       * @return string
 213       */
 214      public function nodeValue($path, $node = null, $count = 1) {
 215          $nd = $this->node($path, $node, $count);
 216          return $this->nodeTextValue($nd);
 217      }
 218  
 219      /**
 220       *
 221       * Get's text value of the node
 222       * @param DOMNode $node
 223       * @return string
 224       */
 225      public function nodeTextValue($node) {
 226          $result = '';
 227          if (is_object($node)) {
 228              if ($node->hasChildNodes()) {
 229                  $chnodesList = $node->childNodes;
 230                  $types = array(XML_TEXT_NODE, XML_CDATA_SECTION_NODE);
 231                  foreach ($chnodesList as $chnode) {
 232                      if (in_array($chnode->nodeType, $types)) {
 233                          $result .= $chnode->wholeText;
 234                      }
 235                  }
 236              }
 237          }
 238          return $result;
 239      }
 240  
 241      /**
 242       *
 243       * Enter description here ...
 244       * @param string $path
 245       * @param DOMNode $nd
 246       * @param int $count
 247       * @return DOMNode
 248       */
 249      public function node($path, $nd = null, $count = 1) {
 250          $result = null;
 251          $resultlist = $this->nodeList($path,$nd);
 252          if (is_object($resultlist) && ($resultlist->length > 0)) {
 253              $result = $resultlist->item($count - 1);
 254          }
 255          return $result;
 256      }
 257  
 258      /**
 259       *
 260       * Enter description here ...
 261       * @param string $path
 262       * @param DOMNode $node
 263       * @return DOMNodeList
 264       */
 265      public function nodeList($path, $node = null) {
 266  
 267          $this->chkxpath();
 268  
 269          $resultlist = null;
 270          if (is_null($node)) {
 271              $resultlist = $this->dxpath->query($path);
 272          } else {
 273              $resultlist = $this->dxpath->query($path, $node);
 274          }
 275          return $resultlist;
 276      }
 277  
 278      /**
 279       *
 280       * Create new attribute
 281       * @param string $namespace
 282       * @param string $name
 283       * @param string $value
 284       * @return DOMAttr
 285       */
 286      public function create_attribute_ns($namespace, $name, $value = null) {
 287          $result = $this->doc->createAttributeNS($namespace, $name);
 288          if (!is_null($value)) {
 289              $result->nodeValue = $value;
 290          }
 291          return $result;
 292      }
 293  
 294      /**
 295       *
 296       * Create new attribute
 297       * @param string $name
 298       * @param string $value
 299       * @return DOMAttr
 300       */
 301      public function create_attribute($name, $value = null) {
 302          $result = $this->doc->createAttribute($name);
 303          if (!is_null($value)) {
 304              $result->nodeValue = $value;
 305          }
 306          return $result;
 307      }
 308  
 309      /**
 310       *
 311       * Adds new node
 312       * @param DOMNode $parentnode
 313       * @param string $namespace
 314       * @param string $name
 315       * @param string $value
 316       * @return DOMNode
 317       */
 318      public function append_new_element_ns(DOMNode &$parentnode, $namespace, $name, $value = null) {
 319          $newnode = null;
 320          if (is_null($value)) {
 321              $newnode = $this->doc->createElementNS($namespace, $name);
 322          } else {
 323              $newnode = $this->doc->createElementNS($namespace, $name, $value);
 324          }
 325          return $parentnode->appendChild($newnode);
 326      }
 327  
 328      /**
 329       *
 330       * New node with CDATA content
 331       * @param DOMNode $parentnode
 332       * @param string $namespace
 333       * @param string $name
 334       * @param string $value
 335       */
 336      public function append_new_element_ns_cdata(DOMNode &$parentnode, $namespace, $name, $value = null) {
 337          $newnode = $this->doc->createElementNS($namespace, $name);
 338          if (!is_null($value)) {
 339              $cdata = $this->doc->createCDATASection($value);
 340              $newnode->appendChild($cdata);
 341          }
 342          return $parentnode->appendChild($newnode);
 343      }
 344  
 345      /**
 346       *
 347       * Adds new node
 348       * @param DOMNode $parentnode
 349       * @param string $name
 350       * @param string $value
 351       * @return DOMNode
 352       */
 353      public function append_new_element(DOMNode &$parentnode, $name, $value = null) {
 354          $newnode = null;
 355          if (is_null($value)) {
 356              $newnode = $this->doc->createElement($name);
 357          } else {
 358              $newnode = $this->doc->createElement($name, $value);
 359          }
 360          return $parentnode->appendChild($newnode);
 361      }
 362  
 363      /**
 364       *
 365       * Adds new attribute
 366       * @param DOMNode $node
 367       * @param string $name
 368       * @param string $value
 369       * @return DOMNode
 370       */
 371      public function append_new_attribute(DOMNode &$node, $name, $value = null) {
 372          return $node->appendChild($this->create_attribute($name, $value));
 373      }
 374  
 375      /**
 376       *
 377       * Adds new attribute
 378       * @param DOMNode $node
 379       * @param string $namespace
 380       * @param string $name
 381       * @param string $value
 382       * @return DOMNode
 383       */
 384      public function append_new_attribute_ns(DOMNode &$node, $namespace, $name, $value = null) {
 385          return $node->appendChild($this->create_attribute_ns($namespace, $name, $value));
 386      }
 387  
 388      public function fileName() {
 389          return $this->filename;
 390      }
 391  
 392      public function filePath() {
 393          return $this->filepath;
 394      }
 395  
 396      protected function on_load() {
 397          return $this->isloaded;
 398      }
 399  
 400      protected function on_save() {
 401          return true;
 402      }
 403  
 404      protected function on_create() {
 405          return true;
 406      }
 407  
 408      public function resetXpath() {
 409          $this->dxpath = null;
 410          $this->chkxpath();
 411      }
 412  
 413      private function chkxpath() {
 414          if (!isset($this->dxpath) || is_null($this->dxpath)) {
 415              $this->dxpath = new DOMXPath($this->doc);
 416              foreach ($this->arrayPrefixNS as $nskey => $nsuri) {
 417                  $this->dxpath->registerNamespace($nskey, $nsuri);
 418              }
 419          }
 420      }
 421  
 422      protected function processPath() {
 423          $path_parts     = pathinfo($this->filename);
 424          $this->filepath = array_key_exists('dirname', $path_parts) ? $path_parts['dirname']."/" : '';
 425      }
 426  }