]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - classes/Notice.php
6a701ae0cd1262693df736b82eafafbea600a4a1
[quix0rs-gnu-social.git] / classes / Notice.php
1 <?php
2 /**
3  * StatusNet - the distributed open-source microblogging tool
4  * Copyright (C) 2008, 2009, StatusNet, Inc.
5  *
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU Affero General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the
14  * GNU Affero General Public License for more details.
15  *
16  * You should have received a copy of the GNU Affero General Public License
17  * along with this program.     If not, see <http://www.gnu.org/licenses/>.
18  *
19  * @category Notices
20  * @package  StatusNet
21  * @author   Brenda Wallace <shiny@cpan.org>
22  * @author   Christopher Vollick <psycotica0@gmail.com>
23  * @author   CiaranG <ciaran@ciarang.com>
24  * @author   Craig Andrews <candrews@integralblue.com>
25  * @author   Evan Prodromou <evan@controlezvous.ca>
26  * @author   Gina Haeussge <osd@foosel.net>
27  * @author   Jeffery To <jeffery.to@gmail.com>
28  * @author   Mike Cochrane <mikec@mikenz.geek.nz>
29  * @author   Robin Millette <millette@controlyourself.ca>
30  * @author   Sarven Capadisli <csarven@controlyourself.ca>
31  * @author   Tom Adams <tom@holizz.com>
32  * @license  GNU Affero General Public License http://www.gnu.org/licenses/
33  */
34
35 if (!defined('STATUSNET') && !defined('LACONICA')) {
36     exit(1);
37 }
38
39 /**
40  * Table Definition for notice
41  */
42 require_once INSTALLDIR.'/classes/Memcached_DataObject.php';
43
44 /* We keep the first three 20-notice pages, plus one for pagination check,
45  * in the memcached cache. */
46
47 define('NOTICE_CACHE_WINDOW', 61);
48
49 define('MAX_BOXCARS', 128);
50
51 class Notice extends Memcached_DataObject
52 {
53     ###START_AUTOCODE
54     /* the code below is auto generated do not remove the above tag */
55
56     public $__table = 'notice';                          // table name
57     public $id;                              // int(4)  primary_key not_null
58     public $profile_id;                      // int(4)  multiple_key not_null
59     public $uri;                             // varchar(255)  unique_key
60     public $content;                         // text
61     public $rendered;                        // text
62     public $url;                             // varchar(255)
63     public $created;                         // datetime  multiple_key not_null default_0000-00-00%2000%3A00%3A00
64     public $modified;                        // timestamp   not_null default_CURRENT_TIMESTAMP
65     public $reply_to;                        // int(4)
66     public $is_local;                        // tinyint(1)
67     public $source;                          // varchar(32)
68     public $conversation;                    // int(4)
69     public $lat;                             // decimal(10,7)
70     public $lon;                             // decimal(10,7)
71     public $location_id;                     // int(4)
72     public $location_ns;                     // int(4)
73     public $repeat_of;                       // int(4)
74
75     /* Static get */
76     function staticGet($k,$v=NULL)
77     {
78         return Memcached_DataObject::staticGet('Notice',$k,$v);
79     }
80
81     /* the code above is auto generated do not remove the tag below */
82     ###END_AUTOCODE
83
84     /* Notice types */
85     const LOCAL_PUBLIC    =  1;
86     const REMOTE_OMB      =  0;
87     const LOCAL_NONPUBLIC = -1;
88     const GATEWAY         = -2;
89
90     function getProfile()
91     {
92         return Profile::staticGet('id', $this->profile_id);
93     }
94
95     function delete()
96     {
97         $this->blowCaches(true);
98         $this->blowFavesCache(true);
99         $this->blowSubsCache(true);
100
101         // For auditing purposes, save a record that the notice
102         // was deleted.
103
104         $deleted = new Deleted_notice();
105
106         $deleted->id         = $this->id;
107         $deleted->profile_id = $this->profile_id;
108         $deleted->uri        = $this->uri;
109         $deleted->created    = $this->created;
110         $deleted->deleted    = common_sql_now();
111
112         $this->query('BEGIN');
113
114         $deleted->insert();
115
116         //Null any notices that are replies to this notice
117         $this->query(sprintf("UPDATE notice set reply_to = null WHERE reply_to = %d", $this->id));
118         $related = array('Reply',
119                          'Fave',
120                          'Notice_tag',
121                          'Group_inbox',
122                          'Queue_item',
123                          'Notice_inbox');
124
125         foreach ($related as $cls) {
126             $inst = new $cls();
127             $inst->notice_id = $this->id;
128             $inst->delete();
129         }
130         $result = parent::delete();
131         $this->query('COMMIT');
132     }
133
134     function saveTags()
135     {
136         /* extract all #hastags */
137         $count = preg_match_all('/(?:^|\s)#([\pL\pN_\-\.]{1,64})/', strtolower($this->content), $match);
138         if (!$count) {
139             return true;
140         }
141
142         //turn each into their canonical tag
143         //this is needed to remove dupes before saving e.g. #hash.tag = #hashtag
144         $hashtags = array();
145         for($i=0; $i<count($match[1]); $i++) {
146             $hashtags[] = common_canonical_tag($match[1][$i]);
147         }
148
149         /* Add them to the database */
150         foreach(array_unique($hashtags) as $hashtag) {
151             /* elide characters we don't want in the tag */
152             $this->saveTag($hashtag);
153         }
154         return true;
155     }
156
157     function saveTag($hashtag)
158     {
159         $tag = new Notice_tag();
160         $tag->notice_id = $this->id;
161         $tag->tag = $hashtag;
162         $tag->created = $this->created;
163         $id = $tag->insert();
164
165         if (!$id) {
166             throw new ServerException(sprintf(_('DB error inserting hashtag: %s'),
167                                               $last_error->message));
168             return;
169         }
170     }
171
172     static function saveNew($profile_id, $content, $source, $options=null) {
173
174         if (!empty($options)) {
175             extract($options);
176             if (!isset($reply_to)) {
177                 $reply_to = NULL;
178             }
179         }
180
181         if (empty($is_local)) {
182             $is_local = Notice::LOCAL_PUBLIC;
183         }
184
185         $profile = Profile::staticGet($profile_id);
186
187         $final = common_shorten_links($content);
188
189         if (Notice::contentTooLong($final)) {
190             throw new ClientException(_('Problem saving notice. Too long.'));
191         }
192
193         if (empty($profile)) {
194             throw new ClientException(_('Problem saving notice. Unknown user.'));
195         }
196
197         if (common_config('throttle', 'enabled') && !Notice::checkEditThrottle($profile_id)) {
198             common_log(LOG_WARNING, 'Excessive posting by profile #' . $profile_id . '; throttled.');
199             throw new ClientException(_('Too many notices too fast; take a breather '.
200                                         'and post again in a few minutes.'));
201         }
202
203         if (common_config('site', 'dupelimit') > 0 && !Notice::checkDupes($profile_id, $final)) {
204             common_log(LOG_WARNING, 'Dupe posting by profile #' . $profile_id . '; throttled.');
205             throw new ClientException(_('Too many duplicate messages too quickly;'.
206                                         ' take a breather and post again in a few minutes.'));
207         }
208
209         if (!$profile->hasRight(Right::NEWNOTICE)) {
210             common_log(LOG_WARNING, "Attempted post from user disallowed to post: " . $profile->nickname);
211             throw new ClientException(_('You are banned from posting notices on this site.'));
212         }
213
214         $notice = new Notice();
215         $notice->profile_id = $profile_id;
216
217         $autosource = common_config('public', 'autosource');
218
219         # Sandboxed are non-false, but not 1, either
220
221         if (!$profile->hasRight(Right::PUBLICNOTICE) ||
222             ($source && $autosource && in_array($source, $autosource))) {
223             $notice->is_local = Notice::LOCAL_NONPUBLIC;
224         } else {
225             $notice->is_local = $is_local;
226         }
227
228         if (!empty($created)) {
229             $notice->created = $created;
230         } else {
231             $notice->created = common_sql_now();
232         }
233
234         $notice->content = $final;
235         $notice->rendered = common_render_content($final, $notice);
236         $notice->source = $source;
237         $notice->uri = $uri;
238
239         // Handle repeat case
240
241         if (isset($repeat_of)) {
242             $notice->repeat_of = $repeat_of;
243             $notice->reply_to = $repeat_of;
244         } else {
245             $notice->reply_to = self::getReplyTo($reply_to, $profile_id, $source, $final);
246         }
247
248         if (!empty($notice->reply_to)) {
249             $reply = Notice::staticGet('id', $notice->reply_to);
250             $notice->conversation = $reply->conversation;
251         }
252
253         if (!empty($lat) && !empty($lon)) {
254             $notice->lat = $lat;
255             $notice->lon = $lon;
256             $notice->location_id = $location_id;
257             $notice->location_ns = $location_ns;
258         } else if (!empty($location_ns) && !empty($location_id)) {
259             $location = Location::fromId($location_id, $location_ns);
260             if (!empty($location)) {
261                 $notice->lat = $location->lat;
262                 $notice->lon = $location->lon;
263                 $notice->location_id = $location_id;
264                 $notice->location_ns = $location_ns;
265             }
266         } else {
267             $notice->lat         = $profile->lat;
268             $notice->lon         = $profile->lon;
269             $notice->location_id = $profile->location_id;
270             $notice->location_ns = $profile->location_ns;
271         }
272
273         if (Event::handle('StartNoticeSave', array(&$notice))) {
274
275             // XXX: some of these functions write to the DB
276
277             $notice->query('BEGIN');
278
279             $id = $notice->insert();
280
281             if (!$id) {
282                 common_log_db_error($notice, 'INSERT', __FILE__);
283                 throw new ServerException(_('Problem saving notice.'));
284             }
285
286             // Update ID-dependent columns: URI, conversation
287
288             $orig = clone($notice);
289
290             $changed = false;
291
292             if (empty($uri)) {
293                 $notice->uri = common_notice_uri($notice);
294                 $changed = true;
295             }
296
297             // If it's not part of a conversation, it's
298             // the beginning of a new conversation.
299
300             if (empty($notice->conversation)) {
301                 $notice->conversation = $notice->id;
302                 $changed = true;
303             }
304
305             if ($changed) {
306                 if (!$notice->update($orig)) {
307                     common_log_db_error($notice, 'UPDATE', __FILE__);
308                     throw new ServerException(_('Problem saving notice.'));
309                 }
310             }
311
312             // XXX: do we need to change this for remote users?
313
314             $notice->saveTags();
315
316             $notice->addToInboxes();
317
318             $notice->saveUrls();
319
320             $notice->query('COMMIT');
321
322             Event::handle('EndNoticeSave', array($notice));
323         }
324
325         # Clear the cache for subscribed users, so they'll update at next request
326         # XXX: someone clever could prepend instead of clearing the cache
327
328         $notice->blowCaches();
329
330         return $notice;
331     }
332
333     /** save all urls in the notice to the db
334      *
335      * follow redirects and save all available file information
336      * (mimetype, date, size, oembed, etc.)
337      *
338      * @return void
339      */
340     function saveUrls() {
341         common_replace_urls_callback($this->content, array($this, 'saveUrl'), $this->id);
342     }
343
344     function saveUrl($data) {
345         list($url, $notice_id) = $data;
346         File::processNew($url, $notice_id);
347     }
348
349     static function checkDupes($profile_id, $content) {
350         $profile = Profile::staticGet($profile_id);
351         if (empty($profile)) {
352             return false;
353         }
354         $notice = $profile->getNotices(0, NOTICE_CACHE_WINDOW);
355         if (!empty($notice)) {
356             $last = 0;
357             while ($notice->fetch()) {
358                 if (time() - strtotime($notice->created) >= common_config('site', 'dupelimit')) {
359                     return true;
360                 } else if ($notice->content == $content) {
361                     return false;
362                 }
363             }
364         }
365         # If we get here, oldest item in cache window is not
366         # old enough for dupe limit; do direct check against DB
367         $notice = new Notice();
368         $notice->profile_id = $profile_id;
369         $notice->content = $content;
370         if (common_config('db','type') == 'pgsql')
371           $notice->whereAdd('extract(epoch from now() - created) < ' . common_config('site', 'dupelimit'));
372         else
373           $notice->whereAdd('now() - created < ' . common_config('site', 'dupelimit'));
374
375         $cnt = $notice->count();
376         return ($cnt == 0);
377     }
378
379     static function checkEditThrottle($profile_id) {
380         $profile = Profile::staticGet($profile_id);
381         if (empty($profile)) {
382             return false;
383         }
384         # Get the Nth notice
385         $notice = $profile->getNotices(common_config('throttle', 'count') - 1, 1);
386         if ($notice && $notice->fetch()) {
387             # If the Nth notice was posted less than timespan seconds ago
388             if (time() - strtotime($notice->created) <= common_config('throttle', 'timespan')) {
389                 # Then we throttle
390                 return false;
391             }
392         }
393         # Either not N notices in the stream, OR the Nth was not posted within timespan seconds
394         return true;
395     }
396
397     function getUploadedAttachment() {
398         $post = clone $this;
399         $query = 'select file.url as up, file.id as i from file join file_to_post on file.id = file_id where post_id=' . $post->escape($post->id) . ' and url like "%/notice/%/file"';
400         $post->query($query);
401         $post->fetch();
402         if (empty($post->up) || empty($post->i)) {
403             $ret = false;
404         } else {
405             $ret = array($post->up, $post->i);
406         }
407         $post->free();
408         return $ret;
409     }
410
411     function hasAttachments() {
412         $post = clone $this;
413         $query = "select count(file_id) as n_attachments from file join file_to_post on (file_id = file.id) join notice on (post_id = notice.id) where post_id = " . $post->escape($post->id);
414         $post->query($query);
415         $post->fetch();
416         $n_attachments = intval($post->n_attachments);
417         $post->free();
418         return $n_attachments;
419     }
420
421     function attachments() {
422         // XXX: cache this
423         $att = array();
424         $f2p = new File_to_post;
425         $f2p->post_id = $this->id;
426         if ($f2p->find()) {
427             while ($f2p->fetch()) {
428                 $f = File::staticGet($f2p->file_id);
429                 $att[] = clone($f);
430             }
431         }
432         return $att;
433     }
434
435     function blowCaches($blowLast=false)
436     {
437         $this->blowSubsCache($blowLast);
438         $this->blowNoticeCache($blowLast);
439         $this->blowRepliesCache($blowLast);
440         $this->blowPublicCache($blowLast);
441         $this->blowTagCache($blowLast);
442         $this->blowGroupCache($blowLast);
443         $this->blowConversationCache($blowLast);
444         $this->blowRepeatCache();
445         $profile = Profile::staticGet($this->profile_id);
446         $profile->blowNoticeCount();
447     }
448
449     function blowRepeatCache()
450     {
451         if (!empty($this->repeat_of)) {
452             $cache = common_memcache();
453             if (!empty($cache)) {
454                 // XXX: only blow if <100 in cache
455                 $ck = common_cache_key('notice:repeats:'.$this->repeat_of);
456                 $result = $cache->delete($ck);
457
458                 $user = User::staticGet('id', $this->profile_id);
459
460                 if (!empty($user)) {
461                     $uk = common_cache_key('user:repeated_by_me:'.$user->id);
462                     $cache->delete($uk);
463                     $user->free();
464                     unset($user);
465                 }
466             }
467         }
468     }
469
470     function blowConversationCache($blowLast=false)
471     {
472         $cache = common_memcache();
473         if ($cache) {
474             $ck = common_cache_key('notice:conversation_ids:'.$this->conversation);
475             $cache->delete($ck);
476             if ($blowLast) {
477                 $cache->delete($ck.';last');
478             }
479         }
480     }
481
482     function blowGroupCache($blowLast=false)
483     {
484         $cache = common_memcache();
485         if ($cache) {
486             $group_inbox = new Group_inbox();
487             $group_inbox->notice_id = $this->id;
488             if ($group_inbox->find()) {
489                 while ($group_inbox->fetch()) {
490                     $cache->delete(common_cache_key('user_group:notice_ids:' . $group_inbox->group_id));
491                     if ($blowLast) {
492                         $cache->delete(common_cache_key('user_group:notice_ids:' . $group_inbox->group_id.';last'));
493                     }
494                     $member = new Group_member();
495                     $member->group_id = $group_inbox->group_id;
496                     if ($member->find()) {
497                         while ($member->fetch()) {
498                             $cache->delete(common_cache_key('notice_inbox:by_user:' . $member->profile_id));
499                             if ($blowLast) {
500                                 $cache->delete(common_cache_key('notice_inbox:by_user:' . $member->profile_id . ';last'));
501                             }
502                         }
503                     }
504                 }
505             }
506             $group_inbox->free();
507             unset($group_inbox);
508         }
509     }
510
511     function blowTagCache($blowLast=false)
512     {
513         $cache = common_memcache();
514         if ($cache) {
515             $tag = new Notice_tag();
516             $tag->notice_id = $this->id;
517             if ($tag->find()) {
518                 while ($tag->fetch()) {
519                     $tag->blowCache($blowLast);
520                     $ck = 'profile:notice_ids_tagged:' . $this->profile_id . ':' . $tag->tag;
521
522                     $cache->delete($ck);
523                     if ($blowLast) {
524                         $cache->delete($ck . ';last');
525                     }
526                 }
527             }
528             $tag->free();
529             unset($tag);
530         }
531     }
532
533     function blowSubsCache($blowLast=false)
534     {
535         $cache = common_memcache();
536         if ($cache) {
537             $user = new User();
538
539             $UT = common_config('db','type')=='pgsql'?'"user"':'user';
540             $user->query('SELECT id ' .
541
542                          "FROM $UT JOIN subscription ON $UT.id = subscription.subscriber " .
543                          'WHERE subscription.subscribed = ' . $this->profile_id);
544
545             while ($user->fetch()) {
546                 $cache->delete(common_cache_key('notice_inbox:by_user:'.$user->id));
547                 $cache->delete(common_cache_key('notice_inbox:by_user_own:'.$user->id));
548                 if ($blowLast) {
549                     $cache->delete(common_cache_key('notice_inbox:by_user:'.$user->id.';last'));
550                     $cache->delete(common_cache_key('notice_inbox:by_user_own:'.$user->id.';last'));
551                 }
552             }
553             $user->free();
554             unset($user);
555         }
556     }
557
558     function blowNoticeCache($blowLast=false)
559     {
560         if ($this->is_local) {
561             $cache = common_memcache();
562             if (!empty($cache)) {
563                 $cache->delete(common_cache_key('profile:notice_ids:'.$this->profile_id));
564                 if ($blowLast) {
565                     $cache->delete(common_cache_key('profile:notice_ids:'.$this->profile_id.';last'));
566                 }
567             }
568         }
569     }
570
571     function blowRepliesCache($blowLast=false)
572     {
573         $cache = common_memcache();
574         if ($cache) {
575             $reply = new Reply();
576             $reply->notice_id = $this->id;
577             if ($reply->find()) {
578                 while ($reply->fetch()) {
579                     $cache->delete(common_cache_key('reply:stream:'.$reply->profile_id));
580                     if ($blowLast) {
581                         $cache->delete(common_cache_key('reply:stream:'.$reply->profile_id.';last'));
582                     }
583                 }
584             }
585             $reply->free();
586             unset($reply);
587         }
588     }
589
590     function blowPublicCache($blowLast=false)
591     {
592         if ($this->is_local == Notice::LOCAL_PUBLIC) {
593             $cache = common_memcache();
594             if ($cache) {
595                 $cache->delete(common_cache_key('public'));
596                 if ($blowLast) {
597                     $cache->delete(common_cache_key('public').';last');
598                 }
599             }
600         }
601     }
602
603     function blowFavesCache($blowLast=false)
604     {
605         $cache = common_memcache();
606         if ($cache) {
607             $fave = new Fave();
608             $fave->notice_id = $this->id;
609             if ($fave->find()) {
610                 while ($fave->fetch()) {
611                     $cache->delete(common_cache_key('fave:ids_by_user:'.$fave->user_id));
612                     $cache->delete(common_cache_key('fave:by_user_own:'.$fave->user_id));
613                     if ($blowLast) {
614                         $cache->delete(common_cache_key('fave:ids_by_user:'.$fave->user_id.';last'));
615                         $cache->delete(common_cache_key('fave:by_user_own:'.$fave->user_id.';last'));
616                     }
617                 }
618             }
619             $fave->free();
620             unset($fave);
621         }
622     }
623
624     # XXX: too many args; we need to move to named params or even a separate
625     # class for notice streams
626
627     static function getStream($qry, $cachekey, $offset=0, $limit=20, $since_id=0, $max_id=0, $order=null, $since=null) {
628
629         if (common_config('memcached', 'enabled')) {
630
631             # Skip the cache if this is a since, since_id or max_id qry
632             if ($since_id > 0 || $max_id > 0 || $since) {
633                 return Notice::getStreamDirect($qry, $offset, $limit, $since_id, $max_id, $order, $since);
634             } else {
635                 return Notice::getCachedStream($qry, $cachekey, $offset, $limit, $order);
636             }
637         }
638
639         return Notice::getStreamDirect($qry, $offset, $limit, $since_id, $max_id, $order, $since);
640     }
641
642     static function getStreamDirect($qry, $offset, $limit, $since_id, $max_id, $order, $since) {
643
644         $needAnd = false;
645         $needWhere = true;
646
647         if (preg_match('/\bWHERE\b/i', $qry)) {
648             $needWhere = false;
649             $needAnd = true;
650         }
651
652         if ($since_id > 0) {
653
654             if ($needWhere) {
655                 $qry .= ' WHERE ';
656                 $needWhere = false;
657             } else {
658                 $qry .= ' AND ';
659             }
660
661             $qry .= ' notice.id > ' . $since_id;
662         }
663
664         if ($max_id > 0) {
665
666             if ($needWhere) {
667                 $qry .= ' WHERE ';
668                 $needWhere = false;
669             } else {
670                 $qry .= ' AND ';
671             }
672
673             $qry .= ' notice.id <= ' . $max_id;
674         }
675
676         if ($since) {
677
678             if ($needWhere) {
679                 $qry .= ' WHERE ';
680                 $needWhere = false;
681             } else {
682                 $qry .= ' AND ';
683             }
684
685             $qry .= ' notice.created > \'' . date('Y-m-d H:i:s', $since) . '\'';
686         }
687
688         # Allow ORDER override
689
690         if ($order) {
691             $qry .= $order;
692         } else {
693             $qry .= ' ORDER BY notice.created DESC, notice.id DESC ';
694         }
695
696         if (common_config('db','type') == 'pgsql') {
697             $qry .= ' LIMIT ' . $limit . ' OFFSET ' . $offset;
698         } else {
699             $qry .= ' LIMIT ' . $offset . ', ' . $limit;
700         }
701
702         $notice = new Notice();
703
704         $notice->query($qry);
705
706         return $notice;
707     }
708
709     # XXX: this is pretty long and should probably be broken up into
710     # some helper functions
711
712     static function getCachedStream($qry, $cachekey, $offset, $limit, $order) {
713
714         # If outside our cache window, just go to the DB
715
716         if ($offset + $limit > NOTICE_CACHE_WINDOW) {
717             return Notice::getStreamDirect($qry, $offset, $limit, null, null, $order, null);
718         }
719
720         # Get the cache; if we can't, just go to the DB
721
722         $cache = common_memcache();
723
724         if (empty($cache)) {
725             return Notice::getStreamDirect($qry, $offset, $limit, null, null, $order, null);
726         }
727
728         # Get the notices out of the cache
729
730         $notices = $cache->get(common_cache_key($cachekey));
731
732         # On a cache hit, return a DB-object-like wrapper
733
734         if ($notices !== false) {
735             $wrapper = new ArrayWrapper(array_slice($notices, $offset, $limit));
736             return $wrapper;
737         }
738
739         # If the cache was invalidated because of new data being
740         # added, we can try and just get the new stuff. We keep an additional
741         # copy of the data at the key + ';last'
742
743         # No cache hit. Try to get the *last* cached version
744
745         $last_notices = $cache->get(common_cache_key($cachekey) . ';last');
746
747         if ($last_notices) {
748
749             # Reverse-chron order, so last ID is last.
750
751             $last_id = $last_notices[0]->id;
752
753             # XXX: this assumes monotonically increasing IDs; a fair
754             # bet with our DB.
755
756             $new_notice = Notice::getStreamDirect($qry, 0, NOTICE_CACHE_WINDOW,
757                                                   $last_id, null, $order, null);
758
759             if ($new_notice) {
760                 $new_notices = array();
761                 while ($new_notice->fetch()) {
762                     $new_notices[] = clone($new_notice);
763                 }
764                 $new_notice->free();
765                 $notices = array_slice(array_merge($new_notices, $last_notices),
766                                        0, NOTICE_CACHE_WINDOW);
767
768                 # Store the array in the cache for next time
769
770                 $result = $cache->set(common_cache_key($cachekey), $notices);
771                 $result = $cache->set(common_cache_key($cachekey) . ';last', $notices);
772
773                 # return a wrapper of the array for use now
774
775                 return new ArrayWrapper(array_slice($notices, $offset, $limit));
776             }
777         }
778
779         # Otherwise, get the full cache window out of the DB
780
781         $notice = Notice::getStreamDirect($qry, 0, NOTICE_CACHE_WINDOW, null, null, $order, null);
782
783         # If there are no hits, just return the value
784
785         if (empty($notice)) {
786             return $notice;
787         }
788
789         # Pack results into an array
790
791         $notices = array();
792
793         while ($notice->fetch()) {
794             $notices[] = clone($notice);
795         }
796
797         $notice->free();
798
799         # Store the array in the cache for next time
800
801         $result = $cache->set(common_cache_key($cachekey), $notices);
802         $result = $cache->set(common_cache_key($cachekey) . ';last', $notices);
803
804         # return a wrapper of the array for use now
805
806         $wrapper = new ArrayWrapper(array_slice($notices, $offset, $limit));
807
808         return $wrapper;
809     }
810
811     function getStreamByIds($ids)
812     {
813         $cache = common_memcache();
814
815         if (!empty($cache)) {
816             $notices = array();
817             foreach ($ids as $id) {
818                 $n = Notice::staticGet('id', $id);
819                 if (!empty($n)) {
820                     $notices[] = $n;
821                 }
822             }
823             return new ArrayWrapper($notices);
824         } else {
825             $notice = new Notice();
826             if (empty($ids)) {
827                 //if no IDs requested, just return the notice object
828                 return $notice;
829             }
830             $notice->whereAdd('id in (' . implode(', ', $ids) . ')');
831
832             $notice->find();
833
834             $temp = array();
835
836             while ($notice->fetch()) {
837                 $temp[$notice->id] = clone($notice);
838             }
839
840             $wrapped = array();
841
842             foreach ($ids as $id) {
843                 if (array_key_exists($id, $temp)) {
844                     $wrapped[] = $temp[$id];
845                 }
846             }
847
848             return new ArrayWrapper($wrapped);
849         }
850     }
851
852     function publicStream($offset=0, $limit=20, $since_id=0, $max_id=0, $since=null)
853     {
854         $ids = Notice::stream(array('Notice', '_publicStreamDirect'),
855                               array(),
856                               'public',
857                               $offset, $limit, $since_id, $max_id, $since);
858
859         return Notice::getStreamByIds($ids);
860     }
861
862     function _publicStreamDirect($offset=0, $limit=20, $since_id=0, $max_id=0, $since=null)
863     {
864         $notice = new Notice();
865
866         $notice->selectAdd(); // clears it
867         $notice->selectAdd('id');
868
869         $notice->orderBy('id DESC');
870
871         if (!is_null($offset)) {
872             $notice->limit($offset, $limit);
873         }
874
875         if (common_config('public', 'localonly')) {
876             $notice->whereAdd('is_local = ' . Notice::LOCAL_PUBLIC);
877         } else {
878             # -1 == blacklisted, -2 == gateway (i.e. Twitter)
879             $notice->whereAdd('is_local !='. Notice::LOCAL_NONPUBLIC);
880             $notice->whereAdd('is_local !='. Notice::GATEWAY);
881         }
882
883         if ($since_id != 0) {
884             $notice->whereAdd('id > ' . $since_id);
885         }
886
887         if ($max_id != 0) {
888             $notice->whereAdd('id <= ' . $max_id);
889         }
890
891         if (!is_null($since)) {
892             $notice->whereAdd('created > \'' . date('Y-m-d H:i:s', $since) . '\'');
893         }
894
895         $ids = array();
896
897         if ($notice->find()) {
898             while ($notice->fetch()) {
899                 $ids[] = $notice->id;
900             }
901         }
902
903         $notice->free();
904         $notice = NULL;
905
906         return $ids;
907     }
908
909     function conversationStream($id, $offset=0, $limit=20, $since_id=0, $max_id=0, $since=null)
910     {
911         $ids = Notice::stream(array('Notice', '_conversationStreamDirect'),
912                               array($id),
913                               'notice:conversation_ids:'.$id,
914                               $offset, $limit, $since_id, $max_id, $since);
915
916         return Notice::getStreamByIds($ids);
917     }
918
919     function _conversationStreamDirect($id, $offset=0, $limit=20, $since_id=0, $max_id=0, $since=null)
920     {
921         $notice = new Notice();
922
923         $notice->selectAdd(); // clears it
924         $notice->selectAdd('id');
925
926         $notice->conversation = $id;
927
928         $notice->orderBy('id DESC');
929
930         if (!is_null($offset)) {
931             $notice->limit($offset, $limit);
932         }
933
934         if ($since_id != 0) {
935             $notice->whereAdd('id > ' . $since_id);
936         }
937
938         if ($max_id != 0) {
939             $notice->whereAdd('id <= ' . $max_id);
940         }
941
942         if (!is_null($since)) {
943             $notice->whereAdd('created > \'' . date('Y-m-d H:i:s', $since) . '\'');
944         }
945
946         $ids = array();
947
948         if ($notice->find()) {
949             while ($notice->fetch()) {
950                 $ids[] = $notice->id;
951             }
952         }
953
954         $notice->free();
955         $notice = NULL;
956
957         return $ids;
958     }
959
960     function addToInboxes()
961     {
962         // XXX: loads constants
963
964         $inbox = new Notice_inbox();
965
966         $users = $this->getSubscribedUsers();
967
968         // FIXME: kind of ignoring 'transitional'...
969         // we'll probably stop supporting inboxless mode
970         // in 0.9.x
971
972         $ni = array();
973
974         foreach ($users as $id) {
975             $ni[$id] = NOTICE_INBOX_SOURCE_SUB;
976         }
977
978         $groups = $this->saveGroups();
979         $profile = $this->getProfile();
980
981         foreach ($groups as $group) {
982             $users = $group->getUserMembers();
983             foreach ($users as $id) {
984                 if (!array_key_exists($id, $ni)) {
985                     $user = User::staticGet('id', $id);
986                     if (!$user->hasBlocked($profile)) {
987                         $ni[$id] = NOTICE_INBOX_SOURCE_GROUP;
988                     }
989                 }
990             }
991         }
992
993         $recipients = $this->saveReplies();
994
995         foreach ($recipients as $recipient) {
996
997             if (!array_key_exists($recipient, $ni)) {
998                 $recipientUser = User::staticGet('id', $recipient);
999                 if (!empty($recipientUser)) {
1000                     $ni[$recipient] = NOTICE_INBOX_SOURCE_REPLY;
1001                 }
1002             }
1003         }
1004
1005         Notice_inbox::bulkInsert($this->id, $this->created, $ni);
1006
1007         return;
1008     }
1009
1010     function getSubscribedUsers()
1011     {
1012         $user = new User();
1013
1014         if(common_config('db','quote_identifiers'))
1015           $user_table = '"user"';
1016         else $user_table = 'user';
1017
1018         $qry =
1019           'SELECT id ' .
1020           'FROM '. $user_table .' JOIN subscription '.
1021           'ON '. $user_table .'.id = subscription.subscriber ' .
1022           'WHERE subscription.subscribed = %d ';
1023
1024         $user->query(sprintf($qry, $this->profile_id));
1025
1026         $ids = array();
1027
1028         while ($user->fetch()) {
1029             $ids[] = $user->id;
1030         }
1031
1032         $user->free();
1033
1034         return $ids;
1035     }
1036
1037     function saveGroups()
1038     {
1039         $groups = array();
1040
1041         /* extract all !group */
1042         $count = preg_match_all('/(?:^|\s)!([A-Za-z0-9]{1,64})/',
1043                                 strtolower($this->content),
1044                                 $match);
1045         if (!$count) {
1046             return $groups;
1047         }
1048
1049         $profile = $this->getProfile();
1050
1051         /* Add them to the database */
1052
1053         foreach (array_unique($match[1]) as $nickname) {
1054             /* XXX: remote groups. */
1055             $group = User_group::getForNickname($nickname);
1056
1057             if (empty($group)) {
1058                 continue;
1059             }
1060
1061             // we automatically add a tag for every group name, too
1062
1063             $tag = Notice_tag::pkeyGet(array('tag' => common_canonical_tag($nickname),
1064                                              'notice_id' => $this->id));
1065
1066             if (is_null($tag)) {
1067                 $this->saveTag($nickname);
1068             }
1069
1070             if ($profile->isMember($group)) {
1071
1072                 $result = $this->addToGroupInbox($group);
1073
1074                 if (!$result) {
1075                     common_log_db_error($gi, 'INSERT', __FILE__);
1076                 }
1077
1078                 $groups[] = clone($group);
1079             }
1080         }
1081
1082         return $groups;
1083     }
1084
1085     function addToGroupInbox($group)
1086     {
1087         $gi = Group_inbox::pkeyGet(array('group_id' => $group->id,
1088                                          'notice_id' => $this->id));
1089
1090         if (empty($gi)) {
1091
1092             $gi = new Group_inbox();
1093
1094             $gi->group_id  = $group->id;
1095             $gi->notice_id = $this->id;
1096             $gi->created   = $this->created;
1097
1098             return $gi->insert();
1099         }
1100
1101         return true;
1102     }
1103
1104     function saveReplies()
1105     {
1106         // Alternative reply format
1107         $tname = false;
1108         if (preg_match('/^T ([A-Z0-9]{1,64}) /', $this->content, $match)) {
1109             $tname = $match[1];
1110         }
1111         // extract all @messages
1112         $cnt = preg_match_all('/(?:^|\s)@([a-z0-9]{1,64})/', $this->content, $match);
1113
1114         $names = array();
1115
1116         if ($cnt || $tname) {
1117             // XXX: is there another way to make an array copy?
1118             $names = ($tname) ? array_unique(array_merge(array(strtolower($tname)), $match[1])) : array_unique($match[1]);
1119         }
1120
1121         $sender = Profile::staticGet($this->profile_id);
1122
1123         $replied = array();
1124
1125         // store replied only for first @ (what user/notice what the reply directed,
1126         // we assume first @ is it)
1127
1128         for ($i=0; $i<count($names); $i++) {
1129             $nickname = $names[$i];
1130             $recipient = common_relative_profile($sender, $nickname, $this->created);
1131             if (empty($recipient)) {
1132                 continue;
1133             }
1134             // Don't save replies from blocked profile to local user
1135             $recipient_user = User::staticGet('id', $recipient->id);
1136             if (!empty($recipient_user) && $recipient_user->hasBlocked($sender)) {
1137                 continue;
1138             }
1139             $reply = new Reply();
1140             $reply->notice_id = $this->id;
1141             $reply->profile_id = $recipient->id;
1142             $id = $reply->insert();
1143             if (!$id) {
1144                 $last_error = &PEAR::getStaticProperty('DB_DataObject','lastError');
1145                 common_log(LOG_ERR, 'DB error inserting reply: ' . $last_error->message);
1146                 common_server_error(sprintf(_('DB error inserting reply: %s'), $last_error->message));
1147                 return array();
1148             } else {
1149                 $replied[$recipient->id] = 1;
1150             }
1151         }
1152
1153         // Hash format replies, too
1154         $cnt = preg_match_all('/(?:^|\s)@#([a-z0-9]{1,64})/', $this->content, $match);
1155         if ($cnt) {
1156             foreach ($match[1] as $tag) {
1157                 $tagged = Profile_tag::getTagged($sender->id, $tag);
1158                 foreach ($tagged as $t) {
1159                     if (!$replied[$t->id]) {
1160                         // Don't save replies from blocked profile to local user
1161                         $t_user = User::staticGet('id', $t->id);
1162                         if ($t_user && $t_user->hasBlocked($sender)) {
1163                             continue;
1164                         }
1165                         $reply = new Reply();
1166                         $reply->notice_id = $this->id;
1167                         $reply->profile_id = $t->id;
1168                         $id = $reply->insert();
1169                         if (!$id) {
1170                             common_log_db_error($reply, 'INSERT', __FILE__);
1171                             return array();
1172                         } else {
1173                             $replied[$recipient->id] = 1;
1174                         }
1175                     }
1176                 }
1177             }
1178         }
1179
1180         $recipientIds = array_keys($replied);
1181
1182         foreach ($recipientIds as $recipient) {
1183             $user = User::staticGet('id', $recipient);
1184             if ($user) {
1185                 mail_notify_attn($user, $this);
1186             }
1187         }
1188
1189         return $recipientIds;
1190     }
1191
1192     function asAtomEntry($namespace=false, $source=false)
1193     {
1194         $profile = $this->getProfile();
1195
1196         $xs = new XMLStringer(true);
1197
1198         if ($namespace) {
1199             $attrs = array('xmlns' => 'http://www.w3.org/2005/Atom',
1200                            'xmlns:thr' => 'http://purl.org/syndication/thread/1.0');
1201         } else {
1202             $attrs = array();
1203         }
1204
1205         $xs->elementStart('entry', $attrs);
1206
1207         if ($source) {
1208             $xs->elementStart('source');
1209             $xs->element('title', null, $profile->nickname . " - " . common_config('site', 'name'));
1210             $xs->element('link', array('href' => $profile->profileurl));
1211             $user = User::staticGet('id', $profile->id);
1212             if (!empty($user)) {
1213                 $atom_feed = common_local_url('ApiTimelineUser',
1214                                               array('format' => 'atom',
1215                                                     'id' => $profile->nickname));
1216                 $xs->element('link', array('rel' => 'self',
1217                                            'type' => 'application/atom+xml',
1218                                            'href' => $profile->profileurl));
1219                 $xs->element('link', array('rel' => 'license',
1220                                            'href' => common_config('license', 'url')));
1221             }
1222
1223             $xs->element('icon', null, $profile->avatarUrl(AVATAR_PROFILE_SIZE));
1224         }
1225
1226         $xs->elementStart('author');
1227         $xs->element('name', null, $profile->nickname);
1228         $xs->element('uri', null, $profile->profileurl);
1229         $xs->elementEnd('author');
1230
1231         if ($source) {
1232             $xs->elementEnd('source');
1233         }
1234
1235         $xs->element('title', null, $this->content);
1236         $xs->element('summary', null, $this->content);
1237
1238         $xs->element('link', array('rel' => 'alternate',
1239                                    'href' => $this->bestUrl()));
1240
1241         $xs->element('id', null, $this->uri);
1242
1243         $xs->element('published', null, common_date_w3dtf($this->created));
1244         $xs->element('updated', null, common_date_w3dtf($this->modified));
1245
1246         if ($this->reply_to) {
1247             $reply_notice = Notice::staticGet('id', $this->reply_to);
1248             if (!empty($reply_notice)) {
1249                 $xs->element('link', array('rel' => 'related',
1250                                            'href' => $reply_notice->bestUrl()));
1251                 $xs->element('thr:in-reply-to',
1252                              array('ref' => $reply_notice->uri,
1253                                    'href' => $reply_notice->bestUrl()));
1254             }
1255         }
1256
1257         $xs->element('content', array('type' => 'html'), $this->rendered);
1258
1259         $tag = new Notice_tag();
1260         $tag->notice_id = $this->id;
1261         if ($tag->find()) {
1262             while ($tag->fetch()) {
1263                 $xs->element('category', array('term' => $tag->tag));
1264             }
1265         }
1266         $tag->free();
1267
1268         # Enclosures
1269         $attachments = $this->attachments();
1270         if($attachments){
1271             foreach($attachments as $attachment){
1272                 $enclosure=$attachment->getEnclosure();
1273                 if ($enclosure) {
1274                     $attributes = array('rel'=>'enclosure','href'=>$enclosure->url,'type'=>$enclosure->mimetype,'length'=>$enclosure->size);
1275                     if($enclosure->title){
1276                         $attributes['title']=$enclosure->title;
1277                     }
1278                     $xs->element('link', $attributes, null);
1279                 }
1280             }
1281         }
1282
1283         if (!empty($this->lat) && !empty($this->lon)) {
1284             $xs->elementStart('geo', array('xmlns:georss' => 'http://www.georss.org/georss'));
1285             $xs->element('georss:point', null, $this->lat . ' ' . $this->lon);
1286             $xs->elementEnd('geo');
1287         }
1288
1289         $xs->elementEnd('entry');
1290
1291         return $xs->getString();
1292     }
1293
1294     function bestUrl()
1295     {
1296         if (!empty($this->url)) {
1297             return $this->url;
1298         } else if (!empty($this->uri) && preg_match('/^https?:/', $this->uri)) {
1299             return $this->uri;
1300         } else {
1301             return common_local_url('shownotice',
1302                                     array('notice' => $this->id));
1303         }
1304     }
1305
1306     function stream($fn, $args, $cachekey, $offset=0, $limit=20, $since_id=0, $max_id=0, $since=null)
1307     {
1308         $cache = common_memcache();
1309
1310         if (empty($cache) ||
1311             $since_id != 0 || $max_id != 0 || (!is_null($since) && $since > 0) ||
1312             is_null($limit) ||
1313             ($offset + $limit) > NOTICE_CACHE_WINDOW) {
1314             return call_user_func_array($fn, array_merge($args, array($offset, $limit, $since_id,
1315                                                                       $max_id, $since)));
1316         }
1317
1318         $idkey = common_cache_key($cachekey);
1319
1320         $idstr = $cache->get($idkey);
1321
1322         if (!empty($idstr)) {
1323             // Cache hit! Woohoo!
1324             $window = explode(',', $idstr);
1325             $ids = array_slice($window, $offset, $limit);
1326             return $ids;
1327         }
1328
1329         $laststr = $cache->get($idkey.';last');
1330
1331         if (!empty($laststr)) {
1332             $window = explode(',', $laststr);
1333             $last_id = $window[0];
1334             $new_ids = call_user_func_array($fn, array_merge($args, array(0, NOTICE_CACHE_WINDOW,
1335                                                                           $last_id, 0, null)));
1336
1337             $new_window = array_merge($new_ids, $window);
1338
1339             $new_windowstr = implode(',', $new_window);
1340
1341             $result = $cache->set($idkey, $new_windowstr);
1342             $result = $cache->set($idkey . ';last', $new_windowstr);
1343
1344             $ids = array_slice($new_window, $offset, $limit);
1345
1346             return $ids;
1347         }
1348
1349         $window = call_user_func_array($fn, array_merge($args, array(0, NOTICE_CACHE_WINDOW,
1350                                                                      0, 0, null)));
1351
1352         $windowstr = implode(',', $window);
1353
1354         $result = $cache->set($idkey, $windowstr);
1355         $result = $cache->set($idkey . ';last', $windowstr);
1356
1357         $ids = array_slice($window, $offset, $limit);
1358
1359         return $ids;
1360     }
1361
1362     /**
1363      * Determine which notice, if any, a new notice is in reply to.
1364      *
1365      * For conversation tracking, we try to see where this notice fits
1366      * in the tree. Rough algorithm is:
1367      *
1368      * if (reply_to is set and valid) {
1369      *     return reply_to;
1370      * } else if ((source not API or Web) and (content starts with "T NAME" or "@name ")) {
1371      *     return ID of last notice by initial @name in content;
1372      * }
1373      *
1374      * Note that all @nickname instances will still be used to save "reply" records,
1375      * so the notice shows up in the mentioned users' "replies" tab.
1376      *
1377      * @param integer $reply_to   ID passed in by Web or API
1378      * @param integer $profile_id ID of author
1379      * @param string  $source     Source tag, like 'web' or 'gwibber'
1380      * @param string  $content    Final notice content
1381      *
1382      * @return integer ID of replied-to notice, or null for not a reply.
1383      */
1384
1385     static function getReplyTo($reply_to, $profile_id, $source, $content)
1386     {
1387         static $lb = array('xmpp', 'mail', 'sms', 'omb');
1388
1389         // If $reply_to is specified, we check that it exists, and then
1390         // return it if it does
1391
1392         if (!empty($reply_to)) {
1393             $reply_notice = Notice::staticGet('id', $reply_to);
1394             if (!empty($reply_notice)) {
1395                 return $reply_to;
1396             }
1397         }
1398
1399         // If it's not a "low bandwidth" source (one where you can't set
1400         // a reply_to argument), we return. This is mostly web and API
1401         // clients.
1402
1403         if (!in_array($source, $lb)) {
1404             return null;
1405         }
1406
1407         // Is there an initial @ or T?
1408
1409         if (preg_match('/^T ([A-Z0-9]{1,64}) /', $content, $match) ||
1410             preg_match('/^@([a-z0-9]{1,64})\s+/', $content, $match)) {
1411             $nickname = common_canonical_nickname($match[1]);
1412         } else {
1413             return null;
1414         }
1415
1416         // Figure out who that is.
1417
1418         $sender = Profile::staticGet('id', $profile_id);
1419         $recipient = common_relative_profile($sender, $nickname, common_sql_now());
1420
1421         if (empty($recipient)) {
1422             return null;
1423         }
1424
1425         // Get their last notice
1426
1427         $last = $recipient->getCurrentNotice();
1428
1429         if (!empty($last)) {
1430             return $last->id;
1431         }
1432     }
1433
1434     static function maxContent()
1435     {
1436         $contentlimit = common_config('notice', 'contentlimit');
1437         // null => use global limit (distinct from 0!)
1438         if (is_null($contentlimit)) {
1439             $contentlimit = common_config('site', 'textlimit');
1440         }
1441         return $contentlimit;
1442     }
1443
1444     static function contentTooLong($content)
1445     {
1446         $contentlimit = self::maxContent();
1447         return ($contentlimit > 0 && !empty($content) && (mb_strlen($content) > $contentlimit));
1448     }
1449
1450     function getLocation()
1451     {
1452         $location = null;
1453
1454         if (!empty($this->location_id) && !empty($this->location_ns)) {
1455             $location = Location::fromId($this->location_id, $this->location_ns);
1456         }
1457
1458         if (is_null($location)) { // no ID, or Location::fromId() failed
1459             if (!empty($this->lat) && !empty($this->lon)) {
1460                 $location = Location::fromLatLon($this->lat, $this->lon);
1461             }
1462         }
1463
1464         return $location;
1465     }
1466
1467     function repeat($repeater_id, $source)
1468     {
1469         $author = Profile::staticGet('id', $this->profile_id);
1470
1471         // FIXME: truncate on long repeats...?
1472
1473         $content = sprintf(_('RT @%1$s %2$s'),
1474                            $author->nickname,
1475                            $this->content);
1476
1477         return self::saveNew($repeater_id, $content, $source,
1478                              array('repeat_of' => $this->id));
1479     }
1480
1481     // These are supposed to be in chron order!
1482
1483     function repeatStream($limit=100)
1484     {
1485         $cache = common_memcache();
1486
1487         if (empty($cache)) {
1488             $ids = $this->_repeatStreamDirect($limit);
1489         } else {
1490             $idstr = $cache->get(common_cache_key('notice:repeats:'.$this->id));
1491             if (!empty($idstr)) {
1492                 $ids = explode(',', $idstr);
1493             } else {
1494                 $ids = $this->_repeatStreamDirect(100);
1495                 $cache->set(common_cache_key('notice:repeats:'.$this->id), implode(',', $ids));
1496             }
1497             if ($limit < 100) {
1498                 // We do a max of 100, so slice down to limit
1499                 $ids = array_slice($ids, 0, $limit);
1500             }
1501         }
1502
1503         return Notice::getStreamByIds($ids);
1504     }
1505
1506     function _repeatStreamDirect($limit)
1507     {
1508         $notice = new Notice();
1509
1510         $notice->selectAdd(); // clears it
1511         $notice->selectAdd('id');
1512
1513         $notice->repeat_of = $this->id;
1514
1515         $notice->orderBy('created'); // NB: asc!
1516
1517         if (!is_null($offset)) {
1518             $notice->limit($offset, $limit);
1519         }
1520
1521         $ids = array();
1522
1523         if ($notice->find()) {
1524             while ($notice->fetch()) {
1525                 $ids[] = $notice->id;
1526             }
1527         }
1528
1529         $notice->free();
1530         $notice = NULL;
1531
1532         return $ids;
1533     }
1534 }