rssparser.class.php

Go to the documentation of this file.

<?php
/* Copyright (C) 2011-2012 Laurent Destailleur  <eldy@users.sourceforge.net>
 * Copyright (C) 2024   MDW             <mdeweerd@users.noreply.github.com>
 * Copyright (C) 2024   Frédéric France     <frederic.france@free.fr>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
// @phan-file-suppress PhanPluginPHPDocInWrongComment
 
class RssParser
{
  public $db;
 
  public $error = '';
 
  public $feed_version;
 
  private $_format = '';
  private $_urlRSS;
  private $_language;
  private $_generator;
  private $_copyright;
  private $_lastbuilddate;
  private $_imageurl;
  private $_link;
  private $_title;
  private $_description;
  private $_lastfetchdate; // Last successful fetch
  private $_rssarray = array();
 
  private $current_namespace;
  public $items = array();
  public $current_item = array();
  public $channel = array();
  public $textinput = array();
  public $image = array();
 
  private $initem;
  private $intextinput;
  private $incontent;
  private $inimage;
  private $inchannel;
 
  // For parsing with xmlparser
  public $stack = array(); // parser stack
  private $_CONTENT_CONSTRUCTS = array('content', 'summary', 'info', 'title', 'tagline', 'copyright');
 
 
  public function __construct($db)
  {
    $this->db = $db;
  }
 
  public function getFormat()
  {
    return $this->_format;
  }
 
  public function getUrlRss()
  {
    return $this->_urlRSS;
  }
  public function getLanguage()
  {
    return $this->_language;
  }
  public function getGenerator()
  {
    return $this->_generator;
  }
  public function getCopyright()
  {
    return $this->_copyright;
  }
  public function getLastBuildDate()
  {
    return $this->_lastbuilddate;
  }
  public function getImageUrl()
  {
    return $this->_imageurl;
  }
  public function getLink()
  {
    return $this->_link;
  }
  public function getTitle()
  {
    return $this->_title;
  }
  public function getDescription()
  {
    return $this->_description;
  }
  public function getLastFetchDate()
  {
    return $this->_lastfetchdate;
  }
  public function getItems()
  {
    return $this->_rssarray;
  }
 
  public function parser($urlRSS, $maxNb = 0, $cachedelay = 60, $cachedir = '')
  {
    include_once DOL_DOCUMENT_ROOT.'/core/lib/files.lib.php';
    include_once DOL_DOCUMENT_ROOT.'/core/lib/geturl.lib.php';
 
    $rss = '';
    $str = ''; // This will contain content of feed
 
    // Check parameters
    if (!dol_is_url($urlRSS)) {
      $this->error = "ErrorBadUrl";
      return -1;
    }
 
    $this->_urlRSS = $urlRSS;
    $newpathofdestfile = $cachedir.'/'.dol_hash($this->_urlRSS, 3); // Force md5 hash (does not contain special chars)
    $newmask = '0644';
 
    //dol_syslog("RssParser::parser parse url=".$urlRSS." => cache file=".$newpathofdestfile);
    $nowgmt = dol_now();
 
    // Search into cache
    $foundintocache = 0;
    if ($cachedelay > 0 && $cachedir) {
      $filedate = dol_filemtime($newpathofdestfile);
      if ($filedate >= ($nowgmt - $cachedelay)) {
        //dol_syslog("RssParser::parser cache file ".$newpathofdestfile." is not older than now - cachedelay (".$nowgmt." - ".$cachedelay.") so we use it.");
        $foundintocache = 1;
 
        $this->_lastfetchdate = $filedate;
      } else {
        dol_syslog(get_class($this)."::parser cache file ".$newpathofdestfile." is not found or older than now - cachedelay (".$nowgmt." - ".$cachedelay.") so we can't use it.");
      }
    }
 
    // Load file into $str
    if ($foundintocache) {    // Cache file found and is not too old
      $str = file_get_contents($newpathofdestfile);
    } else {
      try {
        $result = getURLContent($this->_urlRSS, 'GET', '', 1, array(), array('http', 'https'), 0);
 
        if (!empty($result['content'])) {
          $str = $result['content'];
        } elseif (!empty($result['curl_error_msg'])) {
          $this->error = 'Error retrieving URL '.$this->_urlRSS.' - '.$result['curl_error_msg'];
          return -1;
        }
      } catch (Exception $e) {
        $this->error = 'Error retrieving URL '.$this->_urlRSS.' - '.$e->getMessage();
        return -2;
      }
    }
 
    if ($str !== false) {
      // Convert $str into xml
      if (getDolGlobalString('EXTERNALRSS_USE_SIMPLEXML')) {
        //print 'xx'.LIBXML_NOCDATA;
        libxml_use_internal_errors(false);
        if (LIBXML_VERSION < 20900) {
          // Avoid load of external entities (security problem).
          // Required only if LIBXML_VERSION < 20900
          // @phan-suppress-next-line PhanDeprecatedFunctionInternal
          libxml_disable_entity_loader(true);
        }
 
        $rss = simplexml_load_string($str, "SimpleXMLElement", LIBXML_NOCDATA);
      } else {
        if (!function_exists('xml_parser_create')) {
          $this->error = 'Function xml_parser_create are not supported by your PHP';
          return -1;
        }
 
        try {
          // @phan-suppress-next-line PhanTypeMismatchArgumentInternalProbablyReal
          $xmlparser = xml_parser_create(null);
 
          xml_parser_set_option($xmlparser, XML_OPTION_CASE_FOLDING, 0);
          xml_parser_set_option($xmlparser, XML_OPTION_SKIP_WHITE, 1);
          xml_parser_set_option($xmlparser, XML_OPTION_TARGET_ENCODING, "UTF-8");
          //xml_set_external_entity_ref_handler($xmlparser, 'extEntHandler'); // Seems to have no effect even when function extEntHandler exists.
 
          if (!is_resource($xmlparser) && !is_object($xmlparser)) {
            $this->error = "ErrorFailedToCreateParser";
            return -1;
          }
 
          xml_set_object($xmlparser, $this);
          // @phan-suppress-next-line PhanUndeclaredFunctionInCallable
          xml_set_element_handler($xmlparser, 'feed_start_element', 'feed_end_element'); // @phpstan-ignore-line
          // @phan-suppress-next-line PhanUndeclaredFunctionInCallable
          xml_set_character_data_handler($xmlparser, 'feed_cdata'); // @phpstan-ignore-line
 
          $status = xml_parse($xmlparser, $str, false);
 
          xml_parser_free($xmlparser);
 
          $rss = $this;
          //var_dump($status.' '.$rss->_format);exit;
        } catch (Exception $e) {
          $rss = null;
        }
      }
    }
 
    // If $rss loaded
    if ($rss) {
      // Save file into cache
      if (empty($foundintocache) && $cachedir) {
        dol_syslog(get_class($this)."::parser cache file ".$newpathofdestfile." is saved onto disk.");
        if (!dol_is_dir($cachedir)) {
          dol_mkdir($cachedir);
        }
        $fp = fopen($newpathofdestfile, 'w');
        if ($fp) {
          fwrite($fp, $str);
          fclose($fp);
          dolChmod($newpathofdestfile);
 
          $this->_lastfetchdate = $nowgmt;
        } else {
          print 'Error, failed to open file '.$newpathofdestfile.' for write';
        }
      }
 
      unset($str); // Free memory
 
      if (empty($rss->_format)) {    // If format not detected automatically
        $rss->_format = 'rss';
        if (empty($rss->channel)) {
          $rss->_format = 'atom';
        }
      }
 
      $items = array();
 
      // Save description entries
      if ($rss->_format == 'rss') {
        //var_dump($rss);
        if (getDolGlobalString('EXTERNALRSS_USE_SIMPLEXML')) {
          if (!empty($rss->channel->language)) {
            $this->_language = sanitizeVal((string) $rss->channel->language);
          }
          if (!empty($rss->channel->generator)) {
            $this->_generator = sanitizeVal((string) $rss->channel->generator);
          }
          if (!empty($rss->channel->copyright)) {
            $this->_copyright = sanitizeVal((string) $rss->channel->copyright);
          }
          if (!empty($rss->channel->lastbuilddate)) {
            $this->_lastbuilddate = sanitizeVal((string) $rss->channel->lastbuilddate);
          }
          if (!empty($rss->channel->image->url[0])) {
            $this->_imageurl = sanitizeVal((string) $rss->channel->image->url[0]);
          }
          if (!empty($rss->channel->link)) {
            $this->_link = sanitizeVal((string) $rss->channel->link);
          }
          if (!empty($rss->channel->title)) {
            $this->_title = sanitizeVal((string) $rss->channel->title);
          }
          if (!empty($rss->channel->description)) {
            $this->_description = sanitizeVal((string) $rss->channel->description);
          }
        } else {
          //var_dump($rss->channel);
          if (!empty($rss->channel['language'])) {
            $this->_language = sanitizeVal((string) $rss->channel['language']);
          }
          if (!empty($rss->channel['generator'])) {
            $this->_generator = sanitizeVal((string) $rss->channel['generator']);
          }
          if (!empty($rss->channel['copyright'])) {
            $this->_copyright = sanitizeVal((string) $rss->channel['copyright']);
          }
          if (!empty($rss->channel['lastbuilddate'])) {
            $this->_lastbuilddate = sanitizeVal((string) $rss->channel['lastbuilddate']);
          }
          if (!empty($rss->image['url'])) {
            $this->_imageurl = sanitizeVal((string) $rss->image['url']);
          }
          if (!empty($rss->channel['link'])) {
            $this->_link = sanitizeVal((string) $rss->channel['link']);
          }
          if (!empty($rss->channel['title'])) {
            $this->_title = sanitizeVal((string) $rss->channel['title']);
          }
          if (!empty($rss->channel['description'])) {
            $this->_description = sanitizeVal((string) $rss->channel['description']);
          }
        }
 
        if (getDolGlobalString('EXTERNALRSS_USE_SIMPLEXML')) {
          $items = $rss->channel->item; // With simplexml
        } else {
          $items = $rss->items; // With xmlparse
        }
        //var_dump($items);exit;
      } elseif ($rss->_format == 'atom') {
        //var_dump($rss);
        if (getDolGlobalString('EXTERNALRSS_USE_SIMPLEXML')) {
          if (!empty($rss->generator)) {
            $this->_generator = sanitizeVal((string) $rss->generator);
          }
          if (!empty($rss->lastbuilddate)) {
            $this->_lastbuilddate = sanitizeVal((string) $rss->modified);
          }
          if (!empty($rss->link->href)) {
            $this->_link = sanitizeVal((string) $rss->link->href);
          }
          if (!empty($rss->title)) {
            $this->_title = sanitizeVal((string) $rss->title);
          }
          if (!empty($rss->description)) {
            $this->_description = sanitizeVal((string) $rss->description);
          }
        } else {
          //if (!empty($rss->channel['rss_language']))  $this->_language = (string) $rss->channel['rss_language'];
          if (!empty($rss->channel['generator'])) {
            $this->_generator = sanitizeVal((string) $rss->channel['generator']);
          }
          //if (!empty($rss->channel['rss_copyright'])) $this->_copyright = (string) $rss->channel['rss_copyright'];
          if (!empty($rss->channel['modified'])) {
            $this->_lastbuilddate = sanitizeVal((string) $rss->channel['modified']);
          }
          //if (!empty($rss->image['rss_url']))     $this->_imageurl = (string) $rss->image['rss_url'];
          if (!empty($rss->channel['link'])) {
            $this->_link = sanitizeVal((string) $rss->channel['link']);
          }
          if (!empty($rss->channel['title'])) {
            $this->_title = sanitizeVal((string) $rss->channel['title']);
          }
          //if (!empty($rss->channel['rss_description'])) $this->_description = (string) $rss->channel['rss_description'];
 
          if (!empty($rss->channel)) {
            $this->_imageurl = sanitizeVal($this->getAtomImageUrl($rss->channel));
          }
        }
        if (getDolGlobalString('EXTERNALRSS_USE_SIMPLEXML')) {
          $tmprss = xml2php($rss);
          $items = $tmprss['entry'];
        } else {
          // With simplexml
          $items = $rss->items; // With xmlparse
        }
        //var_dump($items);exit;
      }
 
      $i = 0;
 
      // Loop on each record
      if (is_array($items)) {
        foreach ($items as $item) {
          //var_dump($item);exit;
          if ($rss->_format == 'rss') {
            if (getDolGlobalString('EXTERNALRSS_USE_SIMPLEXML')) {
              $itemLink = sanitizeVal((string) $item->link);
              $itemTitle = sanitizeVal((string) $item->title);
              $itemDescription = sanitizeVal((string) $item->description);
              $itemPubDate = sanitizeVal((string) $item->pubDate);
              $itemId = '';
              $itemAuthor = '';
            } else {
              $itemLink = sanitizeVal((string) $item['link']);
              $itemTitle = sanitizeVal((string) $item['title']);
              $itemDescription = sanitizeVal((string) $item['description']);
              $itemPubDate = sanitizeVal((string) $item['pubdate']);
              $itemId = sanitizeVal((string) $item['guid']);
              $itemAuthor = sanitizeVal((string) ($item['author'] ?? ''));
            }
 
            // Loop on each category
            $itemCategory = array();
            if (!empty($item->category) && is_array($item->category)) {
              foreach ($item->category as $cat) {
                $itemCategory[] = (string) $cat;
              }
            }
          } elseif ($rss->_format == 'atom') {
            $itemLink = (isset($item['link']) ? sanitizeVal((string) $item['link']) : '');
            $itemTitle = sanitizeVal((string) $item['title']);
            $itemDescription = sanitizeVal($this->getAtomItemDescription($item));
            $itemPubDate = sanitizeVal((string) $item['created']);
            $itemId = sanitizeVal((string) $item['id']);
            $itemAuthor = sanitizeVal((string) ($item['author'] ? $item['author'] : $item['author_name']));
            $itemCategory = array();
          } else {
            $itemLink = '';
            $itemTitle = '';
            $itemDescription = '';
            $itemPubDate = '';
            $itemId = '';
            $itemAuthor = '';
            $itemCategory = array();
            print 'ErrorBadFeedFormat';
          }
 
          // Add record to result array
          $this->_rssarray[$i] = array(
            'link' => $itemLink,
            'title' => $itemTitle,
            'description' => $itemDescription,
            'pubDate' => $itemPubDate,
            'category' => $itemCategory,
            'id' => $itemId,
            'author' => $itemAuthor
          );
          //var_dump($this->_rssarray);
 
          $i++;
 
          if ($i > $maxNb) {
            break; // We get all records we want
          }
        }
      }
 
      return 1;
    } else {
      $this->error = 'ErrorFailedToLoadRSSFile';
      return -1;
    }
  }
 
 
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function feed_start_element($p, $element, $attrs)
  {
    // phpcs:enable
    $el = $element = strtolower($element);
    $attrs = array_change_key_case($attrs, CASE_LOWER);
 
    // check for a namespace, and split if found
    $ns = false;
    if (strpos($element, ':')) {
      list($ns, $el) = explode(':', $element, 2);
    }
    if ($ns and $ns != 'rdf') {
      $this->current_namespace = $ns;
    }
 
    // if feed type isn't set, then this is first element of feed identify feed from root element
    if (empty($this->_format)) {
      if ($el == 'rdf') {
        $this->_format = 'rss';
        $this->feed_version = '1.0';
      } elseif ($el == 'rss') {
        $this->_format = 'rss';
        $this->feed_version = $attrs['version'];
      } elseif ($el == 'feed') {
        $this->_format = 'atom';
        $this->feed_version = $attrs['version'];
        $this->inchannel = true;
      }
      return;
    }
 
    if ($el == 'channel') {
      $this->inchannel = true;
    } elseif ($el == 'item' || $el == 'entry') {
      $this->initem = true;
      if (isset($attrs['rdf:about'])) {
        $this->current_item['about'] = $attrs['rdf:about'];
      }
    } elseif ($this->_format == 'rss' && $this->current_namespace == '' && $el == 'textinput') {
      // if we're in the default namespace of an RSS feed,
      //  record textinput or image fields
      $this->intextinput = true;
    } elseif ($this->_format == 'rss' && $this->current_namespace == '' && $el == 'image') {
      $this->inimage = true;
    } elseif ($this->_format == 'atom' && in_array($el, $this->_CONTENT_CONSTRUCTS)) {
      // handle atom content constructs
      // avoid clashing w/ RSS mod_content
      if ($el == 'content') {
        $el = 'atom_content';
      }
 
      $this->incontent = $el;
    } elseif ($this->_format == 'atom' && $this->incontent) {
      // if inside an Atom content construct (e.g. content or summary) field treat tags as text
      // if tags are inlined, then flatten
      $attrs_str = implode(' ', array_map('rss_map_attrs', array_keys($attrs), array_values($attrs)));
 
      $this->append_content("<$element $attrs_str>");
 
      array_unshift($this->stack, $el);
    } elseif ($this->_format == 'atom' && $el == 'link') {
      // Atom support many links per containing element.
      // Magpie treats link elements of type rel='alternate'
      // as being equivalent to RSS's simple link element.
      if (isset($attrs['rel']) && $attrs['rel'] == 'alternate') {
        $link_el = 'link';
      } elseif (!isset($attrs['rel'])) {
        $link_el = 'link';
      } else {
        $link_el = 'link_'.$attrs['rel'];
      }
 
      $this->append($link_el, $attrs['href']);
    } else {
      // set stack[0] to current element
      array_unshift($this->stack, $el);
    }
  }
 
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function feed_cdata($p, $text)
  {
    // phpcs:enable
    if ($this->_format == 'atom' and $this->incontent) {
      $this->append_content($text);
    } else {
      $current_el = implode('_', array_reverse($this->stack));
      $this->append($current_el, $text);
    }
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function feed_end_element($p, $el)
  {
    // phpcs:enable
    $el = strtolower($el);
 
    if ($el == 'item' or $el == 'entry') {
      $this->items[] = $this->current_item;
      $this->current_item = array();
      $this->initem = false;
    } elseif ($this->_format == 'rss' and $this->current_namespace == '' and $el == 'textinput') {
      $this->intextinput = false;
    } elseif ($this->_format == 'rss' and $this->current_namespace == '' and $el == 'image') {
      $this->inimage = false;
    } elseif ($this->_format == 'atom' and in_array($el, $this->_CONTENT_CONSTRUCTS)) {
      $this->incontent = false;
    } elseif ($el == 'channel' or $el == 'feed') {
      $this->inchannel = false;
    } elseif ($this->_format == 'atom' and $this->incontent) {
      // balance tags properly
      // note:  i don't think this is actually necessary
      if ($this->stack[0] == $el) {
        $this->append_content("</$el>");
      } else {
        $this->append_content("<$el />");
      }
 
      array_shift($this->stack);
    } else {
      array_shift($this->stack);
    }
 
    $this->current_namespace = false;
  }
 
 
  public function concat(&$str1, $str2 = "")
  {
    if (!isset($str1)) {
      $str1 = "";
    }
    $str1 .= $str2;
    return $str1;
  }
 
  // phpcs:disable PEAR.NamingConventions.ValidFunctionName.ScopeNotCamelCaps
  public function append_content($text)
  {
    // phpcs:enable
    if (!empty($this->initem)) {
      $this->concat($this->current_item[$this->incontent], $text);
    } elseif (!empty($this->inchannel)) {
      $this->concat($this->channel[$this->incontent], $text);
    }
  }
 
  public function append($el, $text)
  {
    if (!$el) {
      return;
    }
    if (!empty($this->current_namespace)) {
      if (!empty($this->initem)) {
        $this->concat($this->current_item[$this->current_namespace][$el], $text);
      } elseif (!empty($this->inchannel)) {
        $this->concat($this->channel[$this->current_namespace][$el], $text);
      } elseif (!empty($this->intextinput)) {
        $this->concat($this->textinput[$this->current_namespace][$el], $text);
      } elseif (!empty($this->inimage)) {
        $this->concat($this->image[$this->current_namespace][$el], $text);
      }
    } else {
      if (!empty($this->initem)) {
        $this->concat($this->current_item[$el], $text);
      } elseif (!empty($this->intextinput)) {
        $this->concat($this->textinput[$el], $text);
      } elseif (!empty($this->inimage)) {
        $this->concat($this->image[$el], $text);
      } elseif (!empty($this->inchannel)) {
        $this->concat($this->channel[$el], $text);
      }
    }
  }
 
  private function getAtomItemDescription(array $item, $maxlength = 500)
  {
    $result = "";
 
    if (isset($item['summary'])) {
      $result = $item['summary'];
    } elseif (isset($item['atom_content'])) {
      $result = $item['atom_content'];
    }
 
    // remove all HTML elements that can possible break the maximum size of a tooltip,
    // like headings, image, video etc. and allow only simple style elements
    $result = strip_tags($result, "<br><p><ul><ol><li>");
 
    $result = str_replace("\n", "", $result);
 
    if (strlen($result) > $maxlength) {
      $result = substr($result, 0, $maxlength);
      $result .= "...";
    }
 
    return $result;
  }
 
  private function getAtomImageUrl(array $feed)
  {
    if (isset($feed['icon'])) {
      return $feed['logo'];
    }
 
    if (isset($feed['icon'])) {
      return $feed['logo'];
    }
 
    if (isset($feed['webfeeds:logo'])) {
      return $feed['webfeeds:logo'];
    }
 
    if (isset($feed['webfeeds:icon'])) {
      return $feed['webfeeds:icon'];
    }
 
    if (isset($feed['webfeeds:wordmark'])) {
      return $feed['webfeeds:wordmark'];
    }
 
    return "";
  }
}
 
/*
 * A method for the xml_set_external_entity_ref_handler()
 *
 * @param XMLParser $parser
 * @param string $ent
 * @param string|false $base
 * @param string $sysID
 * @param string|false $pubID
 * @return bool
function extEntHandler($parser, $ent, $base, $sysID, $pubID)  {
  print 'extEntHandler ran';
  return true;
}
*/
 
function rss_map_attrs($k, $v)
{
  return "$k=\"$v\"";
}
 
function xml2php($xml)
{
  $threads = 0;
  $tab = false;
  $array = array();
  foreach ($xml->children() as $key => $value) {
    $child = xml2php($value);
 
    //To deal with the attributes
    foreach ($value->attributes() as $ak => $av) {
      $child[$ak] = (string) $av;
    }
 
    //Let see if the new child is not in the array
    if ($tab === false && in_array($key, array_keys($array))) {
      //If this element is already in the array we will create an indexed array
      $tmp = $array[$key];
      $array[$key] = null;
      $array[$key][] = $tmp;
      $array[$key][] = $child;
      $tab = true;
    } elseif ($tab === true) {
      //Add an element in an existing array
      $array[$key][] = $child;
    } else {
      //Add a simple element
      $array[$key] = $child;
    }
 
    $threads++;
  }
 
 
  if ($threads == 0) {
    return (string) $xml;
  }
 
  return $array;
}