application/LinkDB.php

   1 <?php
   2 /**
   3  * Data storage for links.
   4  *
   5  * This object behaves like an associative array.
   6  *
   7  * Example:
   8  *    $myLinks = new LinkDB();
   9  *    echo $myLinks[350]['title'];
  10  *    foreach ($myLinks as $link)
  11  *       echo $link['title'].' at url '.$link['url'].'; description:'.$link['description'];
  12  *
  13  * Available keys:
  14  *  - id:       primary key, incremental integer identifier (persistent)
  15  *  - description: description of the entry
  16  *  - created:  creation date of this entry, DateTime object.
  17  *  - updated:  last modification date of this entry, DateTime object.
  18  *  - private:  Is this link private? 0=no, other value=yes
  19  *  - tags:     tags attached to this entry (separated by spaces)
  20  *  - title     Title of the link
  21  *  - url       URL of the link. Used for displayable links (no redirector, relative, etc.).
  22  *              Can be absolute or relative.
  23  *              Relative URLs are permalinks (e.g.'?m-ukcw')
  24  *  - real_url  Absolute processed URL.
  25  *  - shorturl  Permalink smallhash
  26  *
  27  * Implements 3 interfaces:
  28  *  - ArrayAccess: behaves like an associative array;
  29  *  - Countable:   there is a count() method;
  30  *  - Iterator:    usable in foreach () loops.
  31  *
  32  * ID mechanism:
  33  *   ArrayAccess is implemented in a way that will allow to access a link
  34  *   with the unique identifier ID directly with $link[ID].
  35  *   Note that it's not the real key of the link array attribute.
  36  *   This mechanism is in place to have persistent link IDs,
  37  *   even though the internal array is reordered by date.
  38  *   Example:
  39  *     - DB: link #1 (2010-01-01) link #2 (2016-01-01)
  40  *     - Order: #2 #1
  41  *     - Import links containing: link #3 (2013-01-01)
  42  *     - New DB: link #1 (2010-01-01) link #2 (2016-01-01) link #3 (2013-01-01)
  43  *     - Real order: #2 #3 #1
  44  */
  45 class LinkDB implements Iterator, Countable, ArrayAccess
  46 {
  47     // Links are stored as a PHP serialized string
  48     private $datastore;
  49
  50     // Link date storage format
  51     const LINK_DATE_FORMAT = 'Ymd_His';
  52
  53     // List of links (associative array)
  54     //  - key:   link date (e.g. "20110823_124546"),
  55     //  - value: associative array (keys: title, description...)
  56     private $links;
  57
  58     // List of all recorded URLs (key=url, value=link offset)
  59     // for fast reserve search (url-->link offset)
  60     private $urls;
  61
  62     /**
  63      * @var array List of all links IDS mapped with their array offset.
  64      *            Map: id->offset.
  65      */
  66     protected $ids;
  67
  68     // List of offset keys (for the Iterator interface implementation)
  69     private $keys;
  70
  71     // Position in the $this->keys array (for the Iterator interface)
  72     private $position;
  73
  74     // Is the user logged in? (used to filter private links)
  75     private $loggedIn;
  76
  77     // Hide public links
  78     private $hidePublicLinks;
  79
  80     // link redirector set in user settings.
  81     private $redirector;
  82
  83     /**
  84      * Set this to `true` to urlencode link behind redirector link, `false` to leave it untouched.
  85      *
  86      * Example:
  87      *   anonym.to needs clean URL while dereferer.org needs urlencoded URL.
  88      *
  89      * @var boolean $redirectorEncode parameter: true or false
  90      */
  91     private $redirectorEncode;
  92
  93     /**
  94      * Creates a new LinkDB
  95      *
  96      * Checks if the datastore exists; else, attempts to create a dummy one.
  97      *
  98      * @param string  $datastore        datastore file path.
  99      * @param boolean $isLoggedIn       is the user logged in?
 100      * @param boolean $hidePublicLinks  if true all links are private.
 101      * @param string  $redirector       link redirector set in user settings.
 102      * @param boolean $redirectorEncode Enable urlencode on redirected urls (default: true).
 103      */
 104     public function __construct(
 105         $datastore,
 106         $isLoggedIn,
 107         $hidePublicLinks,
 108         $redirector = '',
 109         $redirectorEncode = true
 110     )
 111     {
 112         $this->datastore = $datastore;
 113         $this->loggedIn = $isLoggedIn;
 114         $this->hidePublicLinks = $hidePublicLinks;
 115         $this->redirector = $redirector;
 116         $this->redirectorEncode = $redirectorEncode === true;
 117         $this->check();
 118         $this->read();
 119     }
 120
 121     /**
 122      * Countable - Counts elements of an object
 123      */
 124     public function count()
 125     {
 126         return count($this->links);
 127     }
 128
 129     /**
 130      * ArrayAccess - Assigns a value to the specified offset
 131      */
 132     public function offsetSet($offset, $value)
 133     {
 134         // TODO: use exceptions instead of "die"
 135         if (!$this->loggedIn) {
 136             die(t('You are not authorized to add a link.'));
 137         }
 138         if (!isset($value['id']) || empty($value['url'])) {
 139             die(t('Internal Error: A link should always have an id and URL.'));
 140         }
 141         if (($offset !== null && ! is_int($offset)) || ! is_int($value['id'])) {
 142             die(t('You must specify an integer as a key.'));
 143         }
 144         if ($offset !== null && $offset !== $value['id']) {
 145             die(t('Array offset and link ID must be equal.'));
 146         }
 147
 148         // If the link exists, we reuse the real offset, otherwise new entry
 149         $existing = $this->getLinkOffset($offset);
 150         if ($existing !== null) {
 151             $offset = $existing;
 152         } else {
 153             $offset = count($this->links);
 154         }
 155         $this->links[$offset] = $value;
 156         $this->urls[$value['url']] = $offset;
 157         $this->ids[$value['id']] = $offset;
 158     }
 159
 160     /**
 161      * ArrayAccess - Whether or not an offset exists
 162      */
 163     public function offsetExists($offset)
 164     {
 165         return array_key_exists($this->getLinkOffset($offset), $this->links);
 166     }
 167
 168     /**
 169      * ArrayAccess - Unsets an offset
 170      */
 171     public function offsetUnset($offset)
 172     {
 173         if (!$this->loggedIn) {
 174             // TODO: raise an exception
 175             die('You are not authorized to delete a link.');
 176         }
 177         $realOffset = $this->getLinkOffset($offset);
 178         $url = $this->links[$realOffset]['url'];
 179         unset($this->urls[$url]);
 180         unset($this->ids[$realOffset]);
 181         unset($this->links[$realOffset]);
 182     }
 183
 184     /**
 185      * ArrayAccess - Returns the value at specified offset
 186      */
 187     public function offsetGet($offset)
 188     {
 189         $realOffset = $this->getLinkOffset($offset);
 190         return isset($this->links[$realOffset]) ? $this->links[$realOffset] : null;
 191     }
 192
 193     /**
 194      * Iterator - Returns the current element
 195      */
 196     public function current()
 197     {
 198         return $this[$this->keys[$this->position]];
 199     }
 200
 201     /**
 202      * Iterator - Returns the key of the current element
 203      */
 204     public function key()
 205     {
 206         return $this->keys[$this->position];
 207     }
 208
 209     /**
 210      * Iterator - Moves forward to next element
 211      */
 212     public function next()
 213     {
 214         ++$this->position;
 215     }
 216
 217     /**
 218      * Iterator - Rewinds the Iterator to the first element
 219      *
 220      * Entries are sorted by date (latest first)
 221      */
 222     public function rewind()
 223     {
 224         $this->keys = array_keys($this->ids);
 225         $this->position = 0;
 226     }
 227
 228     /**
 229      * Iterator - Checks if current position is valid
 230      */
 231     public function valid()
 232     {
 233         return isset($this->keys[$this->position]);
 234     }
 235
 236     /**
 237      * Checks if the DB directory and file exist
 238      *
 239      * If no DB file is found, creates a dummy DB.
 240      */
 241     private function check()
 242     {
 243         if (file_exists($this->datastore)) {
 244             return;
 245         }
 246
 247         // Create a dummy database for example
 248         $this->links = array();
 249         $link = array(
 250             'id' => 1,
 251             'title'=> t('The personal, minimalist, super-fast, database free, bookmarking service'),
 252             'url'=>'https://shaarli.readthedocs.io',
 253             'description'=>t('Welcome to Shaarli! This is your first public bookmark. To edit or delete me, you must first login.
 254
 255 To learn how to use Shaarli, consult the link "Documentation" at the bottom of this page.
 256
 257 You use the community supported version of the original Shaarli project, by Sebastien Sauvage.'),
 258             'private'=>0,
 259             'created'=> new DateTime(),
 260             'tags'=>'opensource software'
 261         );
 262         $link['shorturl'] = link_small_hash($link['created'], $link['id']);
 263         $this->links[1] = $link;
 264
 265         $link = array(
 266             'id' => 0,
 267             'title'=> t('My secret stuff... - Pastebin.com'),
 268             'url'=>'http://sebsauvage.net/paste/?8434b27936c09649#bR7XsXhoTiLcqCpQbmOpBi3rq2zzQUC5hBI7ZT1O3x8=',
 269             'description'=> t('Shhhh! I\'m a private link only YOU can see. You can delete me too.'),
 270             'private'=>1,
 271             'created'=> new DateTime('1 minute ago'),
 272             'tags'=>'secretstuff',
 273         );
 274         $link['shorturl'] = link_small_hash($link['created'], $link['id']);
 275         $this->links[0] = $link;
 276
 277         // Write database to disk
 278         $this->write();
 279     }
 280
 281     /**
 282      * Reads database from disk to memory
 283      */
 284     private function read()
 285     {
 286         // Public links are hidden and user not logged in => nothing to show
 287         if ($this->hidePublicLinks && !$this->loggedIn) {
 288             $this->links = array();
 289             return;
 290         }
 291
 292         $this->urls = [];
 293         $this->ids = [];
 294         $this->links = FileUtils::readFlatDB($this->datastore, []);
 295
 296         $toremove = array();
 297         foreach ($this->links as $key => &$link) {
 298             if (! $this->loggedIn && $link['private'] != 0) {
 299                 // Transition for not upgraded databases.
 300                 unset($this->links[$key]);
 301                 continue;
 302             }
 303
 304             // Sanitize data fields.
 305             sanitizeLink($link);
 306
 307             // Remove private tags if the user is not logged in.
 308             if (! $this->loggedIn) {
 309                 $link['tags'] = preg_replace('/(^|\s+)\.[^($|\s)]+\s*/', ' ', $link['tags']);
 310             }
 311
 312             // Do not use the redirector for internal links (Shaarli note URL starting with a '?').
 313             if (!empty($this->redirector) && !startsWith($link['url'], '?')) {
 314                 $link['real_url'] = $this->redirector;
 315                 if ($this->redirectorEncode) {
 316                     $link['real_url'] .= urlencode(unescape($link['url']));
 317                 } else {
 318                     $link['real_url'] .= $link['url'];
 319                 }
 320             }
 321             else {
 322                 $link['real_url'] = $link['url'];
 323             }
 324
 325             // To be able to load links before running the update, and prepare the update
 326             if (! isset($link['created'])) {
 327                 $link['id'] = $link['linkdate'];
 328                 $link['created'] = DateTime::createFromFormat(self::LINK_DATE_FORMAT, $link['linkdate']);
 329                 if (! empty($link['updated'])) {
 330                     $link['updated'] = DateTime::createFromFormat(self::LINK_DATE_FORMAT, $link['updated']);
 331                 }
 332                 $link['shorturl'] = smallHash($link['linkdate']);
 333             }
 334
 335             $this->urls[$link['url']] = $key;
 336             $this->ids[$link['id']] = $key;
 337         }
 338     }
 339
 340     /**
 341      * Saves the database from memory to disk
 342      *
 343      * @throws IOException the datastore is not writable
 344      */
 345     private function write()
 346     {
 347         $this->reorder();
 348         FileUtils::writeFlatDB($this->datastore, $this->links);
 349     }
 350
 351     /**
 352      * Saves the database from memory to disk
 353      *
 354      * @param string $pageCacheDir page cache directory
 355      */
 356     public function save($pageCacheDir)
 357     {
 358         if (!$this->loggedIn) {
 359             // TODO: raise an Exception instead
 360             die('You are not authorized to change the database.');
 361         }
 362
 363         $this->write();
 364
 365         invalidateCaches($pageCacheDir);
 366     }
 367
 368     /**
 369      * Returns the link for a given URL, or False if it does not exist.
 370      *
 371      * @param string $url URL to search for
 372      *
 373      * @return mixed the existing link if it exists, else 'false'
 374      */
 375     public function getLinkFromUrl($url)
 376     {
 377         if (isset($this->urls[$url])) {
 378             return $this->links[$this->urls[$url]];
 379         }
 380         return false;
 381     }
 382
 383     /**
 384      * Returns the shaare corresponding to a smallHash.
 385      *
 386      * @param string $request QUERY_STRING server parameter.
 387      *
 388      * @return array $filtered array containing permalink data.
 389      *
 390      * @throws LinkNotFoundException if the smallhash is malformed or doesn't match any link.
 391      */
 392     public function filterHash($request)
 393     {
 394         $request = substr($request, 0, 6);
 395         $linkFilter = new LinkFilter($this->links);
 396         return $linkFilter->filter(LinkFilter::$FILTER_HASH, $request);
 397     }
 398
 399     /**
 400      * Returns the list of articles for a given day.
 401      *
 402      * @param string $request day to filter. Format: YYYYMMDD.
 403      *
 404      * @return array list of shaare found.
 405      */
 406     public function filterDay($request) {
 407         $linkFilter = new LinkFilter($this->links);
 408         return $linkFilter->filter(LinkFilter::$FILTER_DAY, $request);
 409     }
 410
 411     /**
 412      * Filter links according to search parameters.
 413      *
 414      * @param array  $filterRequest Search request content. Supported keys:
 415      *                                - searchtags: list of tags
 416      *                                - searchterm: term search
 417      * @param bool   $casesensitive Optional: Perform case sensitive filter
 418      * @param string $visibility    return only all/private/public links
 419      * @param string $untaggedonly  return only untagged links
 420      *
 421      * @return array filtered links, all links if no suitable filter was provided.
 422      */
 423     public function filterSearch($filterRequest = array(), $casesensitive = false, $visibility = 'all', $untaggedonly = false)
 424     {
 425         // Filter link database according to parameters.
 426         $searchtags = isset($filterRequest['searchtags']) ? escape($filterRequest['searchtags']) : '';
 427         $searchterm = isset($filterRequest['searchterm']) ? escape($filterRequest['searchterm']) : '';
 428
 429         // Search tags + fullsearch - blank string parameter will return all links.
 430         $type = LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT; // == "vuotext"
 431         $request = [$searchtags, $searchterm];
 432
 433         $linkFilter = new LinkFilter($this);
 434         return $linkFilter->filter($type, $request, $casesensitive, $visibility, $untaggedonly);
 435     }
 436
 437     /**
 438      * Returns the list tags appearing in the links with the given tags
 439      *
 440      * @param array $filteringTags tags selecting the links to consider
 441      * @param string $visibility   process only all/private/public links
 442      *
 443      * @return array tag => linksCount
 444      */
 445     public function linksCountPerTag($filteringTags = [], $visibility = 'all')
 446     {
 447         $links = $this->filterSearch(['searchtags' => $filteringTags], false, $visibility);
 448         $tags = [];
 449         $caseMapping = [];
 450         foreach ($links as $link) {
 451             foreach (preg_split('/\s+/', $link['tags'], 0, PREG_SPLIT_NO_EMPTY) as $tag) {
 452                 if (empty($tag)) {
 453                     continue;
 454                 }
 455                 // The first case found will be displayed.
 456                 if (!isset($caseMapping[strtolower($tag)])) {
 457                     $caseMapping[strtolower($tag)] = $tag;
 458                     $tags[$caseMapping[strtolower($tag)]] = 0;
 459                 }
 460                 $tags[$caseMapping[strtolower($tag)]]++;
 461             }
 462         }
 463
 464         /*
 465          * Formerly used arsort(), which doesn't define the sort behaviour for equal values.
 466          * Also, this function doesn't produce the same result between PHP 5.6 and 7.
 467          *
 468          * So we now use array_multisort() to sort tags by DESC occurrences,
 469          * then ASC alphabetically for equal values.
 470          *
 471          * @see https://github.com/shaarli/Shaarli/issues/1142
 472          */
 473         $keys = array_keys($tags);
 474         $tmpTags = array_combine($keys, $keys);
 475         array_multisort($tags, SORT_DESC, $tmpTags, SORT_ASC, $tags);
 476         return $tags;
 477     }
 478
 479     /**
 480      * Rename or delete a tag across all links.
 481      *
 482      * @param string $from Tag to rename
 483      * @param string $to   New tag. If none is provided, the from tag will be deleted
 484      *
 485      * @return array|bool List of altered links or false on error
 486      */
 487     public function renameTag($from, $to)
 488     {
 489         if (empty($from)) {
 490             return false;
 491         }
 492         $delete = empty($to);
 493         // True for case-sensitive tag search.
 494         $linksToAlter = $this->filterSearch(['searchtags' => $from], true);
 495         foreach($linksToAlter as $key => &$value)
 496         {
 497             $tags = preg_split('/\s+/', trim($value['tags']));
 498             if (($pos = array_search($from, $tags)) !== false) {
 499                 if ($delete) {
 500                     unset($tags[$pos]); // Remove tag.
 501                 } else {
 502                     $tags[$pos] = trim($to);
 503                 }
 504                 $value['tags'] = trim(implode(' ', array_unique($tags)));
 505                 $this[$value['id']] = $value;
 506             }
 507         }
 508
 509         return $linksToAlter;
 510     }
 511
 512     /**
 513      * Returns the list of days containing articles (oldest first)
 514      * Output: An array containing days (in format YYYYMMDD).
 515      */
 516     public function days()
 517     {
 518         $linkDays = array();
 519         foreach ($this->links as $link) {
 520             $linkDays[$link['created']->format('Ymd')] = 0;
 521         }
 522         $linkDays = array_keys($linkDays);
 523         sort($linkDays);
 524
 525         return $linkDays;
 526     }
 527
 528     /**
 529      * Reorder links by creation date (newest first).
 530      *
 531      * Also update the urls and ids mapping arrays.
 532      *
 533      * @param string $order ASC|DESC
 534      */
 535     public function reorder($order = 'DESC')
 536     {
 537         $order = $order === 'ASC' ? -1 : 1;
 538         // Reorder array by dates.
 539         usort($this->links, function($a, $b) use ($order) {
 540             if (isset($a['sticky']) && isset($b['sticky']) && $a['sticky'] !== $b['sticky']) {
 541                 return $a['sticky'] ? -1 : 1;
 542             }
 543             return $a['created'] < $b['created'] ? 1 * $order : -1 * $order;
 544         });
 545
 546         $this->urls = [];
 547         $this->ids = [];
 548         foreach ($this->links as $key => $link) {
 549             $this->urls[$link['url']] = $key;
 550             $this->ids[$link['id']] = $key;
 551         }
 552     }
 553
 554     /**
 555      * Return the next key for link creation.
 556      * E.g. If the last ID is 597, the next will be 598.
 557      *
 558      * @return int next ID.
 559      */
 560     public function getNextId()
 561     {
 562         if (!empty($this->ids)) {
 563             return max(array_keys($this->ids)) + 1;
 564         }
 565         return 0;
 566     }
 567
 568     /**
 569      * Returns a link offset in links array from its unique ID.
 570      *
 571      * @param int $id Persistent ID of a link.
 572      *
 573      * @return int Real offset in local array, or null if doesn't exist.
 574      */
 575     protected function getLinkOffset($id)
 576     {
 577         if (isset($this->ids[$id])) {
 578             return $this->ids[$id];
 579         }
 580         return null;
 581     }
 582 }