361a43c9be507a833d36aa296c7d158b0d5bf6ec
[banana.git] / banana / spool.inc.php
1 <?php
2 /********************************************************************************
3 * include/spool.inc.php : spool subroutines
4 * -----------------------
5 *
6 * This file is part of the banana distribution
7 * Copyright: See COPYING files that comes with this distribution
8 ********************************************************************************/
9
10 require_once dirname(__FILE__) . '/banana.inc.php';
11
12 define('BANANA_SPOOL_VERSION', '0.3');
13
14 /** Class spoolhead
15 * class used in thread overviews
16 */
17 class BananaSpoolHead
18 {
19 /** date (timestamp) */
20 public $date;
21 /** subject */
22 public $subject;
23 /** author */
24 public $from;
25 /** reference of parent */
26 public $parent = null;
27 /** paren is direct */
28 public $parent_direct;
29 /** array of children */
30 public $children = Array();
31 /** true if post is read */
32 public $isread;
33 /** number of posts deeper in this branch of tree */
34 public $desc;
35 /** same as desc, but counts only unread posts */
36 public $descunread;
37
38 /** storage data */
39 public $storage = array();
40
41 /** constructor
42 * @param $_date INTEGER timestamp of post
43 * @param $_subject STRING subject of post
44 * @param $_from STRING author of post
45 * @param $_desc INTEGER desc value (1 for a new post)
46 * @param $_read BOOLEAN true if read
47 * @param $_descunread INTEGER descunread value (0 for a new post)
48 */
49 public function __construct(array &$message)
50 {
51 $this->date = $message['date'];
52 $this->subject = $message['subject'];
53 $this->from = $message['from'];
54 $this->desc = 1;
55 $this->isread = true;
56 $this->descunread = 0;
57 }
58 }
59
60
61 class BananaSpool
62 {
63 private $version;
64 private $mode;
65
66 /** group name */
67 public $group;
68 /** spool */
69 public $overview;
70 /** array msgid => msgnum */
71 public $ids;
72 /** thread starts */
73 public $roots;
74
75
76 /** constructor
77 * @param $_group STRING group name
78 * @param $_display INTEGER 1 => all posts, 2 => only threads with new posts
79 * @param $_since INTEGER time stamp (used for read/unread)
80 */
81 protected function __construct($group)
82 {
83 $this->version = BANANA_SPOOL_VERSION;
84 $this->mode = Banana::SPOOL_ALL;
85 $this->group = $group;
86 }
87
88 public static function getSpool($group, $since = 0, $clean = false)
89 {
90 if (!is_null(Banana::$spool) && Banana::$spool->group == $group) {
91 $spool =& Banana::$spool;
92 } else {
93 $spool = BananaSpool::readFromFile($group);
94 }
95 if (is_null($spool)) {
96 $spool = new BananaSpool($group);
97 }
98 Banana::$spool =& $spool;
99 $spool->build();
100 if ($clean) {
101 $spool->markAllAsRead();
102 }
103 $spool->updateUnread($since);
104 return $spool;
105 }
106
107 private static function spoolFilename($group)
108 {
109 $file = dirname(dirname(__FILE__));
110 $file .= '/spool/' . Banana::$protocole->name() . '/';
111 if (!is_dir($file)) {
112 mkdir($file);
113 }
114 return $file . Banana::$protocole->filename();
115 }
116
117 private static function readFromFile($group)
118 {
119 $file = BananaSpool::spoolFilename($group);
120 if (!file_exists($file)) {
121 return null;
122 }
123 $spool = unserialize(file_get_contents($file));
124 if ($spool->version != BANANA_SPOOL_VERSION || $spool->mode != Banana::SPOOL_ALL) {
125 return null;
126 }
127 return $spool;
128 }
129
130 private function compare($a, $b)
131 {
132 return ($b->date >= $a->date);
133 }
134
135 private function saveToFile()
136 {
137 $file = BananaSpool::spoolFilename($this->group);
138 uasort($this->overview, array($this, 'compare'));
139
140 $this->roots = Array();
141 foreach($this->overview as $id=>$msg) {
142 if (is_null($msg->parent)) {
143 $this->roots[] = $id;
144 }
145 }
146
147 if ($this->mode == Banana::SPOOL_ALL) {
148 file_put_contents($file, serialize($this));
149 }
150 }
151
152 private function build()
153 {
154 $threshold = 0;
155
156 // Compute the range of indexes
157 list($msgnum, $first, $last) = Banana::$protocole->getIndexes();
158 if ($last < $first) {
159 $threshold = $firt + $msgnum - $last;
160 $threshold = (int)(log($threshold)/log(2));
161 $threshold = (2 ^ ($threshold + 1)) - 1;
162 }
163 if (Banana::$spool_max && Banana::$spool_max < $msgnum) {
164 $first = $last - Banana::$spool_max;
165 if ($first < 0) {
166 $first += $threshold;
167 }
168 }
169 $clean = $this->clean($first, $last, $msgnum);
170 $update = $this->update($first, $last, $msgnum);
171
172 if ($clean || $update) {
173 $this->saveToFile();
174 }
175 }
176
177 private function clean(&$first, &$last, $msgnum)
178 {
179 $do_save = false;
180 if (is_array($this->overview)) {
181 $mids = array_keys($this->overview);
182 foreach ($mids as $id) {
183 if (($first <= $last && ($id < $first || $id > $last))
184 || ($first > $last && $id < $first && $id > $last)) {
185 $this->delid($id, false);
186 $do_save = true;
187 }
188 }
189 if (!empty($this->overview)) {
190 $first = max(array_keys($this->overview))+1;
191 }
192 }
193 return $do_save;
194 }
195
196 private function update(&$first, &$last, $msgnum)
197 {
198 if ($first > $last || !$msgnum) {
199 return false;
200 }
201
202 $messages =& Banana::$protocole->getMessageHeaders($first, $last,
203 array('Date', 'Subject', 'From', 'Message-ID', 'References', 'In-Reply-To'));
204
205 if (!is_array($this->ids)) {
206 $this->ids = array();
207 }
208 foreach ($messages as $id=>&$message) {
209 $this->ids[$message['message-id']] = $id;
210 }
211
212 if (!is_array($this->overview)) {
213 $this->overview = array();
214 }
215 foreach ($messages as $id=>&$message) {
216 if (!isset($this->overview[$id])) {
217 $this->overview[$id] = new BananaSpoolHead($message);
218 }
219 $msg =& $this->overview[$id];
220 $msgrefs = BananaMessage::formatReferences($message);
221 $parents = preg_grep('/^\d+$/', $msgrefs);
222 $msg->parent = array_pop($parents);
223 $msg->parent_direct = preg_match('/^\d+$/', array_pop($msgrefs));
224
225 if (!is_null($p = $msg->parent)) {
226 if (empty($this->overview[$p])) {
227 $this->overview[$p] = new BananaSpoolHead($messages[$p]);
228 }
229 $this->overview[$p]->children[] = $id;
230
231 while (!is_null($p)) {
232 $this->overview[$p]->desc += $msg->desc;
233 if ($p != $this->overview[$p]->parent) {
234 $p = $this->overview[$p]->parent;
235 } else {
236 $p = null;
237 }
238 }
239 }
240 }
241 Banana::$protocole->updateSpool($messages);
242 return true;
243 }
244
245 private function updateUnread($since)
246 {
247 if (empty($since)) {
248 return;
249 }
250
251 $newpostsids = Banana::$protocole->getNewIndexes($since);
252
253 if (empty($newpostsids)) {
254 return;
255 }
256
257 if (!is_array($this->ids)) {
258 $this->ids = array();
259 }
260 $newpostsids = array_intersect($newpostsids, array_keys($this->ids));
261 foreach ($newpostsids as $mid) {
262 $id = $this->ids[$mid];
263 if ($this->overview[$id]->isread) {
264 $this->overview[$id]->isread = false;
265 while (isset($id)) {
266 $this->overview[$id]->descunread ++;
267 $id = $this->overview[$id]->parent;
268 }
269 }
270 }
271 }
272
273 public function setMode($mode)
274 {
275 $this->mode = $mode;
276 switch ($mode) {
277 case Banana::SPOOL_UNREAD:
278 foreach ($this->roots as $k=>$i) {
279 if ($this->overview[$i]->descunread == 0) {
280 $this->killdesc($i);
281 unset($this->roots[$k]);
282 }
283 }
284 break;
285 }
286 }
287
288 /** Mark the given id as read
289 * @param id MSGNUM of post
290 */
291 public function markAsRead($id)
292 {
293 if (!$this->overview[$id]->isread) {
294 $this->overview[$id]->isread = true;
295 while (isset($id)) {
296 $this->overview[$id]->descunread--;
297 $id = $this->overview[$id]->parent;
298 }
299 }
300 }
301
302 /** Mark all unread messages as read
303 */
304 public function markAllAsRead(array &$array = null)
305 {
306 if (is_null($array)) {
307 $array =& $this->roots;
308 }
309 if (!is_array($this->roots)) {
310 return;
311 }
312 foreach ($array as $id) {
313 if (!$this->overview[$id]->isread) {
314 $this->markAsRead($id);
315 }
316 if ($this->overview[$id]->descunread) {
317 $this->markAllAsRead($this->overview[$id]->children);
318 }
319 }
320 }
321
322 /** kill post and childrens
323 * @param $_id MSGNUM of post
324 */
325 private function killdesc($_id)
326 {
327 if (sizeof($this->overview[$_id]->children)) {
328 foreach ($this->overview[$_id]->children as $c) {
329 $this->killdesc($c);
330 }
331 }
332 unset($this->overview[$_id]);
333 if (($msgid = array_search($_id, $this->ids)) !== false) {
334 unset($this->ids[$msgid]);
335 }
336 }
337
338 /** delete a post from overview
339 * @param $_id MSGNUM of post
340 */
341 public function delid($_id, $write = true)
342 {
343 if (isset($this->overview[$_id])) {
344 if (sizeof($this->overview[$_id]->parent)) {
345 $this->overview[$this->overview[$_id]->parent]->children =
346 array_diff($this->overview[$this->overview[$_id]->parent]->children, array($_id));
347 if (sizeof($this->overview[$_id]->children)) {
348 $this->overview[$this->overview[$_id]->parent]->children =
349 array_merge($this->overview[$this->overview[$_id]->parent]->children, $this->overview[$_id]->children);
350 foreach ($this->overview[$_id]->children as $c) {
351 $this->overview[$c]->parent = $this->overview[$_id]->parent;
352 $this->overview[$c]->parent_direct = false;
353 }
354 }
355 $p = $this->overview[$_id]->parent;
356 while ($p) {
357 $this->overview[$p]->desc--;
358 $p = $this->overview[$p]->parent;
359 }
360 } elseif (sizeof($this->overview[$_id]->children)) {
361 foreach ($this->overview[$_id]->children as $c) {
362 $this->overview[$c]->parent = null;
363 }
364 }
365 unset($this->overview[$_id]);
366 $msgid = array_search($_id, $this->ids);
367 if ($msgid) {
368 unset($this->ids[$msgid]);
369 }
370
371 if ($write) {
372 $this->markAllAsRead();
373 $this->saveToFile();
374 }
375 }
376 }
377
378 private function formatDate($stamp)
379 {
380 $today = intval(time() / (24*3600));
381 $dday = intval($stamp / (24*3600));
382
383 if ($today == $dday) {
384 $format = "%H:%M";
385 } elseif ($today == 1 + $dday) {
386 $format = _b_('hier')." %H:%M";
387 } elseif ($today < 7 + $dday) {
388 $format = '%a %H:%M';
389 } else {
390 $format = '%a %e %b';
391 }
392 return utf8_encode(strftime($format, $stamp));
393 }
394
395 /** displays children tree of a post
396 * @param $_id INTEGER MSGNUM of post
397 * @param $_index INTEGER linear number of post in the tree
398 * @param $_first INTEGER linear number of first post displayed
399 * @param $_last INTEGER linear number of last post displayed
400 * @param $_ref STRING MSGNUM of current post
401 * @param $_pfx_node STRING prefix used for current node
402 * @param $_pfx_end STRING prefix used for children of current node
403 * @param $_head BOOLEAN true if first post in thread
404 *
405 * If you want to analyse subject, you can define the function hook_formatDisplayHeader
406 */
407 private function _to_html($_id, $_index, $_first=0, $_last=0, $_ref="", $_pfx_node="", $_pfx_end="", $_head=true)
408 {
409 static $spfx_f, $spfx_n, $spfx_Tnd, $spfx_Lnd, $spfx_snd, $spfx_T, $spfx_L, $spfx_s, $spfx_e, $spfx_I;
410 if (!isset($spfx_f)) {
411 $spfx_f = Banana::$page->makeImg(Array('img' => 'k1', 'alt' => 'o', 'height' => 21, 'width' => 9));
412 $spfx_n = Banana::$page->makeImg(Array('img' => 'k2', 'alt' => '*', 'height' => 21, 'width' => 9));
413 $spfx_Tnd = Banana::$page->makeImg(Array('img' => 'T-direct', 'alt' => '+', 'height' => 21, 'width' => 12));
414 $spfx_Lnd = Banana::$page->makeImg(Array('img' => 'L-direct', 'alt' => '`', 'height' => 21, 'width' => 12));
415 $spfx_snd = Banana::$page->makeImg(Array('img' => 's-direct', 'alt' => '-', 'height' => 21, 'width' => 5));
416 $spfx_T = Banana::$page->makeImg(Array('img' => 'T', 'alt' => '+', 'height' => 21, 'width' => 12));
417 $spfx_L = Banana::$page->makeImg(Array('img' => 'L', 'alt' => '`', 'height' => 21, 'width' => 12));
418 $spfx_s = Banana::$page->makeImg(Array('img' => 's', 'alt' => '-', 'height' => 21, 'width' => 5));
419 $spfx_e = Banana::$page->makeImg(Array('img' => 'e', 'alt' => '&nbsp;', 'height' => 21, 'width' => 12));
420 $spfx_I = Banana::$page->makeImg(Array('img' => 'I', 'alt' => '|', 'height' => 21, 'width' => 12));
421 }
422
423 $overview =& $this->overview[$_id];
424 if ($_index + $overview->desc < $_first || $_index > $_last) {
425 return '';
426 }
427
428 $res = '';
429 if ($_index >= $_first) {
430 $hc = empty($overview->children);
431
432 $res .= '<tr class="' . ($_index%2 ? 'pair' : 'impair') . ($overview->isread ? '' : ' new') . "\">\n";
433 $res .= '<td class="date">' . $this->formatDate($overview->date) . " </td>\n";
434 $res .= '<td class="subj' . ($_index == $_ref ? ' cur' : '') . '">'
435 . $_pfx_node .($hc ? ($_head ? $spfx_f : ($overview->parent_direct ? $spfx_s : $spfx_snd)) : $spfx_n);
436 $subject = $overview->subject;
437 if (function_exists('hook_formatDisplayHeader')) {
438 list($subject, $link) = hook_formatDisplayHeader('subject', $subject, true);
439 } else {
440 $subject = banana_catchFormats(banana_htmlentities(stripslashes($subject)));
441 $link = null;
442 }
443 if (empty($subject)) {
444 $subject = _b_('(pas de sujet)');
445 }
446 if ($_index != $_ref) {
447 $subject = Banana::$page->makeLink(Array('group' => $this->group, 'artid' => $_id,
448 'text' => $subject, 'popup' => $subject));
449 }
450 $res .= '&nbsp;' . $subject . $link;
451 $res .= "</td>\n<td class='from'>" . BananaMessage::formatFrom($overview->from) . "</td>\n</tr>";
452
453 if ($hc) {
454 return $res;
455 }
456 }
457
458 $_index ++;
459 $children = $overview->children;
460 while ($child = array_shift($children)) {
461 $overview =& $this->overview[$child];
462 if ($_index > $_last) {
463 return $res;
464 }
465 if ($_index + $overview->desc >= $_first) {
466 if (sizeof($children)) {
467 $res .= $this->_to_html($child, $_index, $_first, $_last, $_ref,
468 $_pfx_end . ($overview->parent_direct ? $spfx_T : $spfx_Tnd),
469 $_pfx_end . $spfx_I, false);
470 } else {
471 $res .= $this->_to_html($child, $_index, $_first, $_last, $_ref,
472 $_pfx_end . ($overview->parent_direct ? $spfx_L : $spfx_Lnd),
473 $_pfx_end . $spfx_e, false);
474 }
475 }
476 $_index += $overview->desc;
477 }
478
479 return $res;
480 }
481
482 /** Displays overview
483 * @param $_first INTEGER MSGNUM of first post
484 * @param $_last INTEGER MSGNUM of last post
485 * @param $_ref STRING MSGNUM of current/selectionned post
486 */
487 public function toHtml($first = 0, $overview = false)
488 {
489 $res = '';
490
491 if (!$overview) {
492 $_first = $first;
493 $_last = $first + Banana::$spool_tmax - 1;
494 $_ref = null;
495 } else {
496 $_ref = $this->getNdx($first);
497 $_last = $_ref + Banana::$spool_tafter;
498 $_first = $_ref - Banana::$spool_tbefore;
499 if ($_first < 0) {
500 $_last -= $_first;
501 }
502 }
503 $index = 1;
504 foreach ($this->roots as $id) {
505 $res .= $this->_to_html($id, $index, $_first, $_last, $_ref);
506 $index += $this->overview[$id]->desc ;
507 if ($index > $_last) {
508 break;
509 }
510 }
511 return $res;
512 }
513
514 /** computes linear post index
515 * @param $_id INTEGER MSGNUM of post
516 * @return INTEGER linear index of post
517 */
518 public function getNdX($_id)
519 {
520 $ndx = 1;
521 $id_cur = $_id;
522 while (true) {
523 $id_parent = $this->overview[$id_cur]->parent;
524 if (is_null($id_parent)) break;
525 $pos = array_search($id_cur, $this->overview[$id_parent]->children);
526
527 for ($i = 0; $i < $pos ; $i++) {
528 $ndx += $this->overview[$this->overview[$id_parent]->children[$i]]->desc;
529 }
530 $ndx++; //noeud père
531
532 $id_cur = $id_parent;
533 }
534
535 foreach ($this->roots as $i) {
536 if ($i==$id_cur) {
537 break;
538 }
539 $ndx += $this->overview[$i]->desc;
540 }
541 return $ndx;
542 }
543
544 /** Return root message of the given thread
545 * @param id INTEGER id of a message
546 */
547 public function root($id)
548 {
549 $id_cur = $id;
550 while (true) {
551 $id_parent = $this->overview[$id_cur]->parent;
552 if (is_null($id_parent)) break;
553 $id_cur = $id_parent;
554 }
555 return $id_cur;
556 }
557
558 /** Returns previous thread root index
559 * @param id INTEGER message number
560 */
561 public function prevThread($id)
562 {
563 $root = $this->root($id);
564 $last = null;
565 foreach ($this->roots as $i) {
566 if ($i == $root) {
567 return $last;
568 }
569 $last = $i;
570 }
571 return $last;
572 }
573
574 /** Returns next thread root index
575 * @param id INTEGER message number
576 */
577 public function nextThread($id)
578 {
579 $root = $this->root($id);
580 $ok = false;
581 foreach ($this->roots as $i) {
582 if ($ok) {
583 return $i;
584 }
585 if ($i == $root) {
586 $ok = true;
587 }
588 }
589 return null;
590 }
591
592 /** Return prev post in the thread
593 * @param id INTEGER message number
594 */
595 public function prevPost($id)
596 {
597 $parent = $this->overview[$id]->parent;
598 if (is_null($parent)) {
599 return null;
600 }
601 $last = $parent;
602 foreach ($this->overview[$parent]->children as $child) {
603 if ($child == $id) {
604 return $last;
605 }
606 $last = $child;
607 }
608 return null;
609 }
610
611 /** Return next post in the thread
612 * @param id INTEGER message number
613 */
614 public function nextPost($id)
615 {
616 if (count($this->overview[$id]->children) != 0) {
617 return $this->overview[$id]->children[0];
618 }
619
620 $cur = $id;
621 while (true) {
622 $parent = $this->overview[$cur]->parent;
623 if (is_null($parent)) {
624 return null;
625 }
626 $ok = false;
627 foreach ($this->overview[$parent]->children as $child) {
628 if ($ok) {
629 return $child;
630 }
631 if ($child == $cur) {
632 $ok = true;
633 }
634 }
635 $cur = $parent;
636 }
637 return null;
638 }
639
640 /** Look for an unread message in the thread rooted by the message
641 * @param id INTEGER message number
642 */
643 private function _nextUnread($id)
644 {
645 if (!$this->overview[$id]->isread) {
646 return $id;
647 }
648 foreach ($this->overview[$id]->children as $child) {
649 $unread = $this->_nextUnread($child);
650 if (!is_null($unread)) {
651 return $unread;
652 }
653 }
654 return null;
655 }
656
657 /** Find next unread message
658 * @param id INTEGER message number
659 */
660 public function nextUnread($id = null)
661 {
662 if (!is_null($id)) {
663 // Look in message children
664 foreach ($this->overview[$id]->children as $child) {
665 $next = $this->_nextUnread($child);
666 if (!is_null($next)) {
667 return $next;
668 }
669 }
670 }
671
672 // Look in current thread
673 $cur = $id;
674 do {
675 $parent = is_null($cur) ? null : $this->overview[$cur]->parent;
676 $ok = is_null($cur) ? true : false;
677 if (!is_null($parent)) {
678 $array = &$this->overview[$parent]->children;
679 } else {
680 $array = &$this->roots;
681 }
682 foreach ($array as $child) {
683 if ($ok) {
684 $next = $this->_nextUnread($child);
685 if (!is_null($next)) {
686 return $next;
687 }
688 }
689 if ($child == $cur) {
690 $ok = true;
691 }
692 }
693 $cur = $parent;
694 } while(!is_null($cur));
695 return null;
696 }
697 }
698
699 // vim:set et sw=4 sts=4 ts=4 enc=utf-8:
700 ?>