]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - classes/Notice.php
0f2006e14394b12b19c2e1de286461bfd4707ecb
[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  * @copyright 2009 Free Software Foundation, Inc http://www.fsf.org
33  * @license  GNU Affero General Public License http://www.gnu.org/licenses/
34  */
35
36 if (!defined('STATUSNET') && !defined('LACONICA')) {
37     exit(1);
38 }
39
40 /**
41  * Table Definition for notice
42  */
43 require_once INSTALLDIR.'/classes/Memcached_DataObject.php';
44
45 /* We keep 200 notices, the max number of notices available per API request,
46  * in the memcached cache. */
47
48 define('NOTICE_CACHE_WINDOW', CachingNoticeStream::CACHE_WINDOW);
49
50 define('MAX_BOXCARS', 128);
51
52 class Notice extends Memcached_DataObject
53 {
54     ###START_AUTOCODE
55     /* the code below is auto generated do not remove the above tag */
56
57     public $__table = 'notice';                          // table name
58     public $id;                              // int(4)  primary_key not_null
59     public $profile_id;                      // int(4)  multiple_key not_null
60     public $uri;                             // varchar(255)  unique_key
61     public $content;                         // text
62     public $rendered;                        // text
63     public $url;                             // varchar(255)
64     public $created;                         // datetime  multiple_key not_null default_0000-00-00%2000%3A00%3A00
65     public $modified;                        // timestamp   not_null default_CURRENT_TIMESTAMP
66     public $reply_to;                        // int(4)
67     public $is_local;                        // int(4)
68     public $source;                          // varchar(32)
69     public $conversation;                    // int(4)
70     public $lat;                             // decimal(10,7)
71     public $lon;                             // decimal(10,7)
72     public $location_id;                     // int(4)
73     public $location_ns;                     // int(4)
74     public $repeat_of;                       // int(4)
75     public $object_type;                     // varchar(255)
76     public $scope;                           // int(4)
77
78     /* Static get */
79     function staticGet($k,$v=NULL)
80     {
81         return Memcached_DataObject::staticGet('Notice',$k,$v);
82     }
83
84     /* the code above is auto generated do not remove the tag below */
85     ###END_AUTOCODE
86
87     /* Notice types */
88     const LOCAL_PUBLIC    =  1;
89     const REMOTE_OMB      =  0;
90     const LOCAL_NONPUBLIC = -1;
91     const GATEWAY         = -2;
92
93     const PUBLIC_SCOPE    = 0; // Useful fake constant
94     const SITE_SCOPE      = 1;
95     const ADDRESSEE_SCOPE = 2;
96     const GROUP_SCOPE     = 4;
97     const FOLLOWER_SCOPE  = 8;
98
99     protected $_profile = -1;
100
101     function getProfile()
102     {
103         if (is_int($this->_profile) && $this->_profile == -1) {
104             $this->_profile = Profile::staticGet('id', $this->profile_id);
105
106             if (empty($this->_profile)) {
107                 // TRANS: Server exception thrown when a user profile for a notice cannot be found.
108                 // TRANS: %1$d is a profile ID (number), %2$d is a notice ID (number).
109                 throw new ServerException(sprintf(_('No such profile (%1$d) for notice (%2$d).'), $this->profile_id, $this->id));
110             }
111         }
112
113         return $this->_profile;
114     }
115
116     function delete()
117     {
118         // For auditing purposes, save a record that the notice
119         // was deleted.
120
121         // @fixme we have some cases where things get re-run and so the
122         // insert fails.
123         $deleted = Deleted_notice::staticGet('id', $this->id);
124
125         if (!$deleted) {
126             $deleted = Deleted_notice::staticGet('uri', $this->uri);
127         }
128
129         if (!$deleted) {
130             $deleted = new Deleted_notice();
131
132             $deleted->id         = $this->id;
133             $deleted->profile_id = $this->profile_id;
134             $deleted->uri        = $this->uri;
135             $deleted->created    = $this->created;
136             $deleted->deleted    = common_sql_now();
137
138             $deleted->insert();
139         }
140
141         if (Event::handle('NoticeDeleteRelated', array($this))) {
142
143             // Clear related records
144
145             $this->clearReplies();
146             $this->clearRepeats();
147             $this->clearFaves();
148             $this->clearTags();
149             $this->clearGroupInboxes();
150             $this->clearFiles();
151
152             // NOTE: we don't clear inboxes
153             // NOTE: we don't clear queue items
154         }
155
156         $result = parent::delete();
157
158         $this->blowOnDelete();
159         return $result;
160     }
161
162     /**
163      * Extract #hashtags from this notice's content and save them to the database.
164      */
165     function saveTags()
166     {
167         /* extract all #hastags */
168         $count = preg_match_all('/(?:^|\s)#([\pL\pN_\-\.]{1,64})/u', strtolower($this->content), $match);
169         if (!$count) {
170             return true;
171         }
172
173         /* Add them to the database */
174         return $this->saveKnownTags($match[1]);
175     }
176
177     /**
178      * Record the given set of hash tags in the db for this notice.
179      * Given tag strings will be normalized and checked for dupes.
180      */
181     function saveKnownTags($hashtags)
182     {
183         //turn each into their canonical tag
184         //this is needed to remove dupes before saving e.g. #hash.tag = #hashtag
185         for($i=0; $i<count($hashtags); $i++) {
186             /* elide characters we don't want in the tag */
187             $hashtags[$i] = common_canonical_tag($hashtags[$i]);
188         }
189
190         foreach(array_unique($hashtags) as $hashtag) {
191             $this->saveTag($hashtag);
192             self::blow('profile:notice_ids_tagged:%d:%s', $this->profile_id, $hashtag);
193         }
194         return true;
195     }
196
197     /**
198      * Record a single hash tag as associated with this notice.
199      * Tag format and uniqueness must be validated by caller.
200      */
201     function saveTag($hashtag)
202     {
203         $tag = new Notice_tag();
204         $tag->notice_id = $this->id;
205         $tag->tag = $hashtag;
206         $tag->created = $this->created;
207         $id = $tag->insert();
208
209         if (!$id) {
210             // TRANS: Server exception. %s are the error details.
211             throw new ServerException(sprintf(_('Database error inserting hashtag: %s.'),
212                                               $last_error->message));
213             return;
214         }
215
216         // if it's saved, blow its cache
217         $tag->blowCache(false);
218     }
219
220     /**
221      * Save a new notice and push it out to subscribers' inboxes.
222      * Poster's permissions are checked before sending.
223      *
224      * @param int $profile_id Profile ID of the poster
225      * @param string $content source message text; links may be shortened
226      *                        per current user's preference
227      * @param string $source source key ('web', 'api', etc)
228      * @param array $options Associative array of optional properties:
229      *              string 'created' timestamp of notice; defaults to now
230      *              int 'is_local' source/gateway ID, one of:
231      *                  Notice::LOCAL_PUBLIC    - Local, ok to appear in public timeline
232      *                  Notice::REMOTE_OMB      - Sent from a remote OMB service;
233      *                                            hide from public timeline but show in
234      *                                            local "and friends" timelines
235      *                  Notice::LOCAL_NONPUBLIC - Local, but hide from public timeline
236      *                  Notice::GATEWAY         - From another non-OMB service;
237      *                                            will not appear in public views
238      *              float 'lat' decimal latitude for geolocation
239      *              float 'lon' decimal longitude for geolocation
240      *              int 'location_id' geoname identifier
241      *              int 'location_ns' geoname namespace to interpret location_id
242      *              int 'reply_to'; notice ID this is a reply to
243      *              int 'repeat_of'; notice ID this is a repeat of
244      *              string 'uri' unique ID for notice; defaults to local notice URL
245      *              string 'url' permalink to notice; defaults to local notice URL
246      *              string 'rendered' rendered HTML version of content
247      *              array 'replies' list of profile URIs for reply delivery in
248      *                              place of extracting @-replies from content.
249      *              array 'groups' list of group IDs to deliver to, in place of
250      *                              extracting ! tags from content
251      *              array 'tags' list of hashtag strings to save with the notice
252      *                           in place of extracting # tags from content
253      *              array 'urls' list of attached/referred URLs to save with the
254      *                           notice in place of extracting links from content
255      *              boolean 'distribute' whether to distribute the notice, default true
256      *              string 'object_type' URL of the associated object type (default ActivityObject::NOTE)
257      *              int 'scope' Scope bitmask; default to SITE_SCOPE on private sites, 0 otherwise
258      *
259      * @fixme tag override
260      *
261      * @return Notice
262      * @throws ClientException
263      */
264     static function saveNew($profile_id, $content, $source, $options=null) {
265         $defaults = array('uri' => null,
266                           'url' => null,
267                           'reply_to' => null,
268                           'repeat_of' => null,
269                           'scope' => null,
270                           'distribute' => true);
271
272         if (!empty($options)) {
273             $options = $options + $defaults;
274             extract($options);
275         } else {
276             extract($defaults);
277         }
278
279         if (!isset($is_local)) {
280             $is_local = Notice::LOCAL_PUBLIC;
281         }
282
283         $profile = Profile::staticGet('id', $profile_id);
284         $user = User::staticGet('id', $profile_id);
285         if ($user) {
286             // Use the local user's shortening preferences, if applicable.
287             $final = $user->shortenLinks($content);
288         } else {
289             $final = common_shorten_links($content);
290         }
291
292         if (Notice::contentTooLong($final)) {
293             // TRANS: Client exception thrown if a notice contains too many characters.
294             throw new ClientException(_('Problem saving notice. Too long.'));
295         }
296
297         if (empty($profile)) {
298             // TRANS: Client exception thrown when trying to save a notice for an unknown user.
299             throw new ClientException(_('Problem saving notice. Unknown user.'));
300         }
301
302         if (common_config('throttle', 'enabled') && !Notice::checkEditThrottle($profile_id)) {
303             common_log(LOG_WARNING, 'Excessive posting by profile #' . $profile_id . '; throttled.');
304             // TRANS: Client exception thrown when a user tries to post too many notices in a given time frame.
305             throw new ClientException(_('Too many notices too fast; take a breather '.
306                                         'and post again in a few minutes.'));
307         }
308
309         if (common_config('site', 'dupelimit') > 0 && !Notice::checkDupes($profile_id, $final)) {
310             common_log(LOG_WARNING, 'Dupe posting by profile #' . $profile_id . '; throttled.');
311             // TRANS: Client exception thrown when a user tries to post too many duplicate notices in a given time frame.
312             throw new ClientException(_('Too many duplicate messages too quickly;'.
313                                         ' take a breather and post again in a few minutes.'));
314         }
315
316         if (!$profile->hasRight(Right::NEWNOTICE)) {
317             common_log(LOG_WARNING, "Attempted post from user disallowed to post: " . $profile->nickname);
318
319             // TRANS: Client exception thrown when a user tries to post while being banned.
320             throw new ClientException(_('You are banned from posting notices on this site.'), 403);
321         }
322
323         $notice = new Notice();
324         $notice->profile_id = $profile_id;
325
326         $autosource = common_config('public', 'autosource');
327
328         // Sandboxed are non-false, but not 1, either
329
330         if (!$profile->hasRight(Right::PUBLICNOTICE) ||
331             ($source && $autosource && in_array($source, $autosource))) {
332             $notice->is_local = Notice::LOCAL_NONPUBLIC;
333         } else {
334             $notice->is_local = $is_local;
335         }
336
337         if (!empty($created)) {
338             $notice->created = $created;
339         } else {
340             $notice->created = common_sql_now();
341         }
342
343         $notice->content = $final;
344
345         $notice->source = $source;
346         $notice->uri = $uri;
347         $notice->url = $url;
348
349         // Get the groups here so we can figure out replies and such
350
351         if (!isset($groups)) {
352             $groups = self::groupsFromText($notice->content, $profile);
353         }
354
355         $reply = null;
356
357         // Handle repeat case
358
359         if (isset($repeat_of)) {
360
361             // Check for a private one
362
363             $repeat = Notice::staticGet('id', $repeat_of);
364
365             if (empty($repeat)) {
366                 // TRANS: Client exception thrown in notice when trying to repeat a missing or deleted notice.
367                 throw new ClientException(_('Cannot repeat; original notice is missing or deleted.'));
368             }
369
370             if ($profile->id == $repeat->profile_id) {
371                 // TRANS: Client error displayed when trying to repeat an own notice.
372                 throw new ClientException(_('You cannot repeat your own notice.'));
373             }
374
375             if ($repeat->scope != Notice::SITE_SCOPE &&
376                 $repeat->scope != Notice::PUBLIC_SCOPE) {
377                 // TRANS: Client error displayed when trying to repeat a non-public notice.
378                 throw new ClientException(_('Cannot repeat a private notice.'), 403);
379             }
380
381             if (!$repeat->inScope($profile)) {
382                 // The generic checks above should cover this, but let's be sure!
383                 // TRANS: Client error displayed when trying to repeat a notice you cannot access.
384                 throw new ClientException(_('Cannot repeat a notice you cannot read.'), 403);
385             }
386
387             if ($profile->hasRepeated($repeat->id)) {
388                 // TRANS: Client error displayed when trying to repeat an already repeated notice.
389                 throw new ClientException(_('You already repeated that notice.'));
390             }
391
392             $notice->repeat_of = $repeat_of;
393         } else {
394             $reply = self::getReplyTo($reply_to, $profile_id, $source, $final);
395
396             if (!empty($reply)) {
397
398                 if (!$reply->inScope($profile)) {
399                     // TRANS: Client error displayed when trying to reply to a notice a the target has no access to.
400                     // TRANS: %1$s is a user nickname, %2$d is a notice ID (number).
401                     throw new ClientException(sprintf(_('%1$s has no access to notice %2$d.'),
402                                                       $profile->nickname, $reply->id), 403);
403                 }
404
405                 $notice->reply_to     = $reply->id;
406                 $notice->conversation = $reply->conversation;
407
408                 // If the original is private to a group, and notice has no group specified,
409                 // make it to the same group(s)
410
411                 if (empty($groups) && ($reply->scope | Notice::GROUP_SCOPE)) {
412                     $groups = array();
413                     $replyGroups = $reply->getGroups();
414                     foreach ($replyGroups as $group) {
415                         if ($profile->isMember($group)) {
416                             $groups[] = $group->id;
417                         }
418                     }
419                 }
420
421                 // Scope set below
422             }
423         }
424
425         if (!empty($lat) && !empty($lon)) {
426             $notice->lat = $lat;
427             $notice->lon = $lon;
428         }
429
430         if (!empty($location_ns) && !empty($location_id)) {
431             $notice->location_id = $location_id;
432             $notice->location_ns = $location_ns;
433         }
434
435         if (!empty($rendered)) {
436             $notice->rendered = $rendered;
437         } else {
438             $notice->rendered = common_render_content($final, $notice);
439         }
440
441         if (empty($object_type)) {
442             $notice->object_type = (empty($notice->reply_to)) ? ActivityObject::NOTE : ActivityObject::COMMENT;
443         } else {
444             $notice->object_type = $object_type;
445         }
446
447         if (is_null($scope)) { // 0 is a valid value
448             if (!empty($reply)) {
449                 $notice->scope = $reply->scope;
450             } else {
451                 $notice->scope = common_config('notice', 'defaultscope');
452             }
453         } else {
454             $notice->scope = $scope;
455         }
456
457         // For private streams
458
459         $user = $profile->getUser();
460
461         if (!empty($user)) {
462             if ($user->private_stream &&
463                 ($notice->scope == Notice::PUBLIC_SCOPE ||
464                  $notice->scope == Notice::SITE_SCOPE)) {
465                 $notice->scope |= Notice::FOLLOWER_SCOPE;
466             }
467         }
468
469         // Force the scope for private groups
470
471         foreach ($groups as $groupId) {
472             $group = User_group::staticGet('id', $groupId);
473             if (!empty($group)) {
474                 if ($group->force_scope) {
475                     $notice->scope |= Notice::GROUP_SCOPE;
476                     break;
477                 }
478             }
479         }
480
481         if (Event::handle('StartNoticeSave', array(&$notice))) {
482
483             // XXX: some of these functions write to the DB
484
485             $id = $notice->insert();
486
487             if (!$id) {
488                 common_log_db_error($notice, 'INSERT', __FILE__);
489                 // TRANS: Server exception thrown when a notice cannot be saved.
490                 throw new ServerException(_('Problem saving notice.'));
491             }
492
493             // Update ID-dependent columns: URI, conversation
494
495             $orig = clone($notice);
496
497             $changed = false;
498
499             if (empty($uri)) {
500                 $notice->uri = common_notice_uri($notice);
501                 $changed = true;
502             }
503
504             // If it's not part of a conversation, it's
505             // the beginning of a new conversation.
506
507             if (empty($notice->conversation)) {
508                 $conv = Conversation::create();
509                 $notice->conversation = $conv->id;
510                 $changed = true;
511             }
512
513             if ($changed) {
514                 if (!$notice->update($orig)) {
515                     common_log_db_error($notice, 'UPDATE', __FILE__);
516                     // TRANS: Server exception thrown when a notice cannot be updated.
517                     throw new ServerException(_('Problem saving notice.'));
518                 }
519             }
520
521         }
522
523         // Clear the cache for subscribed users, so they'll update at next request
524         // XXX: someone clever could prepend instead of clearing the cache
525
526         $notice->blowOnInsert();
527
528         // Save per-notice metadata...
529
530         if (isset($replies)) {
531             $notice->saveKnownReplies($replies);
532         } else {
533             $notice->saveReplies();
534         }
535
536         if (isset($tags)) {
537             $notice->saveKnownTags($tags);
538         } else {
539             $notice->saveTags();
540         }
541
542         // Note: groups may save tags, so must be run after tags are saved
543         // to avoid errors on duplicates.
544         // Note: groups should always be set.
545
546         $notice->saveKnownGroups($groups);
547
548         if (isset($peopletags)) {
549             $notice->saveProfileTags($peopletags);
550         } else {
551             $notice->saveProfileTags();
552         }
553
554         if (isset($urls)) {
555             $notice->saveKnownUrls($urls);
556         } else {
557             $notice->saveUrls();
558         }
559
560         if ($distribute) {
561             // Prepare inbox delivery, may be queued to background.
562             $notice->distribute();
563         }
564
565         return $notice;
566     }
567
568     function blowOnInsert($conversation = false)
569     {
570         self::blow('profile:notice_ids:%d', $this->profile_id);
571
572         if ($this->isPublic()) {
573             self::blow('public');
574         }
575
576         // XXX: Before we were blowing the casche only if the notice id
577         // was not the root of the conversation.  What to do now?
578
579         self::blow('notice:conversation_ids:%d', $this->conversation);
580         self::blow('conversation::notice_count:%d', $this->conversation);
581
582         if (!empty($this->repeat_of)) {
583             self::blow('notice:repeats:%d', $this->repeat_of);
584         }
585
586         $original = Notice::staticGet('id', $this->repeat_of);
587
588         if (!empty($original)) {
589             $originalUser = User::staticGet('id', $original->profile_id);
590             if (!empty($originalUser)) {
591                 self::blow('user:repeats_of_me:%d', $originalUser->id);
592             }
593         }
594
595         $profile = Profile::staticGet($this->profile_id);
596         if (!empty($profile)) {
597             $profile->blowNoticeCount();
598         }
599     }
600
601     /**
602      * Clear cache entries related to this notice at delete time.
603      * Necessary to avoid breaking paging on public, profile timelines.
604      */
605     function blowOnDelete()
606     {
607         $this->blowOnInsert();
608
609         self::blow('profile:notice_ids:%d;last', $this->profile_id);
610
611         if ($this->isPublic()) {
612             self::blow('public;last');
613         }
614
615         self::blow('fave:by_notice', $this->id);
616
617         if ($this->conversation) {
618             // In case we're the first, will need to calc a new root.
619             self::blow('notice:conversation_root:%d', $this->conversation);
620         }
621     }
622
623     /** save all urls in the notice to the db
624      *
625      * follow redirects and save all available file information
626      * (mimetype, date, size, oembed, etc.)
627      *
628      * @return void
629      */
630     function saveUrls() {
631         if (common_config('attachments', 'process_links')) {
632             common_replace_urls_callback($this->content, array($this, 'saveUrl'), $this->id);
633         }
634     }
635
636     /**
637      * Save the given URLs as related links/attachments to the db
638      *
639      * follow redirects and save all available file information
640      * (mimetype, date, size, oembed, etc.)
641      *
642      * @return void
643      */
644     function saveKnownUrls($urls)
645     {
646         if (common_config('attachments', 'process_links')) {
647             // @fixme validation?
648             foreach (array_unique($urls) as $url) {
649                 File::processNew($url, $this->id);
650             }
651         }
652     }
653
654     /**
655      * @private callback
656      */
657     function saveUrl($url, $notice_id) {
658         File::processNew($url, $notice_id);
659     }
660
661     static function checkDupes($profile_id, $content) {
662         $profile = Profile::staticGet($profile_id);
663         if (empty($profile)) {
664             return false;
665         }
666         $notice = $profile->getNotices(0, CachingNoticeStream::CACHE_WINDOW);
667         if (!empty($notice)) {
668             $last = 0;
669             while ($notice->fetch()) {
670                 if (time() - strtotime($notice->created) >= common_config('site', 'dupelimit')) {
671                     return true;
672                 } else if ($notice->content == $content) {
673                     return false;
674                 }
675             }
676         }
677         // If we get here, oldest item in cache window is not
678         // old enough for dupe limit; do direct check against DB
679         $notice = new Notice();
680         $notice->profile_id = $profile_id;
681         $notice->content = $content;
682         $threshold = common_sql_date(time() - common_config('site', 'dupelimit'));
683         $notice->whereAdd(sprintf("created > '%s'", $notice->escape($threshold)));
684
685         $cnt = $notice->count();
686         return ($cnt == 0);
687     }
688
689     static function checkEditThrottle($profile_id) {
690         $profile = Profile::staticGet($profile_id);
691         if (empty($profile)) {
692             return false;
693         }
694         // Get the Nth notice
695         $notice = $profile->getNotices(common_config('throttle', 'count') - 1, 1);
696         if ($notice && $notice->fetch()) {
697             // If the Nth notice was posted less than timespan seconds ago
698             if (time() - strtotime($notice->created) <= common_config('throttle', 'timespan')) {
699                 // Then we throttle
700                 return false;
701             }
702         }
703         // Either not N notices in the stream, OR the Nth was not posted within timespan seconds
704         return true;
705     }
706
707     function getUploadedAttachment() {
708         $post = clone $this;
709         $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"';
710         $post->query($query);
711         $post->fetch();
712         if (empty($post->up) || empty($post->i)) {
713             $ret = false;
714         } else {
715             $ret = array($post->up, $post->i);
716         }
717         $post->free();
718         return $ret;
719     }
720
721     function hasAttachments() {
722         $post = clone $this;
723         $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);
724         $post->query($query);
725         $post->fetch();
726         $n_attachments = intval($post->n_attachments);
727         $post->free();
728         return $n_attachments;
729     }
730
731     function attachments() {
732
733         $keypart = sprintf('notice:file_ids:%d', $this->id);
734
735         $idstr = self::cacheGet($keypart);
736
737         if ($idstr !== false) {
738             $ids = explode(',', $idstr);
739         } else {
740             $ids = array();
741             $f2p = new File_to_post;
742             $f2p->post_id = $this->id;
743             if ($f2p->find()) {
744                 while ($f2p->fetch()) {
745                     $ids[] = $f2p->file_id;
746                 }
747             }
748             self::cacheSet($keypart, implode(',', $ids));
749         }
750
751         $att = array();
752
753         foreach ($ids as $id) {
754             $f = File::staticGet('id', $id);
755             if (!empty($f)) {
756                 $att[] = clone($f);
757             }
758         }
759
760         return $att;
761     }
762
763
764     function publicStream($offset=0, $limit=20, $since_id=0, $max_id=0)
765     {
766         $stream = new PublicNoticeStream();
767         return $stream->getNotices($offset, $limit, $since_id, $max_id);
768     }
769
770
771     function conversationStream($id, $offset=0, $limit=20, $since_id=0, $max_id=0)
772     {
773         $stream = new ConversationNoticeStream($id);
774
775         return $stream->getNotices($offset, $limit, $since_id, $max_id);
776     }
777
778     /**
779      * Is this notice part of an active conversation?
780      *
781      * @return boolean true if other messages exist in the same
782      *                 conversation, false if this is the only one
783      */
784     function hasConversation()
785     {
786         if (!empty($this->conversation)) {
787             $conversation = Notice::conversationStream(
788                 $this->conversation,
789                 1,
790                 1
791             );
792
793             if ($conversation->N > 0) {
794                 return true;
795             }
796         }
797         return false;
798     }
799
800     /**
801      * Grab the earliest notice from this conversation.
802      *
803      * @return Notice or null
804      */
805     function conversationRoot()
806     {
807         if (!empty($this->conversation)) {
808             $c = self::memcache();
809
810             $key = Cache::key('notice:conversation_root:' . $this->conversation);
811             $notice = $c->get($key);
812             if ($notice) {
813                 return $notice;
814             }
815
816             $notice = new Notice();
817             $notice->conversation = $this->conversation;
818             $notice->orderBy('CREATED');
819             $notice->limit(1);
820             $notice->find(true);
821
822             if ($notice->N) {
823                 $c->set($key, $notice);
824                 return $notice;
825             }
826         }
827         return null;
828     }
829     /**
830      * Pull up a full list of local recipients who will be getting
831      * this notice in their inbox. Results will be cached, so don't
832      * change the input data wily-nilly!
833      *
834      * @param array $groups optional list of Group objects;
835      *              if left empty, will be loaded from group_inbox records
836      * @param array $recipient optional list of reply profile ids
837      *              if left empty, will be loaded from reply records
838      * @return array associating recipient user IDs with an inbox source constant
839      */
840     function whoGets($groups=null, $recipients=null)
841     {
842         $c = self::memcache();
843
844         if (!empty($c)) {
845             $ni = $c->get(Cache::key('notice:who_gets:'.$this->id));
846             if ($ni !== false) {
847                 return $ni;
848             }
849         }
850
851         if (is_null($groups)) {
852             $groups = $this->getGroups();
853         }
854
855         if (is_null($recipients)) {
856             $recipients = $this->getReplies();
857         }
858
859         $users = $this->getSubscribedUsers();
860         $ptags = $this->getProfileTags();
861
862         // FIXME: kind of ignoring 'transitional'...
863         // we'll probably stop supporting inboxless mode
864         // in 0.9.x
865
866         $ni = array();
867
868         // Give plugins a chance to add folks in at start...
869         if (Event::handle('StartNoticeWhoGets', array($this, &$ni))) {
870
871             foreach ($users as $id) {
872                 $ni[$id] = NOTICE_INBOX_SOURCE_SUB;
873             }
874
875             foreach ($groups as $group) {
876                 $users = $group->getUserMembers();
877                 foreach ($users as $id) {
878                     if (!array_key_exists($id, $ni)) {
879                         $ni[$id] = NOTICE_INBOX_SOURCE_GROUP;
880                     }
881                 }
882             }
883
884             foreach ($ptags as $ptag) {
885                 $users = $ptag->getUserSubscribers();
886                 foreach ($users as $id) {
887                     if (!array_key_exists($id, $ni)) {
888                         $user = User::staticGet('id', $id);
889                         if (!$user->hasBlocked($profile)) {
890                             $ni[$id] = NOTICE_INBOX_SOURCE_PROFILE_TAG;
891                         }
892                     }
893                 }
894             }
895
896             foreach ($recipients as $recipient) {
897                 if (!array_key_exists($recipient, $ni)) {
898                     $ni[$recipient] = NOTICE_INBOX_SOURCE_REPLY;
899                 }
900
901                 // Exclude any deleted, non-local, or blocking recipients.
902                 $profile = $this->getProfile();
903                 $originalProfile = null;
904                 if ($this->repeat_of) {
905                     // Check blocks against the original notice's poster as well.
906                     $original = Notice::staticGet('id', $this->repeat_of);
907                     if ($original) {
908                         $originalProfile = $original->getProfile();
909                     }
910                 }
911                 foreach ($ni as $id => $source) {
912                     $user = User::staticGet('id', $id);
913                     if (empty($user) || $user->hasBlocked($profile) ||
914                         ($originalProfile && $user->hasBlocked($originalProfile))) {
915                         unset($ni[$id]);
916                     }
917                 }
918             }
919
920             // Give plugins a chance to filter out...
921             Event::handle('EndNoticeWhoGets', array($this, &$ni));
922         }
923
924         if (!empty($c)) {
925             // XXX: pack this data better
926             $c->set(Cache::key('notice:who_gets:'.$this->id), $ni);
927         }
928
929         return $ni;
930     }
931
932     /**
933      * Adds this notice to the inboxes of each local user who should receive
934      * it, based on author subscriptions, group memberships, and @-replies.
935      *
936      * Warning: running a second time currently will make items appear
937      * multiple times in users' inboxes.
938      *
939      * @fixme make more robust against errors
940      * @fixme break up massive deliveries to smaller background tasks
941      *
942      * @param array $groups optional list of Group objects;
943      *              if left empty, will be loaded from group_inbox records
944      * @param array $recipient optional list of reply profile ids
945      *              if left empty, will be loaded from reply records
946      */
947     function addToInboxes($groups=null, $recipients=null)
948     {
949         $ni = $this->whoGets($groups, $recipients);
950
951         $ids = array_keys($ni);
952
953         // We remove the author (if they're a local user),
954         // since we'll have already done this in distribute()
955
956         $i = array_search($this->profile_id, $ids);
957
958         if ($i !== false) {
959             unset($ids[$i]);
960         }
961
962         // Bulk insert
963
964         Inbox::bulkInsert($this->id, $ids);
965
966         return;
967     }
968
969     function getSubscribedUsers()
970     {
971         $user = new User();
972
973         if(common_config('db','quote_identifiers'))
974           $user_table = '"user"';
975         else $user_table = 'user';
976
977         $qry =
978           'SELECT id ' .
979           'FROM '. $user_table .' JOIN subscription '.
980           'ON '. $user_table .'.id = subscription.subscriber ' .
981           'WHERE subscription.subscribed = %d ';
982
983         $user->query(sprintf($qry, $this->profile_id));
984
985         $ids = array();
986
987         while ($user->fetch()) {
988             $ids[] = $user->id;
989         }
990
991         $user->free();
992
993         return $ids;
994     }
995
996     function getProfileTags()
997     {
998         // Don't save ptags for repeats, for now.
999
1000         if (!empty($this->repeat_of)) {
1001             return array();
1002         }
1003
1004         // XXX: cache me
1005
1006         $ptags = array();
1007
1008         $ptagi = new Profile_tag_inbox();
1009
1010         $ptagi->selectAdd();
1011         $ptagi->selectAdd('profile_tag_id');
1012
1013         $ptagi->notice_id = $this->id;
1014
1015         if ($ptagi->find()) {
1016             while ($ptagi->fetch()) {
1017                 $profile_list = Profile_list::staticGet('id', $ptagi->profile_tag_id);
1018                 if ($profile_list) {
1019                     $ptags[] = $profile_list;
1020                 }
1021             }
1022         }
1023
1024         $ptagi->free();
1025
1026         return $ptags;
1027     }
1028
1029     /**
1030      * Record this notice to the given group inboxes for delivery.
1031      * Overrides the regular parsing of !group markup.
1032      *
1033      * @param string $group_ids
1034      * @fixme might prefer URIs as identifiers, as for replies?
1035      *        best with generalizations on user_group to support
1036      *        remote groups better.
1037      */
1038     function saveKnownGroups($group_ids)
1039     {
1040         if (!is_array($group_ids)) {
1041             // TRANS: Server exception thrown when no array is provided to the method saveKnownGroups().
1042             throw new ServerException(_('Bad type provided to saveKnownGroups.'));
1043         }
1044
1045         $groups = array();
1046         foreach (array_unique($group_ids) as $id) {
1047             $group = User_group::staticGet('id', $id);
1048             if ($group) {
1049                 common_log(LOG_ERR, "Local delivery to group id $id, $group->nickname");
1050                 $result = $this->addToGroupInbox($group);
1051                 if (!$result) {
1052                     common_log_db_error($gi, 'INSERT', __FILE__);
1053                 }
1054
1055                 // we automatically add a tag for every group name, too
1056
1057                 $tag = Notice_tag::pkeyGet(array('tag' => common_canonical_tag($group->nickname),
1058                                                  'notice_id' => $this->id));
1059
1060                 if (is_null($tag)) {
1061                     $this->saveTag($group->nickname);
1062                 }
1063
1064                 $groups[] = clone($group);
1065             } else {
1066                 common_log(LOG_ERR, "Local delivery to group id $id skipped, doesn't exist");
1067             }
1068         }
1069
1070         return $groups;
1071     }
1072
1073     /**
1074      * Parse !group delivery and record targets into group_inbox.
1075      * @return array of Group objects
1076      */
1077     function saveGroups()
1078     {
1079         // Don't save groups for repeats
1080
1081         if (!empty($this->repeat_of)) {
1082             return array();
1083         }
1084
1085         $profile = $this->getProfile();
1086
1087         $groups = self::groupsFromText($this->content, $profile);
1088
1089         /* Add them to the database */
1090
1091         foreach ($groups as $group) {
1092             /* XXX: remote groups. */
1093
1094             if (empty($group)) {
1095                 continue;
1096             }
1097
1098
1099             if ($profile->isMember($group)) {
1100
1101                 $result = $this->addToGroupInbox($group);
1102
1103                 if (!$result) {
1104                     common_log_db_error($gi, 'INSERT', __FILE__);
1105                 }
1106
1107                 $groups[] = clone($group);
1108             }
1109         }
1110
1111         return $groups;
1112     }
1113
1114     function addToGroupInbox($group)
1115     {
1116         $gi = Group_inbox::pkeyGet(array('group_id' => $group->id,
1117                                          'notice_id' => $this->id));
1118
1119         if (empty($gi)) {
1120
1121             $gi = new Group_inbox();
1122
1123             $gi->group_id  = $group->id;
1124             $gi->notice_id = $this->id;
1125             $gi->created   = $this->created;
1126
1127             $result = $gi->insert();
1128
1129             if (!$result) {
1130                 common_log_db_error($gi, 'INSERT', __FILE__);
1131                 // TRANS: Server exception thrown when an update for a group inbox fails.
1132                 throw new ServerException(_('Problem saving group inbox.'));
1133             }
1134
1135             self::blow('user_group:notice_ids:%d', $gi->group_id);
1136         }
1137
1138         return true;
1139     }
1140
1141     /**
1142      * record targets into profile_tag_inbox.
1143      * @return array of Profile_list objects
1144      */
1145     function saveProfileTags($known=array())
1146     {
1147         // Don't save ptags for repeats, for now
1148
1149         if (!empty($this->repeat_of)) {
1150             return array();
1151         }
1152
1153         if (is_array($known)) {
1154             $ptags = $known;
1155         } else {
1156             $ptags = array();
1157         }
1158
1159         $ptag = new Profile_tag();
1160         $ptag->tagged = $this->profile_id;
1161
1162         if($ptag->find()) {
1163             while($ptag->fetch()) {
1164                 $plist = Profile_list::getByTaggerAndTag($ptag->tagger, $ptag->tag);
1165                 if (!empty($plist)) {
1166                     $ptags[] = clone($plist);
1167                 }
1168             }
1169         }
1170
1171         foreach ($ptags as $target) {
1172             $this->addToProfileTagInbox($target);
1173         }
1174
1175         return $ptags;
1176     }
1177
1178     function addToProfileTagInbox($plist)
1179     {
1180         $ptagi = Profile_tag_inbox::pkeyGet(array('profile_tag_id' => $plist->id,
1181                                          'notice_id' => $this->id));
1182
1183         if (empty($ptagi)) {
1184
1185             $ptagi = new Profile_tag_inbox();
1186
1187             $ptagi->query('BEGIN');
1188             $ptagi->profile_tag_id  = $plist->id;
1189             $ptagi->notice_id = $this->id;
1190             $ptagi->created   = $this->created;
1191
1192             $result = $ptagi->insert();
1193             if (!$result) {
1194                 common_log_db_error($ptagi, 'INSERT', __FILE__);
1195                 // TRANS: Server exception thrown when saving profile_tag inbox fails.
1196                 throw new ServerException(_('Problem saving profile_tag inbox.'));
1197             }
1198
1199             $ptagi->query('COMMIT');
1200
1201             self::blow('profile_tag:notice_ids:%d', $ptagi->profile_tag_id);
1202         }
1203
1204         return true;
1205     }
1206
1207     /**
1208      * Save reply records indicating that this notice needs to be
1209      * delivered to the local users with the given URIs.
1210      *
1211      * Since this is expected to be used when saving foreign-sourced
1212      * messages, we won't deliver to any remote targets as that's the
1213      * source service's responsibility.
1214      *
1215      * Mail notifications etc will be handled later.
1216      *
1217      * @param array of unique identifier URIs for recipients
1218      */
1219     function saveKnownReplies($uris)
1220     {
1221         if (empty($uris)) {
1222             return;
1223         }
1224
1225         $sender = Profile::staticGet($this->profile_id);
1226
1227         foreach (array_unique($uris) as $uri) {
1228
1229             $profile = Profile::fromURI($uri);
1230
1231             if (empty($profile)) {
1232                 common_log(LOG_WARNING, "Unable to determine profile for URI '$uri'");
1233                 continue;
1234             }
1235
1236             if ($profile->hasBlocked($sender)) {
1237                 common_log(LOG_INFO, "Not saving reply to profile {$profile->id} ($uri) from sender {$sender->id} because of a block.");
1238                 continue;
1239             }
1240
1241             $reply = new Reply();
1242
1243             $reply->notice_id  = $this->id;
1244             $reply->profile_id = $profile->id;
1245             $reply->modified   = $this->created;
1246
1247             common_log(LOG_INFO, __METHOD__ . ": saving reply: notice $this->id to profile $profile->id");
1248
1249             $id = $reply->insert();
1250         }
1251
1252         return;
1253     }
1254
1255     /**
1256      * Pull @-replies from this message's content in StatusNet markup format
1257      * and save reply records indicating that this message needs to be
1258      * delivered to those users.
1259      *
1260      * Mail notifications to local profiles will be sent later.
1261      *
1262      * @return array of integer profile IDs
1263      */
1264
1265     function saveReplies()
1266     {
1267         // Don't save reply data for repeats
1268
1269         if (!empty($this->repeat_of)) {
1270             return array();
1271         }
1272
1273         $sender = Profile::staticGet($this->profile_id);
1274
1275         // @todo ideally this parser information would only
1276         // be calculated once.
1277
1278         $mentions = common_find_mentions($this->content, $this);
1279
1280         $replied = array();
1281
1282         // store replied only for first @ (what user/notice what the reply directed,
1283         // we assume first @ is it)
1284
1285         foreach ($mentions as $mention) {
1286
1287             foreach ($mention['mentioned'] as $mentioned) {
1288
1289                 // skip if they're already covered
1290
1291                 if (!empty($replied[$mentioned->id])) {
1292                     continue;
1293                 }
1294
1295                 // Don't save replies from blocked profile to local user
1296
1297                 $mentioned_user = User::staticGet('id', $mentioned->id);
1298                 if (!empty($mentioned_user) && $mentioned_user->hasBlocked($sender)) {
1299                     continue;
1300                 }
1301
1302                 $reply = new Reply();
1303
1304                 $reply->notice_id  = $this->id;
1305                 $reply->profile_id = $mentioned->id;
1306                 $reply->modified   = $this->created;
1307
1308                 $id = $reply->insert();
1309
1310                 if (!$id) {
1311                     common_log_db_error($reply, 'INSERT', __FILE__);
1312                     // TRANS: Server exception thrown when a reply cannot be saved.
1313                     // TRANS: %1$d is a notice ID, %2$d is the ID of the mentioned user.
1314                     throw new ServerException(sprintf(_('Could not save reply for %1$d, %2$d.'), $this->id, $mentioned->id));
1315                 } else {
1316                     $replied[$mentioned->id] = 1;
1317                     self::blow('reply:stream:%d', $mentioned->id);
1318                 }
1319             }
1320         }
1321
1322         $recipientIds = array_keys($replied);
1323
1324         return $recipientIds;
1325     }
1326
1327     /**
1328      * Pull the complete list of @-reply targets for this notice.
1329      *
1330      * @return array of integer profile ids
1331      */
1332     function getReplies()
1333     {
1334         $keypart = sprintf('notice:reply_ids:%d', $this->id);
1335
1336         $idstr = self::cacheGet($keypart);
1337
1338         if ($idstr !== false) {
1339             $ids = explode(',', $idstr);
1340         } else {
1341             $ids = array();
1342
1343             $reply = new Reply();
1344             $reply->selectAdd();
1345             $reply->selectAdd('profile_id');
1346             $reply->notice_id = $this->id;
1347
1348             if ($reply->find()) {
1349                 while($reply->fetch()) {
1350                     $ids[] = $reply->profile_id;
1351                 }
1352             }
1353             self::cacheSet($keypart, implode(',', $ids));
1354         }
1355
1356         return $ids;
1357     }
1358
1359     /**
1360      * Send e-mail notifications to local @-reply targets.
1361      *
1362      * Replies must already have been saved; this is expected to be run
1363      * from the distrib queue handler.
1364      */
1365     function sendReplyNotifications()
1366     {
1367         // Don't send reply notifications for repeats
1368
1369         if (!empty($this->repeat_of)) {
1370             return array();
1371         }
1372
1373         $recipientIds = $this->getReplies();
1374
1375         foreach ($recipientIds as $recipientId) {
1376             $user = User::staticGet('id', $recipientId);
1377             if (!empty($user)) {
1378                 mail_notify_attn($user, $this);
1379             }
1380         }
1381     }
1382
1383     /**
1384      * Pull list of groups this notice needs to be delivered to,
1385      * as previously recorded by saveGroups() or saveKnownGroups().
1386      *
1387      * @return array of Group objects
1388      */
1389     function getGroups()
1390     {
1391         // Don't save groups for repeats
1392
1393         if (!empty($this->repeat_of)) {
1394             return array();
1395         }
1396
1397         $ids = array();
1398
1399         $keypart = sprintf('notice:groups:%d', $this->id);
1400
1401         $idstr = self::cacheGet($keypart);
1402
1403         if ($idstr !== false) {
1404             $ids = explode(',', $idstr);
1405         } else {
1406             $gi = new Group_inbox();
1407
1408             $gi->selectAdd();
1409             $gi->selectAdd('group_id');
1410
1411             $gi->notice_id = $this->id;
1412
1413             if ($gi->find()) {
1414                 while ($gi->fetch()) {
1415                     $ids[] = $gi->group_id;
1416                 }
1417             }
1418
1419             self::cacheSet($keypart, implode(',', $ids));
1420         }
1421
1422         $groups = array();
1423
1424         foreach ($ids as $id) {
1425             $group = User_group::staticGet('id', $id);
1426             if ($group) {
1427                 $groups[] = $group;
1428             }
1429         }
1430
1431         return $groups;
1432     }
1433
1434     /**
1435      * Convert a notice into an activity for export.
1436      *
1437      * @param User $cur Current user
1438      *
1439      * @return Activity activity object representing this Notice.
1440      */
1441
1442     function asActivity($cur)
1443     {
1444         $act = self::cacheGet(Cache::codeKey('notice:as-activity:'.$this->id));
1445
1446         if (!empty($act)) {
1447             return $act;
1448         }
1449         $act = new Activity();
1450
1451         if (Event::handle('StartNoticeAsActivity', array($this, &$act))) {
1452
1453             $profile = $this->getProfile();
1454
1455             $act->actor            = ActivityObject::fromProfile($profile);
1456             $act->actor->extra[]   = $profile->profileInfo($cur);
1457             $act->verb             = ActivityVerb::POST;
1458             $act->objects[]        = ActivityObject::fromNotice($this);
1459
1460             // XXX: should this be handled by default processing for object entry?
1461
1462             $act->time    = strtotime($this->created);
1463             $act->link    = $this->bestUrl();
1464
1465             $act->content = common_xml_safe_str($this->rendered);
1466             $act->id      = $this->uri;
1467             $act->title   = common_xml_safe_str($this->content);
1468
1469             // Categories
1470
1471             $tags = $this->getTags();
1472
1473             foreach ($tags as $tag) {
1474                 $cat       = new AtomCategory();
1475                 $cat->term = $tag;
1476
1477                 $act->categories[] = $cat;
1478             }
1479
1480             // Enclosures
1481             // XXX: use Atom Media and/or File activity objects instead
1482
1483             $attachments = $this->attachments();
1484
1485             foreach ($attachments as $attachment) {
1486                 $enclosure = $attachment->getEnclosure();
1487                 if ($enclosure) {
1488                     $act->enclosures[] = $enclosure;
1489                 }
1490             }
1491
1492             $ctx = new ActivityContext();
1493
1494             if (!empty($this->reply_to)) {
1495                 $reply = Notice::staticGet('id', $this->reply_to);
1496                 if (!empty($reply)) {
1497                     $ctx->replyToID  = $reply->uri;
1498                     $ctx->replyToUrl = $reply->bestUrl();
1499                 }
1500             }
1501
1502             $ctx->location = $this->getLocation();
1503
1504             $conv = null;
1505
1506             if (!empty($this->conversation)) {
1507                 $conv = Conversation::staticGet('id', $this->conversation);
1508                 if (!empty($conv)) {
1509                     $ctx->conversation = $conv->uri;
1510                 }
1511             }
1512
1513             $reply_ids = $this->getReplies();
1514
1515             foreach ($reply_ids as $id) {
1516                 $rprofile = Profile::staticGet('id', $id);
1517                 if (!empty($rprofile)) {
1518                     $ctx->attention[] = $rprofile->getUri();
1519                 }
1520             }
1521
1522             $groups = $this->getGroups();
1523
1524             foreach ($groups as $group) {
1525                 $ctx->attention[] = $group->getUri();
1526             }
1527
1528             // XXX: deprecated; use ActivityVerb::SHARE instead
1529
1530             $repeat = null;
1531
1532             if (!empty($this->repeat_of)) {
1533                 $repeat = Notice::staticGet('id', $this->repeat_of);
1534                 $ctx->forwardID  = $repeat->uri;
1535                 $ctx->forwardUrl = $repeat->bestUrl();
1536             }
1537
1538             $act->context = $ctx;
1539
1540             // Source
1541
1542             $atom_feed = $profile->getAtomFeed();
1543
1544             if (!empty($atom_feed)) {
1545
1546                 $act->source = new ActivitySource();
1547
1548                 // XXX: we should store the actual feed ID
1549
1550                 $act->source->id = $atom_feed;
1551
1552                 // XXX: we should store the actual feed title
1553
1554                 $act->source->title = $profile->getBestName();
1555
1556                 $act->source->links['alternate'] = $profile->profileurl;
1557                 $act->source->links['self']      = $atom_feed;
1558
1559                 $act->source->icon = $profile->avatarUrl(AVATAR_PROFILE_SIZE);
1560
1561                 $notice = $profile->getCurrentNotice();
1562
1563                 if (!empty($notice)) {
1564                     $act->source->updated = self::utcDate($notice->created);
1565                 }
1566
1567                 $user = User::staticGet('id', $profile->id);
1568
1569                 if (!empty($user)) {
1570                     $act->source->links['license'] = common_config('license', 'url');
1571                 }
1572             }
1573
1574             if ($this->isLocal()) {
1575                 $act->selfLink = common_local_url('ApiStatusesShow', array('id' => $this->id,
1576                                                                            'format' => 'atom'));
1577                 $act->editLink = $act->selfLink;
1578             }
1579
1580             Event::handle('EndNoticeAsActivity', array($this, &$act));
1581         }
1582
1583         self::cacheSet(Cache::codeKey('notice:as-activity:'.$this->id), $act);
1584
1585         return $act;
1586     }
1587
1588     // This has gotten way too long. Needs to be sliced up into functional bits
1589     // or ideally exported to a utility class.
1590
1591     function asAtomEntry($namespace=false,
1592                          $source=false,
1593                          $author=true,
1594                          $cur=null)
1595     {
1596         $act = $this->asActivity($cur);
1597         $act->extra[] = $this->noticeInfo($cur);
1598         return $act->asString($namespace, $author, $source);
1599     }
1600
1601     /**
1602      * Extra notice info for atom entries
1603      *
1604      * Clients use some extra notice info in the atom stream.
1605      * This gives it to them.
1606      *
1607      * @param User $cur Current user
1608      *
1609      * @return array representation of <statusnet:notice_info> element
1610      */
1611
1612     function noticeInfo($cur)
1613     {
1614         // local notice ID (useful to clients for ordering)
1615
1616         $noticeInfoAttr = array('local_id' => $this->id);
1617
1618         // notice source
1619
1620         $ns = $this->getSource();
1621
1622         if (!empty($ns)) {
1623             $noticeInfoAttr['source'] =  $ns->code;
1624             if (!empty($ns->url)) {
1625                 $noticeInfoAttr['source_link'] = $ns->url;
1626                 if (!empty($ns->name)) {
1627                     $noticeInfoAttr['source'] =  '<a href="'
1628                         . htmlspecialchars($ns->url)
1629                         . '" rel="nofollow">'
1630                         . htmlspecialchars($ns->name)
1631                         . '</a>';
1632                 }
1633             }
1634         }
1635
1636         // favorite and repeated
1637
1638         if (!empty($cur)) {
1639             $noticeInfoAttr['favorite'] = ($cur->hasFave($this)) ? "true" : "false";
1640             $cp = $cur->getProfile();
1641             $noticeInfoAttr['repeated'] = ($cp->hasRepeated($this->id)) ? "true" : "false";
1642         }
1643
1644         if (!empty($this->repeat_of)) {
1645             $noticeInfoAttr['repeat_of'] = $this->repeat_of;
1646         }
1647
1648         return array('statusnet:notice_info', $noticeInfoAttr, null);
1649     }
1650
1651     /**
1652      * Returns an XML string fragment with a reference to a notice as an
1653      * Activity Streams noun object with the given element type.
1654      *
1655      * Assumes that 'activity' namespace has been previously defined.
1656      *
1657      * @param string $element one of 'subject', 'object', 'target'
1658      * @return string
1659      */
1660
1661     function asActivityNoun($element)
1662     {
1663         $noun = ActivityObject::fromNotice($this);
1664         return $noun->asString('activity:' . $element);
1665     }
1666
1667     function bestUrl()
1668     {
1669         if (!empty($this->url)) {
1670             return $this->url;
1671         } else if (!empty($this->uri) && preg_match('/^https?:/', $this->uri)) {
1672             return $this->uri;
1673         } else {
1674             return common_local_url('shownotice',
1675                                     array('notice' => $this->id));
1676         }
1677     }
1678
1679
1680     /**
1681      * Determine which notice, if any, a new notice is in reply to.
1682      *
1683      * For conversation tracking, we try to see where this notice fits
1684      * in the tree. Rough algorithm is:
1685      *
1686      * if (reply_to is set and valid) {
1687      *     return reply_to;
1688      * } else if ((source not API or Web) and (content starts with "T NAME" or "@name ")) {
1689      *     return ID of last notice by initial @name in content;
1690      * }
1691      *
1692      * Note that all @nickname instances will still be used to save "reply" records,
1693      * so the notice shows up in the mentioned users' "replies" tab.
1694      *
1695      * @param integer $reply_to   ID passed in by Web or API
1696      * @param integer $profile_id ID of author
1697      * @param string  $source     Source tag, like 'web' or 'gwibber'
1698      * @param string  $content    Final notice content
1699      *
1700      * @return integer ID of replied-to notice, or null for not a reply.
1701      */
1702
1703     static function getReplyTo($reply_to, $profile_id, $source, $content)
1704     {
1705         static $lb = array('xmpp', 'mail', 'sms', 'omb');
1706
1707         // If $reply_to is specified, we check that it exists, and then
1708         // return it if it does
1709
1710         if (!empty($reply_to)) {
1711             $reply_notice = Notice::staticGet('id', $reply_to);
1712             if (!empty($reply_notice)) {
1713                 return $reply_notice;
1714             }
1715         }
1716
1717         // If it's not a "low bandwidth" source (one where you can't set
1718         // a reply_to argument), we return. This is mostly web and API
1719         // clients.
1720
1721         if (!in_array($source, $lb)) {
1722             return null;
1723         }
1724
1725         // Is there an initial @ or T?
1726
1727         if (preg_match('/^T ([A-Z0-9]{1,64}) /', $content, $match) ||
1728             preg_match('/^@([a-z0-9]{1,64})\s+/', $content, $match)) {
1729             $nickname = common_canonical_nickname($match[1]);
1730         } else {
1731             return null;
1732         }
1733
1734         // Figure out who that is.
1735
1736         $sender = Profile::staticGet('id', $profile_id);
1737         if (empty($sender)) {
1738             return null;
1739         }
1740
1741         $recipient = common_relative_profile($sender, $nickname, common_sql_now());
1742
1743         if (empty($recipient)) {
1744             return null;
1745         }
1746
1747         // Get their last notice
1748
1749         $last = $recipient->getCurrentNotice();
1750
1751         if (!empty($last)) {
1752             return $last;
1753         }
1754
1755         return null;
1756     }
1757
1758     static function maxContent()
1759     {
1760         $contentlimit = common_config('notice', 'contentlimit');
1761         // null => use global limit (distinct from 0!)
1762         if (is_null($contentlimit)) {
1763             $contentlimit = common_config('site', 'textlimit');
1764         }
1765         return $contentlimit;
1766     }
1767
1768     static function contentTooLong($content)
1769     {
1770         $contentlimit = self::maxContent();
1771         return ($contentlimit > 0 && !empty($content) && (mb_strlen($content) > $contentlimit));
1772     }
1773
1774     function getLocation()
1775     {
1776         $location = null;
1777
1778         if (!empty($this->location_id) && !empty($this->location_ns)) {
1779             $location = Location::fromId($this->location_id, $this->location_ns);
1780         }
1781
1782         if (is_null($location)) { // no ID, or Location::fromId() failed
1783             if (!empty($this->lat) && !empty($this->lon)) {
1784                 $location = Location::fromLatLon($this->lat, $this->lon);
1785             }
1786         }
1787
1788         return $location;
1789     }
1790
1791     /**
1792      * Convenience function for posting a repeat of an existing message.
1793      *
1794      * @param int $repeater_id: profile ID of user doing the repeat
1795      * @param string $source: posting source key, eg 'web', 'api', etc
1796      * @return Notice
1797      *
1798      * @throws Exception on failure or permission problems
1799      */
1800     function repeat($repeater_id, $source)
1801     {
1802         $author = Profile::staticGet('id', $this->profile_id);
1803
1804         // TRANS: Message used to repeat a notice. RT is the abbreviation of 'retweet'.
1805         // TRANS: %1$s is the repeated user's name, %2$s is the repeated notice.
1806         $content = sprintf(_('RT @%1$s %2$s'),
1807                            $author->nickname,
1808                            $this->content);
1809
1810         $maxlen = common_config('site', 'textlimit');
1811         if ($maxlen > 0 && mb_strlen($content) > $maxlen) {
1812             // Web interface and current Twitter API clients will
1813             // pull the original notice's text, but some older
1814             // clients and RSS/Atom feeds will see this trimmed text.
1815             //
1816             // Unfortunately this is likely to lose tags or URLs
1817             // at the end of long notices.
1818             $content = mb_substr($content, 0, $maxlen - 4) . ' ...';
1819         }
1820
1821         // Scope is same as this one's
1822
1823         return self::saveNew($repeater_id,
1824                              $content,
1825                              $source,
1826                              array('repeat_of' => $this->id,
1827                                    'scope' => $this->scope));
1828     }
1829
1830     // These are supposed to be in chron order!
1831
1832     function repeatStream($limit=100)
1833     {
1834         $cache = Cache::instance();
1835
1836         if (empty($cache)) {
1837             $ids = $this->_repeatStreamDirect($limit);
1838         } else {
1839             $idstr = $cache->get(Cache::key('notice:repeats:'.$this->id));
1840             if ($idstr !== false) {
1841                 $ids = explode(',', $idstr);
1842             } else {
1843                 $ids = $this->_repeatStreamDirect(100);
1844                 $cache->set(Cache::key('notice:repeats:'.$this->id), implode(',', $ids));
1845             }
1846             if ($limit < 100) {
1847                 // We do a max of 100, so slice down to limit
1848                 $ids = array_slice($ids, 0, $limit);
1849             }
1850         }
1851
1852         return NoticeStream::getStreamByIds($ids);
1853     }
1854
1855     function _repeatStreamDirect($limit)
1856     {
1857         $notice = new Notice();
1858
1859         $notice->selectAdd(); // clears it
1860         $notice->selectAdd('id');
1861
1862         $notice->repeat_of = $this->id;
1863
1864         $notice->orderBy('created, id'); // NB: asc!
1865
1866         if (!is_null($limit)) {
1867             $notice->limit(0, $limit);
1868         }
1869
1870         $ids = array();
1871
1872         if ($notice->find()) {
1873             while ($notice->fetch()) {
1874                 $ids[] = $notice->id;
1875             }
1876         }
1877
1878         $notice->free();
1879         $notice = NULL;
1880
1881         return $ids;
1882     }
1883
1884     function locationOptions($lat, $lon, $location_id, $location_ns, $profile = null)
1885     {
1886         $options = array();
1887
1888         if (!empty($location_id) && !empty($location_ns)) {
1889             $options['location_id'] = $location_id;
1890             $options['location_ns'] = $location_ns;
1891
1892             $location = Location::fromId($location_id, $location_ns);
1893
1894             if (!empty($location)) {
1895                 $options['lat'] = $location->lat;
1896                 $options['lon'] = $location->lon;
1897             }
1898
1899         } else if (!empty($lat) && !empty($lon)) {
1900             $options['lat'] = $lat;
1901             $options['lon'] = $lon;
1902
1903             $location = Location::fromLatLon($lat, $lon);
1904
1905             if (!empty($location)) {
1906                 $options['location_id'] = $location->location_id;
1907                 $options['location_ns'] = $location->location_ns;
1908             }
1909         } else if (!empty($profile)) {
1910             if (isset($profile->lat) && isset($profile->lon)) {
1911                 $options['lat'] = $profile->lat;
1912                 $options['lon'] = $profile->lon;
1913             }
1914
1915             if (isset($profile->location_id) && isset($profile->location_ns)) {
1916                 $options['location_id'] = $profile->location_id;
1917                 $options['location_ns'] = $profile->location_ns;
1918             }
1919         }
1920
1921         return $options;
1922     }
1923
1924     function clearReplies()
1925     {
1926         $replyNotice = new Notice();
1927         $replyNotice->reply_to = $this->id;
1928
1929         //Null any notices that are replies to this notice
1930
1931         if ($replyNotice->find()) {
1932             while ($replyNotice->fetch()) {
1933                 $orig = clone($replyNotice);
1934                 $replyNotice->reply_to = null;
1935                 $replyNotice->update($orig);
1936             }
1937         }
1938
1939         // Reply records
1940
1941         $reply = new Reply();
1942         $reply->notice_id = $this->id;
1943
1944         if ($reply->find()) {
1945             while($reply->fetch()) {
1946                 self::blow('reply:stream:%d', $reply->profile_id);
1947                 $reply->delete();
1948             }
1949         }
1950
1951         $reply->free();
1952     }
1953
1954     function clearFiles()
1955     {
1956         $f2p = new File_to_post();
1957
1958         $f2p->post_id = $this->id;
1959
1960         if ($f2p->find()) {
1961             while ($f2p->fetch()) {
1962                 $f2p->delete();
1963             }
1964         }
1965         // FIXME: decide whether to delete File objects
1966         // ...and related (actual) files
1967     }
1968
1969     function clearRepeats()
1970     {
1971         $repeatNotice = new Notice();
1972         $repeatNotice->repeat_of = $this->id;
1973
1974         //Null any notices that are repeats of this notice
1975
1976         if ($repeatNotice->find()) {
1977             while ($repeatNotice->fetch()) {
1978                 $orig = clone($repeatNotice);
1979                 $repeatNotice->repeat_of = null;
1980                 $repeatNotice->update($orig);
1981             }
1982         }
1983     }
1984
1985     function clearFaves()
1986     {
1987         $fave = new Fave();
1988         $fave->notice_id = $this->id;
1989
1990         if ($fave->find()) {
1991             while ($fave->fetch()) {
1992                 self::blow('fave:ids_by_user_own:%d', $fave->user_id);
1993                 self::blow('fave:ids_by_user_own:%d;last', $fave->user_id);
1994                 self::blow('fave:ids_by_user:%d', $fave->user_id);
1995                 self::blow('fave:ids_by_user:%d;last', $fave->user_id);
1996                 $fave->delete();
1997             }
1998         }
1999
2000         $fave->free();
2001     }
2002
2003     function clearTags()
2004     {
2005         $tag = new Notice_tag();
2006         $tag->notice_id = $this->id;
2007
2008         if ($tag->find()) {
2009             while ($tag->fetch()) {
2010                 self::blow('profile:notice_ids_tagged:%d:%s', $this->profile_id, Cache::keyize($tag->tag));
2011                 self::blow('profile:notice_ids_tagged:%d:%s;last', $this->profile_id, Cache::keyize($tag->tag));
2012                 self::blow('notice_tag:notice_ids:%s', Cache::keyize($tag->tag));
2013                 self::blow('notice_tag:notice_ids:%s;last', Cache::keyize($tag->tag));
2014                 $tag->delete();
2015             }
2016         }
2017
2018         $tag->free();
2019     }
2020
2021     function clearGroupInboxes()
2022     {
2023         $gi = new Group_inbox();
2024
2025         $gi->notice_id = $this->id;
2026
2027         if ($gi->find()) {
2028             while ($gi->fetch()) {
2029                 self::blow('user_group:notice_ids:%d', $gi->group_id);
2030                 $gi->delete();
2031             }
2032         }
2033
2034         $gi->free();
2035     }
2036
2037     function distribute()
2038     {
2039         // We always insert for the author so they don't
2040         // have to wait
2041         Event::handle('StartNoticeDistribute', array($this));
2042
2043         $user = User::staticGet('id', $this->profile_id);
2044         if (!empty($user)) {
2045             Inbox::insertNotice($user->id, $this->id);
2046         }
2047
2048         if (common_config('queue', 'inboxes')) {
2049             // If there's a failure, we want to _force_
2050             // distribution at this point.
2051             try {
2052                 $qm = QueueManager::get();
2053                 $qm->enqueue($this, 'distrib');
2054             } catch (Exception $e) {
2055                 // If the exception isn't transient, this
2056                 // may throw more exceptions as DQH does
2057                 // its own enqueueing. So, we ignore them!
2058                 try {
2059                     $handler = new DistribQueueHandler();
2060                     $handler->handle($this);
2061                 } catch (Exception $e) {
2062                     common_log(LOG_ERR, "emergency redistribution resulted in " . $e->getMessage());
2063                 }
2064                 // Re-throw so somebody smarter can handle it.
2065                 throw $e;
2066             }
2067         } else {
2068             $handler = new DistribQueueHandler();
2069             $handler->handle($this);
2070         }
2071     }
2072
2073     function insert()
2074     {
2075         $result = parent::insert();
2076
2077         if ($result) {
2078             // Profile::hasRepeated() abuses pkeyGet(), so we
2079             // have to clear manually
2080             if (!empty($this->repeat_of)) {
2081                 $c = self::memcache();
2082                 if (!empty($c)) {
2083                     $ck = self::multicacheKey('Notice',
2084                                               array('profile_id' => $this->profile_id,
2085                                                     'repeat_of' => $this->repeat_of));
2086                     $c->delete($ck);
2087                 }
2088             }
2089         }
2090
2091         return $result;
2092     }
2093
2094     /**
2095      * Get the source of the notice
2096      *
2097      * @return Notice_source $ns A notice source object. 'code' is the only attribute
2098      *                           guaranteed to be populated.
2099      */
2100     function getSource()
2101     {
2102         $ns = new Notice_source();
2103         if (!empty($this->source)) {
2104             switch ($this->source) {
2105             case 'web':
2106             case 'xmpp':
2107             case 'mail':
2108             case 'omb':
2109             case 'system':
2110             case 'api':
2111                 $ns->code = $this->source;
2112                 break;
2113             default:
2114                 $ns = Notice_source::staticGet($this->source);
2115                 if (!$ns) {
2116                     $ns = new Notice_source();
2117                     $ns->code = $this->source;
2118                     $app = Oauth_application::staticGet('name', $this->source);
2119                     if ($app) {
2120                         $ns->name = $app->name;
2121                         $ns->url  = $app->source_url;
2122                     }
2123                 }
2124                 break;
2125             }
2126         }
2127         return $ns;
2128     }
2129
2130     /**
2131      * Determine whether the notice was locally created
2132      *
2133      * @return boolean locality
2134      */
2135
2136     public function isLocal()
2137     {
2138         return ($this->is_local == Notice::LOCAL_PUBLIC ||
2139                 $this->is_local == Notice::LOCAL_NONPUBLIC);
2140     }
2141
2142     /**
2143      * Get the list of hash tags saved with this notice.
2144      *
2145      * @return array of strings
2146      */
2147     public function getTags()
2148     {
2149         $tags = array();
2150
2151         $keypart = sprintf('notice:tags:%d', $this->id);
2152
2153         $tagstr = self::cacheGet($keypart);
2154
2155         if ($tagstr !== false) {
2156             $tags = explode(',', $tagstr);
2157         } else {
2158             $tag = new Notice_tag();
2159             $tag->notice_id = $this->id;
2160             if ($tag->find()) {
2161                 while ($tag->fetch()) {
2162                     $tags[] = $tag->tag;
2163                 }
2164             }
2165             self::cacheSet($keypart, implode(',', $tags));
2166         }
2167
2168         return $tags;
2169     }
2170
2171     static private function utcDate($dt)
2172     {
2173         $dateStr = date('d F Y H:i:s', strtotime($dt));
2174         $d = new DateTime($dateStr, new DateTimeZone('UTC'));
2175         return $d->format(DATE_W3C);
2176     }
2177
2178     /**
2179      * Look up the creation timestamp for a given notice ID, even
2180      * if it's been deleted.
2181      *
2182      * @param int $id
2183      * @return mixed string recorded creation timestamp, or false if can't be found
2184      */
2185     public static function getAsTimestamp($id)
2186     {
2187         if (!$id) {
2188             return false;
2189         }
2190
2191         $notice = Notice::staticGet('id', $id);
2192         if ($notice) {
2193             return $notice->created;
2194         }
2195
2196         $deleted = Deleted_notice::staticGet('id', $id);
2197         if ($deleted) {
2198             return $deleted->created;
2199         }
2200
2201         return false;
2202     }
2203
2204     /**
2205      * Build an SQL 'where' fragment for timestamp-based sorting from a since_id
2206      * parameter, matching notices posted after the given one (exclusive).
2207      *
2208      * If the referenced notice can't be found, will return false.
2209      *
2210      * @param int $id
2211      * @param string $idField
2212      * @param string $createdField
2213      * @return mixed string or false if no match
2214      */
2215     public static function whereSinceId($id, $idField='id', $createdField='created')
2216     {
2217         $since = Notice::getAsTimestamp($id);
2218         if ($since) {
2219             return sprintf("($createdField = '%s' and $idField > %d) or ($createdField > '%s')", $since, $id, $since);
2220         }
2221         return false;
2222     }
2223
2224     /**
2225      * Build an SQL 'where' fragment for timestamp-based sorting from a since_id
2226      * parameter, matching notices posted after the given one (exclusive), and
2227      * if necessary add it to the data object's query.
2228      *
2229      * @param DB_DataObject $obj
2230      * @param int $id
2231      * @param string $idField
2232      * @param string $createdField
2233      * @return mixed string or false if no match
2234      */
2235     public static function addWhereSinceId(DB_DataObject $obj, $id, $idField='id', $createdField='created')
2236     {
2237         $since = self::whereSinceId($id, $idField, $createdField);
2238         if ($since) {
2239             $obj->whereAdd($since);
2240         }
2241     }
2242
2243     /**
2244      * Build an SQL 'where' fragment for timestamp-based sorting from a max_id
2245      * parameter, matching notices posted before the given one (inclusive).
2246      *
2247      * If the referenced notice can't be found, will return false.
2248      *
2249      * @param int $id
2250      * @param string $idField
2251      * @param string $createdField
2252      * @return mixed string or false if no match
2253      */
2254     public static function whereMaxId($id, $idField='id', $createdField='created')
2255     {
2256         $max = Notice::getAsTimestamp($id);
2257         if ($max) {
2258             return sprintf("($createdField < '%s') or ($createdField = '%s' and $idField <= %d)", $max, $max, $id);
2259         }
2260         return false;
2261     }
2262
2263     /**
2264      * Build an SQL 'where' fragment for timestamp-based sorting from a max_id
2265      * parameter, matching notices posted before the given one (inclusive), and
2266      * if necessary add it to the data object's query.
2267      *
2268      * @param DB_DataObject $obj
2269      * @param int $id
2270      * @param string $idField
2271      * @param string $createdField
2272      * @return mixed string or false if no match
2273      */
2274     public static function addWhereMaxId(DB_DataObject $obj, $id, $idField='id', $createdField='created')
2275     {
2276         $max = self::whereMaxId($id, $idField, $createdField);
2277         if ($max) {
2278             $obj->whereAdd($max);
2279         }
2280     }
2281
2282     function isPublic()
2283     {
2284         if (common_config('public', 'localonly')) {
2285             return ($this->is_local == Notice::LOCAL_PUBLIC);
2286         } else {
2287             return (($this->is_local != Notice::LOCAL_NONPUBLIC) &&
2288                     ($this->is_local != Notice::GATEWAY));
2289         }
2290     }
2291
2292     /**
2293      * Check that the given profile is allowed to read, respond to, or otherwise
2294      * act on this notice.
2295      *
2296      * The $scope member is a bitmask of scopes, representing a logical AND of the
2297      * scope requirement. So, 0x03 (Notice::ADDRESSEE_SCOPE | Notice::SITE_SCOPE) means
2298      * "only visible to people who are mentioned in the notice AND are users on this site."
2299      * Users on the site who are not mentioned in the notice will not be able to see the
2300      * notice.
2301      *
2302      * @param Profile $profile The profile to check; pass null to check for public/unauthenticated users.
2303      *
2304      * @return boolean whether the profile is in the notice's scope
2305      */
2306     function inScope($profile)
2307     {
2308         $keypart = sprintf('notice:in-scope-for:%d:%d', $this->id, $profile->id);
2309
2310         $result = self::cacheGet($keypart);
2311
2312         if ($result === false) {
2313             $bResult = $this->_inScope($profile);
2314             $result = ($bResult) ? 1 : 0;
2315             self::cacheSet($keypart, $result, 0, 300);
2316         }
2317
2318         return ($result == 1) ? true : false;
2319     }
2320
2321     protected function _inScope($profile)
2322     {
2323         // If there's no scope, anyone (even anon) is in scope.
2324
2325         if ($this->scope == 0) {
2326             return true;
2327         }
2328
2329         // If there's scope, anon cannot be in scope
2330
2331         if (empty($profile)) {
2332             return false;
2333         }
2334
2335         // Author is always in scope
2336
2337         if ($this->profile_id == $profile->id) {
2338             return true;
2339         }
2340
2341         // Only for users on this site
2342
2343         if ($this->scope & Notice::SITE_SCOPE) {
2344             $user = $profile->getUser();
2345             if (empty($user)) {
2346                 return false;
2347             }
2348         }
2349
2350         // Only for users mentioned in the notice
2351
2352         if ($this->scope & Notice::ADDRESSEE_SCOPE) {
2353
2354             // XXX: just query for the single reply
2355
2356             $replies = $this->getReplies();
2357
2358             if (!in_array($profile->id, $replies)) {
2359                 return false;
2360             }
2361         }
2362
2363         // Only for members of the given group
2364
2365         if ($this->scope & Notice::GROUP_SCOPE) {
2366
2367             // XXX: just query for the single membership
2368
2369             $groups = $this->getGroups();
2370
2371             $foundOne = false;
2372
2373             foreach ($groups as $group) {
2374                 if ($profile->isMember($group)) {
2375                     $foundOne = true;
2376                     break;
2377                 }
2378             }
2379
2380             if (!$foundOne) {
2381                 return false;
2382             }
2383         }
2384
2385         // Only for followers of the author
2386
2387         if ($this->scope & Notice::FOLLOWER_SCOPE) {
2388             $author = $this->getProfile();
2389             if (!Subscription::exists($profile, $author)) {
2390                 return false;
2391             }
2392         }
2393
2394         return true;
2395     }
2396
2397     static function groupsFromText($text, $profile)
2398     {
2399         $groups = array();
2400
2401         /* extract all !group */
2402         $count = preg_match_all('/(?:^|\s)!(' . Nickname::DISPLAY_FMT . ')/',
2403                                 strtolower($text),
2404                                 $match);
2405
2406         if (!$count) {
2407             return $groups;
2408         }
2409
2410         foreach (array_unique($match[1]) as $nickname) {
2411             $group = User_group::getForNickname($nickname, $profile);
2412             if (!empty($group) && $profile->isMember($group)) {
2413                 $groups[] = $group->id;
2414             }
2415         }
2416
2417         return $groups;
2418     }
2419 }