PageRenderTime 61ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 1ms

/classes/Notice.php

https://bitbucket.org/petris/statusnet
PHP | 2739 lines | 1696 code | 526 blank | 517 comment | 328 complexity | 9e5dd8800cc86b00c2c9c557e340713d MD5 | raw file
Possible License(s): MIT, MPL-2.0-no-copyleft-exception, BSD-3-Clause, AGPL-3.0, GPL-2.0, LGPL-2.1 
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * StatusNet - the distributed open-source microblogging tool
    4. 

  4.  * Copyright (C) 2008-2011 StatusNet, Inc.
    5. 

  5.  *
    6. 

  6.  * This program is free software: you can redistribute it and/or modify
    7. 

  7.  * it under the terms of the GNU Affero General Public License as published by
    8. 

  8.  * the Free Software Foundation, either version 3 of the License, or
    9. 

  9.  * (at your option) any later version.
    10. 

  10.  *
    11. 

  11.  * This program is distributed in the hope that it will be useful,
    12. 

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    13. 

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.     See the
    14. 

  14.  * GNU Affero General Public License for more details.
    15. 

  15.  *
    16. 

  16.  * You should have received a copy of the GNU Affero General Public License
    17. 

  17.  * along with this program.     If not, see <http://www.gnu.org/licenses/>.
    18. 

  18.  *
    19. 

  19.  * @category Notices
    20. 

  20.  * @package  StatusNet
    21. 

  21.  * @author   Brenda Wallace <shiny@cpan.org>
    22. 

  22.  * @author   Christopher Vollick <psycotica0@gmail.com>
    23. 

  23.  * @author   CiaranG <ciaran@ciarang.com>
    24. 

  24.  * @author   Craig Andrews <candrews@integralblue.com>
    25. 

  25.  * @author   Evan Prodromou <evan@controlezvous.ca>
    26. 

  26.  * @author   Gina Haeussge <osd@foosel.net>
    27. 

  27.  * @author   Jeffery To <jeffery.to@gmail.com>
    28. 

  28.  * @author   Mike Cochrane <mikec@mikenz.geek.nz>
    29. 

  29.  * @author   Robin Millette <millette@controlyourself.ca>
    30. 

  30.  * @author   Sarven Capadisli <csarven@controlyourself.ca>
    31. 

  31.  * @author   Tom Adams <tom@holizz.com>
    32. 

  32.  * @copyright 2009 Free Software Foundation, Inc http://www.fsf.org
    33. 

  33.  * @license  GNU Affero General Public License http://www.gnu.org/licenses/
    34. 

  34.  */
    35. 

  35. 

  36. if (!defined('STATUSNET') && !defined('LACONICA')) {
    37. 

  37.     exit(1);
    38. 

  38. }
    39. 

  39. 

  40. /**
    41. 

  41.  * Table Definition for notice
    42. 

  42.  */
    43. 

  43. require_once INSTALLDIR.'/classes/Memcached_DataObject.php';
    44. 

  44. 

  45. /* We keep 200 notices, the max number of notices available per API request,
    46. 

  46.  * in the memcached cache. */
    47. 

  47. 

  48. define('NOTICE_CACHE_WINDOW', CachingNoticeStream::CACHE_WINDOW);
    49. 

  49. 

  50. define('MAX_BOXCARS', 128);
    51. 

  51. 

  52. class Notice extends Managed_DataObject
    53. 

  53. {
    54. 

  54.     ###START_AUTOCODE
    55. 

  55.     /* the code below is auto generated do not remove the above tag */
    56. 

  56. 

  57.     public $__table = 'notice';                          // table name
    58. 

  58.     public $id;                              // int(4)  primary_key not_null
    59. 

  59.     public $profile_id;                      // int(4)  multiple_key not_null
    60. 

  60.     public $uri;                             // varchar(255)  unique_key
    61. 

  61.     public $content;                         // text
    62. 

  62.     public $rendered;                        // text
    63. 

  63.     public $url;                             // varchar(255)
    64. 

  64.     public $created;                         // datetime  multiple_key not_null default_0000-00-00%2000%3A00%3A00
    65. 

  65.     public $modified;                        // timestamp   not_null default_CURRENT_TIMESTAMP
    66. 

  66.     public $reply_to;                        // int(4)
    67. 

  67.     public $is_local;                        // int(4)
    68. 

  68.     public $source;                          // varchar(32)
    69. 

  69.     public $conversation;                    // int(4)
    70. 

  70.     public $lat;                             // decimal(10,7)
    71. 

  71.     public $lon;                             // decimal(10,7)
    72. 

  72.     public $location_id;                     // int(4)
    73. 

  73.     public $location_ns;                     // int(4)
    74. 

  74.     public $repeat_of;                       // int(4)
    75. 

  75.     public $verb;                            // varchar(255)
    76. 

  76.     public $object_type;                     // varchar(255)
    77. 

  77.     public $scope;                           // int(4)
    78. 

  78. 

  79.     /* Static get */
    80. 

  80.     function staticGet($k,$v=NULL)
    81. 

  81.     {
    82. 

  82.         return Memcached_DataObject::staticGet('Notice',$k,$v);
    83. 

  83.     }
    84. 

  84. 

  85.     /* the code above is auto generated do not remove the tag below */
    86. 

  86.     ###END_AUTOCODE
    87. 

  87. 

  88.     public static function schemaDef()
    89. 

  89.     {
    90. 

  90.         $def = array(
    91. 

  91.             'fields' => array(
    92. 

  92.                 'id' => array('type' => 'serial', 'not null' => true, 'description' => 'unique identifier'),
    93. 

  93.                 'profile_id' => array('type' => 'int', 'not null' => true, 'description' => 'who made the update'),
    94. 

  94.                 'uri' => array('type' => 'varchar', 'length' => 255, 'description' => 'universally unique identifier, usually a tag URI'),
    95. 

  95.                 'content' => array('type' => 'text', 'description' => 'update content', 'collate' => 'utf8_general_ci'),
    96. 

  96.                 'rendered' => array('type' => 'text', 'description' => 'HTML version of the content'),
    97. 

  97.                 'url' => array('type' => 'varchar', 'length' => 255, 'description' => 'URL of any attachment (image, video, bookmark, whatever)'),
    98. 

  98.                 'created' => array('type' => 'datetime', 'not null' => true, 'description' => 'date this record was created'),
    99. 

  99.                 'modified' => array('type' => 'timestamp', 'not null' => true, 'description' => 'date this record was modified'),
    100. 

  100.                 'reply_to' => array('type' => 'int', 'description' => 'notice replied to (usually a guess)'),
    101. 

  101.                 'is_local' => array('type' => 'int', 'size' => 'tiny', 'default' => 0, 'description' => 'notice was generated by a user'),
    102. 

  102.                 'source' => array('type' => 'varchar', 'length' => 32, 'description' => 'source of comment, like "web", "im", or "clientname"'),
    103. 

  103.                 'conversation' => array('type' => 'int', 'description' => 'id of root notice in this conversation'),
    104. 

  104.                 'lat' => array('type' => 'numeric', 'precision' => 10, 'scale' => 7, 'description' => 'latitude'),
    105. 

  105.                 'lon' => array('type' => 'numeric', 'precision' => 10, 'scale' => 7, 'description' => 'longitude'),
    106. 

  106.                 'location_id' => array('type' => 'int', 'description' => 'location id if possible'),
    107. 

  107.                 'location_ns' => array('type' => 'int', 'description' => 'namespace for location'),
    108. 

  108.                 'repeat_of' => array('type' => 'int', 'description' => 'notice this is a repeat of'),
    109. 

  109.                 'object_type' => array('type' => 'varchar', 'length' => 255, 'description' => 'URI representing activity streams object type', 'default' => 'http://activitystrea.ms/schema/1.0/note'),
    110. 

  110.                 'verb' => array('type' => 'varchar', 'length' => 255, 'description' => 'URI representing activity streams verb', 'default' => 'http://activitystrea.ms/schema/1.0/post'),
    111. 

  111.                 'scope' => array('type' => 'int',
    112. 

  112.                                  'description' => 'bit map for distribution scope; 0 = everywhere; 1 = this server only; 2 = addressees; 4 = followers; null = default'),
    113. 

  113.             ),
    114. 

  114.             'primary key' => array('id'),
    115. 

  115.             'unique keys' => array(
    116. 

  116.                 'notice_uri_key' => array('uri'),
    117. 

  117.             ),
    118. 

  118.             'foreign keys' => array(
    119. 

  119.                 'notice_profile_id_fkey' => array('profile', array('profile_id' => 'id')),
    120. 

  120.                 'notice_reply_to_fkey' => array('notice', array('reply_to' => 'id')),
    121. 

  121.                 'notice_conversation_fkey' => array('conversation', array('conversation' => 'id')), # note... used to refer to notice.id
    122. 

  122.                 'notice_repeat_of_fkey' => array('notice', array('repeat_of' => 'id')), # @fixme: what about repeats of deleted notices?
    123. 

  123.             ),
    124. 

  124.             'indexes' => array(
    125. 

  125.                 'notice_created_id_is_local_idx' => array('created', 'id', 'is_local'),
    126. 

  126.                 'notice_profile_id_idx' => array('profile_id', 'created', 'id'),
    127. 

  127.                 'notice_repeat_of_created_id_idx' => array('repeat_of', 'created', 'id'),
    128. 

  128.                 'notice_conversation_created_id_idx' => array('conversation', 'created', 'id'),
    129. 

  129.                 'notice_replyto_idx' => array('reply_to')
    130. 

  130.             )
    131. 

  131.         );
    132. 

  132. 

  133.         if (common_config('search', 'type') == 'fulltext') {
    134. 

  134.             $def['fulltext indexes'] = array('content' => array('content'));
    135. 

  135.         }
    136. 

  136. 

  137.         return $def;
    138. 

  138.     }
    139. 

  139.     
    140. 

  140. 	function multiGet($kc, $kvs, $skipNulls=true)
    141. 

  141. 	{
    142. 

  142. 		return Memcached_DataObject::multiGet('Notice', $kc, $kvs, $skipNulls);
    143. 

  143. 	}
    144. 

  144. 	
    145. 

  145.     /* Notice types */
    146. 

  146.     const LOCAL_PUBLIC    =  1;
    147. 

  147.     const REMOTE          =  0;
    148. 

  148.     const LOCAL_NONPUBLIC = -1;
    149. 

  149.     const GATEWAY         = -2;
    150. 

  150. 

  151.     const PUBLIC_SCOPE    = 0; // Useful fake constant
    152. 

  152.     const SITE_SCOPE      = 1;
    153. 

  153.     const ADDRESSEE_SCOPE = 2;
    154. 

  154.     const GROUP_SCOPE     = 4;
    155. 

  155.     const FOLLOWER_SCOPE  = 8;
    156. 

  156. 

  157.     protected $_profile = -1;
    158. 

  158. 

  159.     function getProfile()
    160. 

  160.     {
    161. 

  161.         if (is_int($this->_profile) && $this->_profile == -1) {
    162. 

  162.             $this->_setProfile(Profile::staticGet('id', $this->profile_id));
    163. 

  163. 

  164.             if (empty($this->_profile)) {
    165. 

  165.                 // TRANS: Server exception thrown when a user profile for a notice cannot be found.
    166. 

  166.                 // TRANS: %1$d is a profile ID (number), %2$d is a notice ID (number).
    167. 

  167.                 throw new ServerException(sprintf(_('No such profile (%1$d) for notice (%2$d).'), $this->profile_id, $this->id));
    168. 

  168.             }
    169. 

  169.         }
    170. 

  170. 

  171.         return $this->_profile;
    172. 

  172.     }
    173. 

  173.     
    174. 

  174.     function _setProfile($profile)
    175. 

  175.     {
    176. 

  176.         $this->_profile = $profile;
    177. 

  177.     }
    178. 

  178. 

  179.     function delete()
    180. 

  180.     {
    181. 

  181.         // For auditing purposes, save a record that the notice
    182. 

  182.         // was deleted.
    183. 

  183. 

  184.         // @fixme we have some cases where things get re-run and so the
    185. 

  185.         // insert fails.
    186. 

  186.         $deleted = Deleted_notice::staticGet('id', $this->id);
    187. 

  187. 

  188.         if (!$deleted) {
    189. 

  189.             $deleted = Deleted_notice::staticGet('uri', $this->uri);
    190. 

  190.         }
    191. 

  191. 

  192.         if (!$deleted) {
    193. 

  193.             $deleted = new Deleted_notice();
    194. 

  194. 

  195.             $deleted->id         = $this->id;
    196. 

  196.             $deleted->profile_id = $this->profile_id;
    197. 

  197.             $deleted->uri        = $this->uri;
    198. 

  198.             $deleted->created    = $this->created;
    199. 

  199.             $deleted->deleted    = common_sql_now();
    200. 

  200. 

  201.             $deleted->insert();
    202. 

  202.         }
    203. 

  203. 

  204.         if (Event::handle('NoticeDeleteRelated', array($this))) {
    205. 

  205. 

  206.             // Clear related records
    207. 

  207. 

  208.             $this->clearReplies();
    209. 

  209.             $this->clearRepeats();
    210. 

  210.             $this->clearFaves();
    211. 

  211.             $this->clearTags();
    212. 

  212.             $this->clearGroupInboxes();
    213. 

  213.             $this->clearFiles();
    214. 

  214. 

  215.             // NOTE: we don't clear inboxes
    216. 

  216.             // NOTE: we don't clear queue items
    217. 

  217.         }
    218. 

  218. 

  219.         $result = parent::delete();
    220. 

  220. 

  221.         $this->blowOnDelete();
    222. 

  222.         return $result;
    223. 

  223.     }
    224. 

  224. 

  225.     /**
    226. 

  226.      * Extract #hashtags from this notice's content and save them to the database.
    227. 

  227.      */
    228. 

  228.     function saveTags()
    229. 

  229.     {
    230. 

  230.         /* extract all #hastags */
    231. 

  231.         $count = preg_match_all('/(?:^|\s)#([\pL\pN_\-\.]{1,64})/u', strtolower($this->content), $match);
    232. 

  232.         if (!$count) {
    233. 

  233.             return true;
    234. 

  234.         }
    235. 

  235. 

  236.         /* Add them to the database */
    237. 

  237.         return $this->saveKnownTags($match[1]);
    238. 

  238.     }
    239. 

  239. 

  240.     /**
    241. 

  241.      * Record the given set of hash tags in the db for this notice.
    242. 

  242.      * Given tag strings will be normalized and checked for dupes.
    243. 

  243.      */
    244. 

  244.     function saveKnownTags($hashtags)
    245. 

  245.     {
    246. 

  246.         //turn each into their canonical tag
    247. 

  247.         //this is needed to remove dupes before saving e.g. #hash.tag = #hashtag
    248. 

  248.         for($i=0; $i<count($hashtags); $i++) {
    249. 

  249.             /* elide characters we don't want in the tag */
    250. 

  250.             $hashtags[$i] = common_canonical_tag($hashtags[$i]);
    251. 

  251.         }
    252. 

  252. 

  253.         foreach(array_unique($hashtags) as $hashtag) {
    254. 

  254.             $this->saveTag($hashtag);
    255. 

  255.             self::blow('profile:notice_ids_tagged:%d:%s', $this->profile_id, $hashtag);
    256. 

  256.         }
    257. 

  257.         return true;
    258. 

  258.     }
    259. 

  259. 

  260.     /**
    261. 

  261.      * Record a single hash tag as associated with this notice.
    262. 

  262.      * Tag format and uniqueness must be validated by caller.
    263. 

  263.      */
    264. 

  264.     function saveTag($hashtag)
    265. 

  265.     {
    266. 

  266.         $tag = new Notice_tag();
    267. 

  267.         $tag->notice_id = $this->id;
    268. 

  268.         $tag->tag = $hashtag;
    269. 

  269.         $tag->created = $this->created;
    270. 

  270.         $id = $tag->insert();
    271. 

  271. 

  272.         if (!$id) {
    273. 

  273.             // TRANS: Server exception. %s are the error details.
    274. 

  274.             throw new ServerException(sprintf(_('Database error inserting hashtag: %s.'),
    275. 

  275.                                               $last_error->message));
    276. 

  276.             return;
    277. 

  277.         }
    278. 

  278. 

  279.         // if it's saved, blow its cache
    280. 

  280.         $tag->blowCache(false);
    281. 

  281.     }
    282. 

  282. 

  283.     /**
    284. 

  284.      * Save a new notice and push it out to subscribers' inboxes.
    285. 

  285.      * Poster's permissions are checked before sending.
    286. 

  286.      *
    287. 

  287.      * @param int $profile_id Profile ID of the poster
    288. 

  288.      * @param string $content source message text; links may be shortened
    289. 

  289.      *                        per current user's preference
    290. 

  290.      * @param string $source source key ('web', 'api', etc)
    291. 

  291.      * @param array $options Associative array of optional properties:
    292. 

  292.      *              string 'created' timestamp of notice; defaults to now
    293. 

  293.      *              int 'is_local' source/gateway ID, one of:
    294. 

  294.      *                  Notice::LOCAL_PUBLIC    - Local, ok to appear in public timeline
    295. 

  295.      *                  Notice::REMOTE          - Sent from a remote service;
    296. 

  296.      *                                            hide from public timeline but show in
    297. 

  297.      *                                            local "and friends" timelines
    298. 

  298.      *                  Notice::LOCAL_NONPUBLIC - Local, but hide from public timeline
    299. 

  299.      *                  Notice::GATEWAY         - From another non-OStatus service;
    300. 

  300.      *                                            will not appear in public views
    301. 

  301.      *              float 'lat' decimal latitude for geolocation
    302. 

  302.      *              float 'lon' decimal longitude for geolocation
    303. 

  303.      *              int 'location_id' geoname identifier
    304. 

  304.      *              int 'location_ns' geoname namespace to interpret location_id
    305. 

  305.      *              int 'reply_to'; notice ID this is a reply to
    306. 

  306.      *              int 'repeat_of'; notice ID this is a repeat of
    307. 

  307.      *              string 'uri' unique ID for notice; defaults to local notice URL
    308. 

  308.      *              string 'url' permalink to notice; defaults to local notice URL
    309. 

  309.      *              string 'rendered' rendered HTML version of content
    310. 

  310.      *              array 'replies' list of profile URIs for reply delivery in
    311. 

  311.      *                              place of extracting @-replies from content.
    312. 

  312.      *              array 'groups' list of group IDs to deliver to, in place of
    313. 

  313.      *                              extracting ! tags from content
    314. 

  314.      *              array 'tags' list of hashtag strings to save with the notice
    315. 

  315.      *                           in place of extracting # tags from content
    316. 

  316.      *              array 'urls' list of attached/referred URLs to save with the
    317. 

  317.      *                           notice in place of extracting links from content
    318. 

  318.      *              boolean 'distribute' whether to distribute the notice, default true
    319. 

  319.      *              string 'object_type' URL of the associated object type (default ActivityObject::NOTE)
    320. 

  320.      *              string 'verb' URL of the associated verb (default ActivityVerb::POST)
    321. 

  321.      *              int 'scope' Scope bitmask; default to SITE_SCOPE on private sites, 0 otherwise
    322. 

  322.      *
    323. 

  323.      * @fixme tag override
    324. 

  324.      *
    325. 

  325.      * @return Notice
    326. 

  326.      * @throws ClientException
    327. 

  327.      */
    328. 

  328.     static function saveNew($profile_id, $content, $source, $options=null) {
    329. 

  329.         $defaults = array('uri' => null,
    330. 

  330.                           'url' => null,
    331. 

  331.                           'reply_to' => null,
    332. 

  332.                           'repeat_of' => null,
    333. 

  333.                           'scope' => null,
    334. 

  334.                           'distribute' => true,
    335. 

  335.                           'object_type' => null,
    336. 

  336.                           'verb' => null);
    337. 

  337. 

  338.         if (!empty($options) && is_array($options)) {
    339. 

  339.             $options = array_merge($defaults, $options);
    340. 

  340.             extract($options);
    341. 

  341.         } else {
    342. 

  342.             extract($defaults);
    343. 

  343.         }
    344. 

  344. 

  345.         if (!isset($is_local)) {
    346. 

  346.             $is_local = Notice::LOCAL_PUBLIC;
    347. 

  347.         }
    348. 

  348. 

  349.         $profile = Profile::staticGet('id', $profile_id);
    350. 

  350.         $user = User::staticGet('id', $profile_id);
    351. 

  351.         if ($user) {
    352. 

  352.             // Use the local user's shortening preferences, if applicable.
    353. 

  353.             $final = $user->shortenLinks($content);
    354. 

  354.         } else {
    355. 

  355.             $final = common_shorten_links($content);
    356. 

  356.         }
    357. 

  357. 

  358.         if (Notice::contentTooLong($final)) {
    359. 

  359.             // TRANS: Client exception thrown if a notice contains too many characters.
    360. 

  360.             throw new ClientException(_('Problem saving notice. Too long.'));
    361. 

  361.         }
    362. 

  362. 

  363.         if (empty($profile)) {
    364. 

  364.             // TRANS: Client exception thrown when trying to save a notice for an unknown user.
    365. 

  365.             throw new ClientException(_('Problem saving notice. Unknown user.'));
    366. 

  366.         }
    367. 

  367. 

  368.         if (common_config('throttle', 'enabled') && !Notice::checkEditThrottle($profile_id)) {
    369. 

  369.             common_log(LOG_WARNING, 'Excessive posting by profile #' . $profile_id . '; throttled.');
    370. 

  370.             // TRANS: Client exception thrown when a user tries to post too many notices in a given time frame.
    371. 

  371.             throw new ClientException(_('Too many notices too fast; take a breather '.
    372. 

  372.                                         'and post again in a few minutes.'));
    373. 

  373.         }
    374. 

  374. 

  375.         if (common_config('site', 'dupelimit') > 0 && !Notice::checkDupes($profile_id, $final)) {
    376. 

  376.             common_log(LOG_WARNING, 'Dupe posting by profile #' . $profile_id . '; throttled.');
    377. 

  377.             // TRANS: Client exception thrown when a user tries to post too many duplicate notices in a given time frame.
    378. 

  378.             throw new ClientException(_('Too many duplicate messages too quickly;'.
    379. 

  379.                                         ' take a breather and post again in a few minutes.'));
    380. 

  380.         }
    381. 

  381. 

  382.         if (!$profile->hasRight(Right::NEWNOTICE)) {
    383. 

  383.             common_log(LOG_WARNING, "Attempted post from user disallowed to post: " . $profile->nickname);
    384. 

  384. 

  385.             // TRANS: Client exception thrown when a user tries to post while being banned.
    386. 

  386.             throw new ClientException(_('You are banned from posting notices on this site.'), 403);
    387. 

  387.         }
    388. 

  388. 

  389.         $notice = new Notice();
    390. 

  390.         $notice->profile_id = $profile_id;
    391. 

  391. 

  392.         $autosource = common_config('public', 'autosource');
    393. 

  393. 

  394.         // Sandboxed are non-false, but not 1, either
    395. 

  395. 

  396.         if (!$profile->hasRight(Right::PUBLICNOTICE) ||
    397. 

  397.             ($source && $autosource && in_array($source, $autosource))) {
    398. 

  398.             $notice->is_local = Notice::LOCAL_NONPUBLIC;
    399. 

  399.         } else {
    400. 

  400.             $notice->is_local = $is_local;
    401. 

  401.         }
    402. 

  402. 

  403.         if (!empty($created)) {
    404. 

  404.             $notice->created = $created;
    405. 

  405.         } else {
    406. 

  406.             $notice->created = common_sql_now();
    407. 

  407.         }
    408. 

  408. 

  409.         $notice->content = $final;
    410. 

  410. 

  411.         $notice->source = $source;
    412. 

  412.         $notice->uri = $uri;
    413. 

  413.         $notice->url = $url;
    414. 

  414. 

  415.         // Get the groups here so we can figure out replies and such
    416. 

  416. 

  417.         if (!isset($groups)) {
    418. 

  418.             $groups = self::groupsFromText($notice->content, $profile);
    419. 

  419.         }
    420. 

  420. 

  421.         $reply = null;
    422. 

  422. 

  423.         // Handle repeat case
    424. 

  424. 

  425.         if (isset($repeat_of)) {
    426. 

  426. 

  427.             // Check for a private one
    428. 

  428. 

  429.             $repeat = Notice::staticGet('id', $repeat_of);
    430. 

  430. 

  431.             if (empty($repeat)) {
    432. 

  432.                 // TRANS: Client exception thrown in notice when trying to repeat a missing or deleted notice.
    433. 

  433.                 throw new ClientException(_('Cannot repeat; original notice is missing or deleted.'));
    434. 

  434.             }
    435. 

  435. 

  436.             if ($profile->id == $repeat->profile_id) {
    437. 

  437.                 // TRANS: Client error displayed when trying to repeat an own notice.
    438. 

  438.                 throw new ClientException(_('You cannot repeat your own notice.'));
    439. 

  439.             }
    440. 

  440. 

  441.             if ($repeat->scope != Notice::SITE_SCOPE &&
    442. 

  442.                 $repeat->scope != Notice::PUBLIC_SCOPE) {
    443. 

  443.                 // TRANS: Client error displayed when trying to repeat a non-public notice.
    444. 

  444.                 throw new ClientException(_('Cannot repeat a private notice.'), 403);
    445. 

  445.             }
    446. 

  446. 

  447.             if (!$repeat->inScope($profile)) {
    448. 

  448.                 // The generic checks above should cover this, but let's be sure!
    449. 

  449.                 // TRANS: Client error displayed when trying to repeat a notice you cannot access.
    450. 

  450.                 throw new ClientException(_('Cannot repeat a notice you cannot read.'), 403);
    451. 

  451.             }
    452. 

  452. 

  453.             if ($profile->hasRepeated($repeat->id)) {
    454. 

  454.                 // TRANS: Client error displayed when trying to repeat an already repeated notice.
    455. 

  455.                 throw new ClientException(_('You already repeated that notice.'));
    456. 

  456.             }
    457. 

  457. 

  458.             $notice->repeat_of = $repeat_of;
    459. 

  459.         } else {
    460. 

  460.             $reply = self::getReplyTo($reply_to, $profile_id, $source, $final);
    461. 

  461. 

  462.             if (!empty($reply)) {
    463. 

  463. 

  464.                 if (!$reply->inScope($profile)) {
    465. 

  465.                     // TRANS: Client error displayed when trying to reply to a notice a the target has no access to.
    466. 

  466.                     // TRANS: %1$s is a user nickname, %2$d is a notice ID (number).
    467. 

  467.                     throw new ClientException(sprintf(_('%1$s has no access to notice %2$d.'),
    468. 

  468.                                                       $profile->nickname, $reply->id), 403);
    469. 

  469.                 }
    470. 

  470. 

  471.                 $notice->reply_to     = $reply->id;
    472. 

  472.                 $notice->conversation = $reply->conversation;
    473. 

  473. 

  474.                 // If the original is private to a group, and notice has no group specified,
    475. 

  475.                 // make it to the same group(s)
    476. 

  476. 

  477.                 if (empty($groups) && ($reply->scope | Notice::GROUP_SCOPE)) {
    478. 

  478.                     $groups = array();
    479. 

  479.                     $replyGroups = $reply->getGroups();
    480. 

  480.                     foreach ($replyGroups as $group) {
    481. 

  481.                         if ($profile->isMember($group)) {
    482. 

  482.                             $groups[] = $group->id;
    483. 

  483.                         }
    484. 

  484.                     }
    485. 

  485.                 }
    486. 

  486. 

  487.                 // Scope set below
    488. 

  488.             }
    489. 

  489.         }
    490. 

  490. 

  491.         if (!empty($lat) && !empty($lon)) {
    492. 

  492.             $notice->lat = $lat;
    493. 

  493.             $notice->lon = $lon;
    494. 

  494.         }
    495. 

  495. 

  496.         if (!empty($location_ns) && !empty($location_id)) {
    497. 

  497.             $notice->location_id = $location_id;
    498. 

  498.             $notice->location_ns = $location_ns;
    499. 

  499.         }
    500. 

  500. 

  501.         if (!empty($rendered)) {
    502. 

  502.             $notice->rendered = $rendered;
    503. 

  503.         } else {
    504. 

  504.             $notice->rendered = common_render_content($final, $notice);
    505. 

  505.         }
    506. 

  506. 

  507.         if (empty($verb)) {
    508. 

  508.             if (!empty($notice->repeat_of)) {
    509. 

  509.                 $notice->verb        = ActivityVerb::SHARE;
    510. 

  510.                 $notice->object_type = ActivityObject::ACTIVITY;
    511. 

  511.             } else {
    512. 

  512.                 $notice->verb        = ActivityVerb::POST;
    513. 

  513.             }
    514. 

  514.         } else {
    515. 

  515.             $notice->verb = $verb;
    516. 

  516.         }
    517. 

  517. 

  518.         if (empty($object_type)) {
    519. 

  519.             $notice->object_type = (empty($notice->reply_to)) ? ActivityObject::NOTE : ActivityObject::COMMENT;
    520. 

  520.         } else {
    521. 

  521.             $notice->object_type = $object_type;
    522. 

  522.         }
    523. 

  523. 

  524.         if (is_null($scope)) { // 0 is a valid value
    525. 

  525.             if (!empty($reply)) {
    526. 

  526.                 $notice->scope = $reply->scope;
    527. 

  527.             } else {
    528. 

  528.                 $notice->scope = self::defaultScope();
    529. 

  529.             }
    530. 

  530.         } else {
    531. 

  531.             $notice->scope = $scope;
    532. 

  532.         }
    533. 

  533. 

  534.         // For private streams
    535. 

  535. 

  536.         $user = $profile->getUser();
    537. 

  537. 

  538.         if (!empty($user)) {
    539. 

  539.             if ($user->private_stream &&
    540. 

  540.                 ($notice->scope == Notice::PUBLIC_SCOPE ||
    541. 

  541.                  $notice->scope == Notice::SITE_SCOPE)) {
    542. 

  542.                 $notice->scope |= Notice::FOLLOWER_SCOPE;
    543. 

  543.             }
    544. 

  544.         }
    545. 

  545. 

  546.         // Force the scope for private groups
    547. 

  547. 

  548.         foreach ($groups as $groupId) {
    549. 

  549.             $group = User_group::staticGet('id', $groupId);
    550. 

  550.             if (!empty($group)) {
    551. 

  551.                 if ($group->force_scope) {
    552. 

  552.                     $notice->scope |= Notice::GROUP_SCOPE;
    553. 

  553.                     break;
    554. 

  554.                 }
    555. 

  555.             }
    556. 

  556.         }
    557. 

  557. 

  558.         if (Event::handle('StartNoticeSave', array(&$notice))) {
    559. 

  559. 

  560.             // XXX: some of these functions write to the DB
    561. 

  561. 

  562.             $id = $notice->insert();
    563. 

  563. 

  564.             if (!$id) {
    565. 

  565.                 common_log_db_error($notice, 'INSERT', __FILE__);
    566. 

  566.                 // TRANS: Server exception thrown when a notice cannot be saved.
    567. 

  567.                 throw new ServerException(_('Problem saving notice.'));
    568. 

  568.             }
    569. 

  569. 

  570.             // Update ID-dependent columns: URI, conversation
    571. 

  571. 

  572.             $orig = clone($notice);
    573. 

  573. 

  574.             $changed = false;
    575. 

  575. 

  576.             if (empty($uri)) {
    577. 

  577.                 $notice->uri = common_notice_uri($notice);
    578. 

  578.                 $changed = true;
    579. 

  579.             }
    580. 

  580. 

  581.             // If it's not part of a conversation, it's
    582. 

  582.             // the beginning of a new conversation.
    583. 

  583. 

  584.             if (empty($notice->conversation)) {
    585. 

  585.                 $conv = Conversation::create();
    586. 

  586.                 $notice->conversation = $conv->id;
    587. 

  587.                 $changed = true;
    588. 

  588.             }
    589. 

  589. 

  590.             if ($changed) {
    591. 

  591.                 if (!$notice->update($orig)) {
    592. 

  592.                     common_log_db_error($notice, 'UPDATE', __FILE__);
    593. 

  593.                     // TRANS: Server exception thrown when a notice cannot be updated.
    594. 

  594.                     throw new ServerException(_('Problem saving notice.'));
    595. 

  595.                 }
    596. 

  596.             }
    597. 

  597. 

  598.         }
    599. 

  599. 

  600.         // Clear the cache for subscribed users, so they'll update at next request
    601. 

  601.         // XXX: someone clever could prepend instead of clearing the cache
    602. 

  602. 

  603.         $notice->blowOnInsert();
    604. 

  604. 

  605.         // Save per-notice metadata...
    606. 

  606. 

  607.         if (isset($replies)) {
    608. 

  608.             $notice->saveKnownReplies($replies);
    609. 

  609.         } else {
    610. 

  610.             $notice->saveReplies();
    611. 

  611.         }
    612. 

  612. 

  613.         if (isset($tags)) {
    614. 

  614.             $notice->saveKnownTags($tags);
    615. 

  615.         } else {
    616. 

  616.             $notice->saveTags();
    617. 

  617.         }
    618. 

  618. 

  619.         // Note: groups may save tags, so must be run after tags are saved
    620. 

  620.         // to avoid errors on duplicates.
    621. 

  621.         // Note: groups should always be set.
    622. 

  622. 

  623.         $notice->saveKnownGroups($groups);
    624. 

  624. 

  625.         if (isset($urls)) {
    626. 

  626.             $notice->saveKnownUrls($urls);
    627. 

  627.         } else {
    628. 

  628.             $notice->saveUrls();
    629. 

  629.         }
    630. 

  630. 

  631.         if ($distribute) {
    632. 

  632.             // Prepare inbox delivery, may be queued to background.
    633. 

  633.             $notice->distribute();
    634. 

  634.         }
    635. 

  635. 

  636.         return $notice;
    637. 

  637.     }
    638. 

  638. 

  639.     function blowOnInsert($conversation = false)
    640. 

  640.     {
    641. 

  641.         $this->blowStream('profile:notice_ids:%d', $this->profile_id);
    642. 

  642. 

  643.         if ($this->isPublic()) {
    644. 

  644.             $this->blowStream('public');
    645. 

  645.         }
    646. 

  646. 

  647.         self::blow('notice:list-ids:conversation:%s', $this->conversation);
    648. 

  648.         self::blow('conversation:notice_count:%d', $this->conversation);
    649. 

  649. 

  650.         if (!empty($this->repeat_of)) {
    651. 

  651.             // XXX: we should probably only use one of these
    652. 

  652.             $this->blowStream('notice:repeats:%d', $this->repeat_of);
    653. 

  653.             self::blow('notice:list-ids:repeat_of:%d', $this->repeat_of);
    654. 

  654.         }
    655. 

  655. 

  656.         $original = Notice::staticGet('id', $this->repeat_of);
    657. 

  657. 

  658.         if (!empty($original)) {
    659. 

  659.             $originalUser = User::staticGet('id', $original->profile_id);
    660. 

  660.             if (!empty($originalUser)) {
    661. 

  661.                 $this->blowStream('user:repeats_of_me:%d', $originalUser->id);
    662. 

  662.             }
    663. 

  663.         }
    664. 

  664. 

  665.         $profile = Profile::staticGet($this->profile_id);
    666. 

  666. 

  667.         if (!empty($profile)) {
    668. 

  668.             $profile->blowNoticeCount();
    669. 

  669.         }
    670. 

  670. 

  671.         $ptags = $this->getProfileTags();
    672. 

  672.         foreach ($ptags as $ptag) {
    673. 

  673.             $ptag->blowNoticeStreamCache();
    674. 

  674.         }
    675. 

  675.     }
    676. 

  676. 

  677.     /**
    678. 

  678.      * Clear cache entries related to this notice at delete time.
    679. 

  679.      * Necessary to avoid breaking paging on public, profile timelines.
    680. 

  680.      */
    681. 

  681.     function blowOnDelete()
    682. 

  682.     {
    683. 

  683.         $this->blowOnInsert();
    684. 

  684. 

  685.         self::blow('profile:notice_ids:%d;last', $this->profile_id);
    686. 

  686. 

  687.         if ($this->isPublic()) {
    688. 

  688.             self::blow('public;last');
    689. 

  689.         }
    690. 

  690. 

  691.         self::blow('fave:by_notice', $this->id);
    692. 

  692. 

  693.         if ($this->conversation) {
    694. 

  694.             // In case we're the first, will need to calc a new root.
    695. 

  695.             self::blow('notice:conversation_root:%d', $this->conversation);
    696. 

  696.         }
    697. 

  697. 

  698.         $ptags = $this->getProfileTags();
    699. 

  699.         foreach ($ptags as $ptag) {
    700. 

  700.             $ptag->blowNoticeStreamCache(true);
    701. 

  701.         }
    702. 

  702.     }
    703. 

  703. 

  704.     function blowStream()
    705. 

  705.     {
    706. 

  706.         $c = self::memcache();
    707. 

  707. 

  708.         if (empty($c)) {
    709. 

  709.             return false;
    710. 

  710.         }
    711. 

  711. 

  712.         $args = func_get_args();
    713. 

  713. 

  714.         $format = array_shift($args);
    715. 

  715. 

  716.         $keyPart = vsprintf($format, $args);
    717. 

  717. 

  718.         $cacheKey = Cache::key($keyPart);
    719. 

  719.         
    720. 

  720.         $c->delete($cacheKey);
    721. 

  721. 

  722.         // delete the "last" stream, too, if this notice is
    723. 

  723.         // older than the top of that stream
    724. 

  724. 

  725.         $lastKey = $cacheKey.';last';
    726. 

  726. 

  727.         $lastStr = $c->get($lastKey);
    728. 

  728. 

  729.         if ($lastStr !== false) {
    730. 

  730.             $window     = explode(',', $lastStr);
    731. 

  731.             $lastID     = $window[0];
    732. 

  732.             $lastNotice = Notice::staticGet('id', $lastID);
    733. 

  733.             if (empty($lastNotice) // just weird
    734. 

  734.                 || strtotime($lastNotice->created) >= strtotime($this->created)) {
    735. 

  735.                 $c->delete($lastKey);
    736. 

  736.             }
    737. 

  737.         }
    738. 

  738.     }
    739. 

  739. 

  740.     /** save all urls in the notice to the db
    741. 

  741.      *
    742. 

  742.      * follow redirects and save all available file information
    743. 

  743.      * (mimetype, date, size, oembed, etc.)
    744. 

  744.      *
    745. 

  745.      * @return void
    746. 

  746.      */
    747. 

  747.     function saveUrls() {
    748. 

  748.         if (common_config('attachments', 'process_links')) {
    749. 

  749.             common_replace_urls_callback($this->content, array($this, 'saveUrl'), $this->id);
    750. 

  750.         }
    751. 

  751.     }
    752. 

  752. 

  753.     /**
    754. 

  754.      * Save the given URLs as related links/attachments to the db
    755. 

  755.      *
    756. 

  756.      * follow redirects and save all available file information
    757. 

  757.      * (mimetype, date, size, oembed, etc.)
    758. 

  758.      *
    759. 

  759.      * @return void
    760. 

  760.      */
    761. 

  761.     function saveKnownUrls($urls)
    762. 

  762.     {
    763. 

  763.         if (common_config('attachments', 'process_links')) {
    764. 

  764.             // @fixme validation?
    765. 

  765.             foreach (array_unique($urls) as $url) {
    766. 

  766.                 File::processNew($url, $this->id);
    767. 

  767.             }
    768. 

  768.         }
    769. 

  769.     }
    770. 

  770. 

  771.     /**
    772. 

  772.      * @private callback
    773. 

  773.      */
    774. 

  774.     function saveUrl($url, $notice_id) {
    775. 

  775.         File::processNew($url, $notice_id);
    776. 

  776.     }
    777. 

  777. 

  778.     static function checkDupes($profile_id, $content) {
    779. 

  779.         $profile = Profile::staticGet($profile_id);
    780. 

  780.         if (empty($profile)) {
    781. 

  781.             return false;
    782. 

  782.         }
    783. 

  783.         $notice = $profile->getNotices(0, CachingNoticeStream::CACHE_WINDOW);
    784. 

  784.         if (!empty($notice)) {
    785. 

  785.             $last = 0;
    786. 

  786.             while ($notice->fetch()) {
    787. 

  787.                 if (time() - strtotime($notice->created) >= common_config('site', 'dupelimit')) {
    788. 

  788.                     return true;
    789. 

  789.                 } else if ($notice->content == $content) {
    790. 

  790.                     return false;
    791. 

  791.                 }
    792. 

  792.             }
    793. 

  793.         }
    794. 

  794.         // If we get here, oldest item in cache window is not
    795. 

  795.         // old enough for dupe limit; do direct check against DB
    796. 

  796.         $notice = new Notice();
    797. 

  797.         $notice->profile_id = $profile_id;
    798. 

  798.         $notice->content = $content;
    799. 

  799.         $threshold = common_sql_date(time() - common_config('site', 'dupelimit'));
    800. 

  800.         $notice->whereAdd(sprintf("created > '%s'", $notice->escape($threshold)));
    801. 

  801. 

  802.         $cnt = $notice->count();
    803. 

  803.         return ($cnt == 0);
    804. 

  804.     }
    805. 

  805. 

  806.     static function checkEditThrottle($profile_id) {
    807. 

  807.         $profile = Profile::staticGet($profile_id);
    808. 

  808.         if (empty($profile)) {
    809. 

  809.             return false;
    810. 

  810.         }
    811. 

  811.         // Get the Nth notice
    812. 

  812.         $notice = $profile->getNotices(common_config('throttle', 'count') - 1, 1);
    813. 

  813.         if ($notice && $notice->fetch()) {
    814. 

  814.             // If the Nth notice was posted less than timespan seconds ago
    815. 

  815.             if (time() - strtotime($notice->created) <= common_config('throttle', 'timespan')) {
    816. 

  816.                 // Then we throttle
    817. 

  817.                 return false;
    818. 

  818.             }
    819. 

  819.         }
    820. 

  820.         // Either not N notices in the stream, OR the Nth was not posted within timespan seconds
    821. 

  821.         return true;
    822. 

  822.     }
    823. 

  823. 

  824. 	protected $_attachments = -1;
    825. 

  825. 	
    826. 

  826.     function attachments() {
    827. 

  827. 

  828. 		if ($this->_attachments != -1)  {
    829. 

  829.             return $this->_attachments;
    830. 

  830.         }
    831. 

  831. 		
    832. 

  832. 		$f2ps = Memcached_DataObject::listGet('File_to_post', 'post_id', array($this->id));
    833. 

  833. 		
    834. 

  834. 		$ids = array();
    835. 

  835. 		
    836. 

  836. 		foreach ($f2ps[$this->id] as $f2p) {
    837. 

  837.             $ids[] = $f2p->file_id;    
    838. 

  838.         }
    839. 

  839. 		
    840. 

  840. 		$files = Memcached_DataObject::multiGet('File', 'id', $ids);
    841. 

  841. 

  842. 		$this->_attachments = $files->fetchAll();
    843. 

  843. 		
    844. 

  844.         return $this->_attachments;
    845. 

  845.     }
    846. 

  846. 

  847. 	function _setAttachments($attachments)
    848. 

  848. 	{
    849. 

  849. 	    $this->_attachments = $attachments;
    850. 

  850. 	}
    851. 

  851. 

  852.     function publicStream($offset=0, $limit=20, $since_id=0, $max_id=0)
    853. 

  853.     {
    854. 

  854.         $stream = new PublicNoticeStream();
    855. 

  855.         return $stream->getNotices($offset, $limit, $since_id, $max_id);
    856. 

  856.     }
    857. 

  857. 

  858. 

  859.     function conversationStream($id, $offset=0, $limit=20, $since_id=0, $max_id=0)
    860. 

  860.     {
    861. 

  861.         $stream = new ConversationNoticeStream($id);
    862. 

  862. 

  863.         return $stream->getNotices($offset, $limit, $since_id, $max_id);
    864. 

  864.     }
    865. 

  865. 

  866.     /**
    867. 

  867.      * Is this notice part of an active conversation?
    868. 

  868.      *
    869. 

  869.      * @return boolean true if other messages exist in the same
    870. 

  870.      *                 conversation, false if this is the only one
    871. 

  871.      */
    872. 

  872.     function hasConversation()
    873. 

  873.     {
    874. 

  874.         if (!empty($this->conversation)) {
    875. 

  875.             $conversation = Notice::conversationStream(
    876. 

  876.                 $this->conversation,
    877. 

  877.                 1,
    878. 

  878.                 1
    879. 

  879.             );
    880. 

  880. 

  881.             if ($conversation->N > 0) {
    882. 

  882.                 return true;
    883. 

  883.             }
    884. 

  884.         }
    885. 

  885.         return false;
    886. 

  886.     }
    887. 

  887. 

  888.     /**
    889. 

  889.      * Grab the earliest notice from this conversation.
    890. 

  890.      *
    891. 

  891.      * @return Notice or null
    892. 

  892.      */
    893. 

  893.     function conversationRoot($profile=-1)
    894. 

  894.     {
    895. 

  895.         // XXX: can this happen?
    896. 

  896. 

  897.         if (empty($this->conversation)) {
    898. 

  898.             return null;
    899. 

  899.         }
    900. 

  900. 

  901.         // Get the current profile if not specified
    902. 

  902. 

  903.         if (is_int($profile) && $profile == -1) {
    904. 

  904.             $profile = Profile::current();
    905. 

  905.         }
    906. 

  906. 

  907.         // If this notice is out of scope, no root for you!
    908. 

  908. 

  909.         if (!$this->inScope($profile)) {
    910. 

  910.             return null;
    911. 

  911.         }
    912. 

  912. 

  913.         // If this isn't a reply to anything, then it's its own
    914. 

  914.         // root.
    915. 

  915. 

  916.         if (empty($this->reply_to)) {
    917. 

  917.             return $this;
    918. 

  918.         }
    919. 

  919.         
    920. 

  920.         if (is_null($profile)) {
    921. 

  921.             $keypart = sprintf('notice:conversation_root:%d:null', $this->id);
    922. 

  922.         } else {
    923. 

  923.             $keypart = sprintf('notice:conversation_root:%d:%d',
    924. 

  924.                                $this->id,
    925. 

  925.                                $profile->id);
    926. 

  926.         }
    927. 

  927.             
    928. 

  928.         $root = self::cacheGet($keypart);
    929. 

  929. 

  930.         if ($root !== false && $root->inScope($profile)) {
    931. 

  931.             return $root;
    932. 

  932.         } else {
    933. 

  933.             $last = $this;
    934. 

  934. 

  935.             do {
    936. 

  936.                 $parent = $last->getOriginal();
    937. 

  937.                 if (!empty($parent) && $parent->inScope($profile)) {
    938. 

  938.                     $last = $parent;
    939. 

  939.                     continue;
    940. 

  940.                 } else {
    941. 

  941.                     $root = $last;
    942. 

  942.                     break;
    943. 

  943.                 }
    944. 

  944.             } while (!empty($parent));
    945. 

  945. 

  946.             self::cacheSet($keypart, $root);
    947. 

  947.         }
    948. 

  948. 

  949.         return $root;
    950. 

  950.     }
    951. 

  951. 

  952.     /**
    953. 

  953.      * Pull up a full list of local recipients who will be getting
    954. 

  954.      * this notice in their inbox. Results will be cached, so don't
    955. 

  955.      * change the input data wily-nilly!
    956. 

  956.      *
    957. 

  957.      * @param array $groups optional list of Group objects;
    958. 

  958.      *              if left empty, will be loaded from group_inbox records
    959. 

  959.      * @param array $recipient optional list of reply profile ids
    960. 

  960.      *              if left empty, will be loaded from reply records
    961. 

  961.      * @return array associating recipient user IDs with an inbox source constant
    962. 

  962.      */
    963. 

  963.     function whoGets($groups=null, $recipients=null)
    964. 

  964.     {
    965. 

  965.         $c = self::memcache();
    966. 

  966. 

  967.         if (!empty($c)) {
    968. 

  968.             $ni = $c->get(Cache::key('notice:who_gets:'.$this->id));
    969. 

  969.             if ($ni !== false) {
    970. 

  970.                 return $ni;
    971. 

  971.             }
    972. 

  972.         }
    973. 

  973. 

  974.         if (is_null($groups)) {
    975. 

  975.             $groups = $this->getGroups();
    976. 

  976.         }
    977. 

  977. 

  978.         if (is_null($recipients)) {
    979. 

  979.             $recipients = $this->getReplies();
    980. 

  980.         }
    981. 

  981. 

  982.         $users = $this->getSubscribedUsers();
    983. 

  983.         $ptags = $this->getProfileTags();
    984. 

  984. 

  985.         // FIXME: kind of ignoring 'transitional'...
    986. 

  986.         // we'll probably stop supporting inboxless mode
    987. 

  987.         // in 0.9.x
    988. 

  988. 

  989.         $ni = array();
    990. 

  990. 

  991.         // Give plugins a chance to add folks in at start...
    992. 

  992.         if (Event::handle('StartNoticeWhoGets', array($this, &$ni))) {
    993. 

  993. 

  994.             foreach ($users as $id) {
    995. 

  995.                 $ni[$id] = NOTICE_INBOX_SOURCE_SUB;
    996. 

  996.             }
    997. 

  997. 

  998.             foreach ($groups as $group) {
    999. 

  999.                 $users = $group->getUserMembers();
    1000. 

  1000.                 foreach ($users as $id) {
    1001. 

  1001.                     if (!array_key_exists($id, $ni)) {
    1002. 

  1002.                         $ni[$id] = NOTICE_INBOX_SOURCE_GROUP;
    1003. 

  1003.                     }
    1004. 

  1004.                 }
    1005. 

  1005.             }
    1006. 

  1006. 

  1007.             foreach ($ptags as $ptag) {
    1008. 

  1008.                 $users = $ptag->getUserSubscribers();
    1009. 

  1009.                 foreach ($users as $id) {
    1010. 

  1010.                     if (!array_key_exists($id, $ni)) {
    1011. 

  1011.                         $ni[$id] = NOTICE_INBOX_SOURCE_PROFILE_TAG;
    1012. 

  1012.                     }
    1013. 

  1013.                 }
    1014. 

  1014.             }
    1015. 

  1015. 

  1016.             foreach ($recipients as $recipient) {
    1017. 

  1017.                 if (!array_key_exists($recipient, $ni)) {
    1018. 

  1018.                     $ni[$recipient] = NOTICE_INBOX_SOURCE_REPLY;
    1019. 

  1019.                 }
    1020. 

  1020.             }
    1021. 

  1021. 

  1022.             // Exclude any deleted, non-local, or blocking recipients.
    1023. 

  1023.             $profile = $this->getProfile();
    1024. 

  1024.             $originalProfile = null;
    1025. 

  1025.             if ($this->repeat_of) {
    1026. 

  1026.                 // Check blocks against the original notice's poster as well.
    1027. 

  1027.                 $original = Notice::staticGet('id', $this->repeat_of);
    1028. 

  1028.                 if ($original) {
    1029. 

  1029.                     $originalProfile = $original->getProfile();
    1030. 

  1030.                 }
    1031. 

  1031.             }
    1032. 

  1032. 

  1033.             foreach ($ni as $id => $source) {
    1034. 

  1034.                 $user = User::staticGet('id', $id);
    1035. 

  1035.                 if (empty($user) || $user->hasBlocked($profile) ||
    1036. 

  1036.                     ($originalProfile && $user->hasBlocked($originalProfile))) {
    1037. 

  1037.                     unset($ni[$id]);
    1038. 

  1038.                 }
    1039. 

  1039.             }
    1040. 

  1040. 

  1041.             // Give plugins a chance to filter out...
    1042. 

  1042.             Event::handle('EndNoticeWhoGets', array($this, &$ni));
    1043. 

  1043.         }
    1044. 

  1044. 

  1045.         if (!empty($c)) {
    1046. 

  1046.             // XXX: pack this data better
    1047. 

  1047.             $c->set(Cache::key('notice:who_gets:'.$this->id), $ni);
    1048. 

  1048.         }
    1049. 

  1049. 

  1050.         return $ni;
    1051. 

  1051.     }
    1052. 

  1052. 

  1053.     /**
    1054. 

  1054.      * Adds this notice to the inboxes of each local user who should receive
    1055. 

  1055.      * it, based on author subscriptions, group memberships, and @-replies.
    1056. 

  1056.      *
    1057. 

  1057.      * Warning: running a second time currently will make items appear
    1058. 

  1058.      * multiple times in users' inboxes.
    1059. 

  1059.      *
    1060. 

  1060.      * @fixme make more robust against errors
    1061. 

  1061.      * @fixme break up massive deliveries to smaller background tasks
    1062. 

  1062.      *
    1063. 

  1063.      * @param array $groups optional list of Group objects;
    1064. 

  1064.      *              if left empty, will be loaded from group_inbox records
    1065. 

  1065.      * @param array $recipient optional list of reply profile ids
    1066. 

  1066.      *              if left empty, will be loaded from reply records
    1067. 

  1067.      */
    1068. 

  1068.     function addToInboxes($groups=null, $recipients=null)
    1069. 

  1069.     {
    1070. 

  1070.         $ni = $this->whoGets($groups, $recipients);
    1071. 

  1071. 

  1072.         $ids = array_keys($ni);
    1073. 

  1073. 

  1074.         // We remove the author (if they're a local user),
    1075. 

  1075.         // since we'll have already done this in distribute()
    1076. 

  1076. 

  1077.         $i = array_search($this->profile_id, $ids);
    1078. 

  1078. 

  1079.         if ($i !== false) {
    1080. 

  1080.             unset($ids[$i]);
    1081. 

  1081.         }
    1082. 

  1082. 

  1083.         // Bulk insert
    1084. 

  1084. 

  1085.         Inbox::bulkInsert($this->id, $ids);
    1086. 

  1086. 

  1087.         return;
    1088. 

  1088.     }
    1089. 

  1089. 

  1090.     function getSubscribedUsers()
    1091. 

  1091.     {
    1092. 

  1092.         $user = new User();
    1093. 

  1093. 

  1094.         if(common_config('db','quote_identifiers'))
    1095. 

  1095.           $user_table = '"user"';
    1096. 

  1096.         else $user_table = 'user';
    1097. 

  1097. 

  1098.         $qry =
    1099. 

  1099.           'SELECT id ' .
    1100. 

  1100.           'FROM '. $user_table .' JOIN subscription '.
    1101. 

  1101.           'ON '. $user_table .'.id = subscription.subscriber ' .
    1102. 

  1102.           'WHERE subscription.subscribed = %d ';
    1103. 

  1103. 

  1104.         $user->query(sprintf($qry, $this->profile_id));
    1105. 

  1105. 

  1106.         $ids = array();
    1107. 

  1107. 

  1108.         while ($user->fetch()) {
    1109. 

  1109.             $ids[] = $user->id;
    1110. 

  1110.         }
    1111. 

  1111. 

  1112.         $user->free();
    1113. 

  1113. 

  1114.         return $ids;
    1115. 

  1115.     }
    1116. 

  1116. 

  1117.     function getProfileTags()
    1118. 

  1118.     {
    1119. 

  1119.         $profile = $this->getProfile();
    1120. 

  1120.         $list    = $profile->getOtherTags($profile);
    1121. 

  1121.         $ptags   = array();
    1122. 

  1122. 

  1123.         while($list->fetch()) {
    1124. 

  1124.             $ptags[] = clone($list);
    1125. 

  1125.         }
    1126. 

  1126. 

  1127.         return $ptags;
    1128. 

  1128.     }
    1129. 

  1129. 

  1130.     /**
    1131. 

  1131.      * Record this notice to the given group inboxes for delivery.
    1132. 

  1132.      * Overrides the regular parsing of !group markup.
    1133. 

  1133.      *
    1134. 

  1134.      * @param string $group_ids
    1135. 

  1135.      * @fixme might prefer URIs as identifiers, as for replies?
    1136. 

  1136.      *        best with generalizations on user_group to support
    1137. 

  1137.      *        remote groups better.
    1138. 

  1138.      */
    1139. 

  1139.     function saveKnownGroups($group_ids)
    1140. 

  1140.     {
    1141. 

  1141.         if (!is_array($group_ids)) {
    1142. 

  1142.             // TRANS: Server exception thrown when no array is provided to the method saveKnownGroups().
    1143. 

  1143.             throw new ServerException(_('Bad type provided to saveKnownGroups.'));
    1144. 

  1144.         }
    1145. 

  1145. 

  1146.         $groups = array();
    1147. 

  1147.         foreach (array_unique($group_ids) as $id) {
    1148. 

  1148.             $group = User_group::staticGet('id', $id);
    1149. 

  1149.             if ($group) {
    1150. 

  1150.                 common_log(LOG_ERR, "Local delivery to group id $id, $group->nickname");
    1151. 

  1151.                 $result = $this->addToGroupInbox($group);
    1152. 

  1152.                 if (!$result) {
    1153. 

  1153.                     common_log_db_error($gi, 'INSERT', __FILE__);
    1154. 

  1154.                 }
    1155. 

  1155. 

  1156.                 if (common_config('group', 'addtag')) {
    1157. 

  1157.                     // we automatically add a tag for every group name, too
    1158. 

  1158. 

  1159.                     $tag = Notice_tag::pkeyGet(array('tag' => common_canonical_tag($group->nickname),
    1160. 

  1160.                                                      'notice_id' => $this->id));
    1161. 

  1161. 

  1162.                     if (is_null($tag)) {
    1163. 

  1163.                         $this->saveTag($group->nickname);
    1164. 

  1164.                     }
    1165. 

  1165.                 }
    1166. 

  1166. 

  1167.                 $groups[] = clone($group);
    1168. 

  1168.             } else {
    1169. 

  1169.                 common_log(LOG_ERR, "Local delivery to group id $id skipped, doesn't exist");
    1170. 

  1170.             }
    1171. 

  1171.         }
    1172. 

  1172. 

  1173.         return $groups;
    1174. 

  1174.     }
    1175. 

  1175. 

  1176.     /**
    1177. 

  1177.      * Parse !group delivery and record targets into group_inbox.
    1178. 

  1178.      * @return array of Group objects
    1179. 

  1179.      */
    1180. 

  1180.     function saveGroups()
    1181. 

  1181.     {
    1182. 

  1182.         // Don't save groups for repeats
    1183. 

  1183. 

  1184.         if (!empty($this->repeat_of)) {
    1185. 

  1185.             return array();
    1186. 

  1186.         }
    1187. 

  1187. 

  1188.         $profile = $this->getProfile();
    1189. 

  1189. 

  1190.         $groups = self::groupsFromText($this->content, $profile);
    1191. 

  1191. 

  1192.         /* Add them to the database */
    1193. 

  1193. 

  1194.         foreach ($groups as $group) {
    1195. 

  1195.             /* XXX: remote groups. */
    1196. 

  1196. 

  1197.             if (empty($group)) {
    1198. 

  1198.                 continue;
    1199. 

  1199.             }
    1200. 

  1200. 

  1201. 

  1202.             if ($profile->isMember($group)) {
    1203. 

  1203. 

  1204.                 $result = $this->addToGroupInbox($group);
    1205. 

  1205. 

  1206.                 if (!$result) {
    1207. 

  1207.                     common_log_db_error($gi, 'INSERT', __FILE__);
    1208. 

  1208.                 }
    1209. 

  1209. 

  1210.                 $groups[] = clone($group);
    1211. 

  1211.             }
    1212. 

  1212.         }
    1213. 

  1213. 

  1214.         return $groups;
    1215. 

  1215.     }
    1216. 

  1216. 

  1217.     function addToGroupInbox($group)
    1218. 

  1218.     {
    1219. 

  1219.         $gi = Group_inbox::pkeyGet(array('group_id' => $group->id,
    1220. 

  1220.                                          'notice_id' => $this->id));
    1221. 

  1221. 

  1222.         if (empty($gi)) {
    1223. 

  1223. 

  1224.             $gi = new Group_inbox();
    1225. 

  1225. 

  1226.             $gi->group_id  = $group->id;
    1227. 

  1227.             $gi->notice_id = $this->id;
    1228. 

  1228.             $gi->created   = $this->created;
    1229. 

  1229. 

  1230.             $result = $gi->insert();
    1231. 

  1231. 

  1232.             if (!$result) {
    1233. 

  1233.                 common_log_db_error($gi, 'INSERT', __FILE__);
    1234. 

  1234.                 // TRANS: Server exception thrown when an update for a group inbox fails.
    1235. 

  1235.                 throw new ServerException(_('Problem saving group inbox.'));
    1236. 

  1236.             }
    1237. 

  1237. 

  1238.             self::blow('user_group:notice_ids:%d', $gi->group_id);
    1239. 

  1239.         }
    1240. 

  1240. 

  1241.         return true;
    1242. 

  1242.     }
    1243. 

  1243. 

  1244.     /**
    1245. 

  1245.      * Save reply records indicating that this notice needs to be
    1246. 

  1246.      * delivered to the local users with the given URIs.
    1247. 

  1247.      *
    1248. 

  1248.      * Since this is expected to be used when saving foreign-sourced
    1249. 

  1249.      * messages, we won't deliver to any remote targets as that's the
    1250. 

  1250.      * source service's responsibility.
    1251. 

  1251.      *
    1252. 

  1252.      * Mail notifications etc will be handled later.
    1253. 

  1253.      *
    1254. 

  1254.      * @param array of unique identifier URIs for recipients
    1255. 

  1255.      */
    1256. 

  1256.     function saveKnownReplies($uris)
    1257. 

  1257.     {
    1258. 

  1258.         if (empty($uris)) {
    1259. 

  1259.             return;
    1260. 

  1260.         }
    1261. 

  1261. 

  1262.         $sender = Profile::staticGet($this->profile_id);
    1263. 

  1263. 

  1264.         foreach (array_unique($uris) as $uri) {
    1265. 

  1265. 

  1266.             $profile = Profile::fromURI($uri);
    1267. 

  1267. 

  1268.             if (empty($profile)) {
    1269. 

  1269.                 common_log(LOG_WARNING, "Unable to determine profile for URI '$uri'");
    1270. 

  1270.                 continue;
    1271. 

  1271.             }
    1272. 

  1272. 

  1273.             if ($profile->hasBlocked($sender)) {
    1274. 

  1274.                 common_log(LOG_INFO, "Not saving reply to profile {$profile->id} ($uri) from sender {$sender->id} because of a block.");
    1275. 

  1275.                 continue;
    1276. 

  1276.             }
    1277. 

  1277. 

  1278.             $this->saveReply($profile->id);
    1279. 

  1279.             self::blow('reply:stream:%d', $profile->id);
    1280. 

  1280.         }
    1281. 

  1281. 

  1282.         return;
    1283. 

  1283.     }
    1284. 

  1284. 

  1285.     /**
    1286. 

  1286.      * Pull @-replies from this message's content in StatusNet markup format
    1287. 

  1287.      * and save reply records indicating that this message needs to be
    1288. 

  1288.      * delivered to those users.
    1289. 

  1289.      *
    1290. 

  1290.      * Mail notifications to local profiles will be sent later.
    1291. 

  1291.      *
    1292. 

  1292.      * @return array of integer profile IDs
    1293. 

  1293.      */
    1294. 

  1294. 

  1295.     function saveReplies()
    1296. 

  1296.     {
    1297. 

  1297.         // Don't save reply data for repeats
    1298. 

  1298. 

  1299.         if (!empty($this->repeat_of)) {
    1300. 

  1300.             return array();
    1301. 

  1301.         }
    1302. 

  1302. 

  1303.         $sender = Profile::staticGet($this->profile_id);
    1304. 

  1304. 

  1305.         $replied = array();
    1306. 

  1306. 

  1307.         // If it's a reply, save for the replied-to author
    1308. 

  1308. 

  1309.         if (!empty($this->reply_to)) {
    1310. 

  1310.             $original = $this->getOriginal();
    1311. 

  1311.             if (!empty($original)) { // that'd be weird
    1312. 

  1312.                 $author = $original->getProfile();
    1313. 

  1313.                 if (!empty($author)) {
    1314. 

  1314.                     $this->saveReply($author->id);
    1315. 

  1315.                     $replied[$author->id] = 1;
    1316. 

  1316.                     self::blow('reply:stream:%d', $author->id);
    1317. 

  1317.                 }
    1318. 

  1318.             }
    1319. 

  1319.         }
    1320. 

  1320. 

  1321.         // @todo ideally this parser information would only
    1322. 

  1322.         // be calculated once.
    1323. 

  1323. 

  1324.         $mentions = common_find_mentions($this->content, $this);
    1325. 

  1325. 

  1326.         // store replied only for first @ (what user/notice what the reply directed,
    1327. 

  1327.         // we assume first @ is it)
    1328. 

  1328. 

  1329.         foreach ($mentions as $mention) {
    1330. 

  1330. 

  1331.             foreach ($mention['mentioned'] as $mentioned) {
    1332. 

  1332. 

  1333.                 // skip if they're already covered
    1334. 

  1334. 

  1335.                 if (!empty($replied[$mentioned->id])) {
    1336. 

  1336.                     continue;
    1337. 

  1337.                 }
    1338. 

  1338. 

  1339.                 // Don't save replies from blocked profile to local user
    1340. 

  1340. 

  1341.                 $mentioned_user = User::staticGet('id', $mentioned->id);
    1342. 

  1342.                 if (!empty($mentioned_user) && $mentioned_user->hasBlocked($sender)) {
    1343. 

  1343.                     continue;
    1344. 

  1344.                 }
    1345. 

  1345. 

  1346.                 $this->saveReply($mentioned->id);
    1347. 

  1347.                 $replied[$mentioned->id] = 1;
    1348. 

  1348.                 self::blow('reply:stream:%d', $mentioned->id);
    1349. 

  1349.             }
    1350. 

  1350.         }
    1351. 

  1351. 

  1352.         $recipientIds = array_keys($replied);
    1353. 

  1353. 

  1354.         return $recipientIds;
    1355. 

  1355.     }
    1356. 

  1356. 

  1357.     function saveReply($profileId)
    1358. 

  1358.     {
    1359. 

  1359.         $reply = new Reply();
    1360. 

  1360. 

  1361.         $reply->notice_id  = $this->id;
    1362. 

  1362.         $reply->profile_id = $profileId;
    1363. 

  1363.         $reply->modified   = $this->created;
    1364. 

  1364. 

  1365.         $reply->insert();
    1366. 

  1366. 

  1367.         return $reply;
    1368. 

  1368.     }
    1369. 

  1369. 

  1370.     protected $_replies = -1;
    1371. 

  1371. 

  1372.     /**
    1373. 

  1373.      * Pull the complete list of @-reply targets for this notice.
    1374. 

  1374.      *
    1375. 

  1375.      * @return array of integer profile ids
    1376. 

  1376.      */
    1377. 

  1377.     function getReplies()
    1378. 

  1378.     {
    1379. 

  1379.         if ($this->_replies != -1) {
    1380. 

  1380.             return $this->_replies;
    1381. 

  1381.         }
    1382. 

  1382. 

  1383.         $replyMap = Memcached_DataObject::listGet('Reply', 'notice_id', array($this->id));
    1384. 

  1384. 

  1385.         $ids = array();
    1386. 

  1386. 

  1387.         foreach ($replyMap[$this->id] as $reply) {
    1388. 

  1388.             $ids[] = $reply->profile_id;
    1389. 

  1389.         }
    1390. 

  1390. 

  1391.         $this->_replies = $ids;
    1392. 

  1392. 

  1393.         return $ids;
    1394. 

  1394.     }
    1395. 

  1395. 

  1396.     function _setReplies($replies)
    1397. 

  1397.     {
    1398. 

  1398.         $this->_replies = $replies;
    1399. 

  1399.     }
    1400. 

  1400. 

  1401.     /**
    1402. 

  1402.      * Pull the complete list of @-reply targets for this notice.
    1403. 

  1403.      *
    1404. 

  1404.      * @return array of Profiles
    1405. 

  1405.      */
    1406. 

  1406.     function getReplyProfiles()
    1407. 

  1407.     {
    1408. 

  1408.         $ids = $this->getReplies();
    1409. 

  1409.         
    1410. 

  1410.         $profiles = Profile::multiGet('id', $ids);
    1411. 

  1411.         
    1412. 

  1412.         return $profiles->fetchAll();
    1413. 

  1413.     }
    1414. 

  1414. 

  1415.     /**
    1416. 

  1416.      * Send e-mail notifications to local @-reply targets.
    1417. 

  1417.      *
    1418. 

  1418.      * Replies must already have been saved; this is expected to be run
    1419. 

  1419.      * from the distrib queue handler.
    1420. 

  1420.      */
    1421. 

  1421.     function sendReplyNotifications()
    1422. 

  1422.     {
    1423. 

  1423.         // Don't send reply notifications for repeats
    1424. 

  1424. 

  1425.         if (!empty($this->repeat_of)) {
    1426. 

  1426.             return array();
    1427. 

  1427.         }
    1428. 

  1428. 

  1429.         $recipientIds = $this->getReplies();
    1430. 

  1430. 

  1431.         foreach ($recipientIds as $recipientId) {
    1432. 

  1432.             $user = User::staticGet('id', $recipientId);
    1433. 

  1433.             if (!empty($user)) {
    1434. 

  1434.                 mail_notify_attn($user, $this);
    1435. 

  1435.             }
    1436. 

  1436.         }
    1437. 

  1437.     }
    1438. 

  1438. 

  1439.     /**
    1440. 

  1440.      * Pull list of groups this notice needs to be delivered to,
    1441. 

  1441.      * as previously recorded by saveGroups() or saveKnownGroups().
    1442. 

  1442.      *
    1443. 

  1443.      * @return array of Group objects
    1444. 

  1444.      */
    1445. 

  1445.     
    1446. 

  1446.     protected $_groups = -1;
    1447. 

  1447.     
    1448. 

  1448.     function getGroups()
    1449. 

  1449.     {
    1450. 

  1450.         // Don't save groups for repeats
    1451. 

  1451. 

  1452.         if (!empty($this->repeat_of)) {
    1453. 

  1453.             return array();
    1454. 

  1454.         }
    1455. 

  1455.         
    1456. 

  1456.         if ($this->_groups != -1)
    1457. 

  1457.         {
    1458. 

  1458.             return $this->_groups;
    1459. 

  1459.         }
    1460. 

  1460.         
    1461. 

  1461.         $gis = Memcached_DataObject::listGet('Group_inbox', 'notice_id', array($this->id));
    1462. 

  1462. 

  1463.         $ids = array();
    1464. 

  1464. 

  1465. 		foreach ($gis[$this->id] as $gi)
    1466. 

  1466. 		{
    1467. 

  1467. 		    $ids[] = $gi->group_id;
    1468. 

  1468. 		}
    1469. 

  1469. 		
    1470. 

  1470. 		$groups = User_group::multiGet('id', $ids);
    1471. 

  1471. 		
    1472. 

  1472. 		$this->_groups = $groups->fetchAll();
    1473. 

  1473. 		
    1474. 

  1474. 		return $this->_groups;
    1475. 

  1475.     }
    1476. 

  1476.     
    1477. 

  1477.     function _setGroups($groups)
    1478. 

  1478.     {
    1479. 

  1479.         $this->_groups = $groups;
    1480. 

  1480.     }
    1481. 

  1481. 

  1482.     /**
    1483. 

  1483.      * Convert a notice into an activity for export.
    1484. 

  1484.      *
    1485. 

  1485.      * @param User $cur Current user
    1486. 

  1486.      *
    1487. 

  1487.      * @return Activity activity object representing this Notice.
    1488. 

  1488.      */
    1489. 

  1489. 

  1490.     function asActivity($cur)
    1491. 

  1491.     {
    1492. 

  1492.         $act = self::cacheGet(Cache::codeKey('notice:as-activity:'.$this->id));
    1493. 

  1493. 

  1494.         if (!empty($act)) {
    1495. 

  1495.             return $act;
    1496. 

  1496.         }
    1497. 

  1497.         $act = new Activity();
    1498. 

  1498. 

  1499.         if (Event::handle('StartNoticeAsActivity', array($this, &$act))) {
    1500. 

  1500. 

  1501.             $act->id      = $this->uri;
    1502. 

  1502.             $act->time    = strtotime($this->created);
    1503. 

  1503.             $act->link    = $this->bestUrl();
    1504. 

  1504.             $act->content = common_xml_safe_str($this->rendered);
    1505. 

  1505.             $act->title   = common_xml_safe_str($this->content);
    1506. 

  1506. 

  1507.             $profile = $this->getProfile();
    1508. 

  1508. 

  1509.             $act->actor            = ActivityObject::fromProfile($profile);
    1510. 

  1510.             $act->actor->extra[]   = $profile->profileInfo($cur);
    1511. 

  1511. 

  1512.             $act->verb = $this->verb;
    1513. 

  1513. 

  1514.             if ($this->repeat_of) {
    1515. 

  1515.                 $repeated = Notice::staticGet('id', $this->repeat_of);
    1516. 

  1516.                 if (!empty($repeated)) {
    1517. 

  1517.                     $act->objects[] = $repeated->asActivity($cur);
    1518. 

  1518.                 }
    1519. 

  1519.             } else {
    1520. 

  1520.                 $act->objects[] = ActivityObject::fromNotice($this);
    1521. 

  1521.             }
    1522. 

  1522. 

  1523.             // XXX: should this be handled by default processing for object entry?
    1524. 

  1524. 

  1525.             // Categories
    1526. 

  1526. 

  1527.             $tags = $this->getTags();
    1528. 

  1528. 

  1529.             foreach ($tags as $tag) {
    1530. 

  1530.                 $cat       = new AtomCategory();
    1531. 

  1531.                 $cat->term = $tag;
    1532. 

  1532. 

  1533.                 $act->categories[] = $cat;
    1534. 

  1534.             }
    1535. 

  1535. 

  1536.             // Enclosures
    1537. 

  1537.             // XXX: use Atom Media and/or File activity objects instead
    1538. 

  1538. 

  1539.             $attachments = $this->attachments();
    1540. 

  1540. 

  1541.             foreach ($attachments as $attachment) {
    1542. 

  1542.                 $enclosure = $attachment->getEnclosure();
    1543. 

  1543.                 if ($enclosure) {
    1544. 

  1544.                     $act->enclosures[] = $enclosure;
    1545. 

  1545.                 }
    1546. 

  1546.             }
    1547. 

  1547. 

  1548.             $ctx = new ActivityContext();
    1549. 

  1549. 

  1550.             if (!empty($this->reply_to)) {
    1551. 

  1551.                 $reply = Notice::staticGet('id', $this->reply_to);
    1552. 

  1552.                 if (!empty($reply)) {
    1553. 

  1553.                     $ctx->replyToID  = $reply->uri;
    1554. 

  1554.                     $ctx->replyToUrl = $reply->bestUrl();
    1555. 

  1555.                 }
    1556. 

  1556.             }
    1557. 

  1557. 

  1558.             $ctx->location = $this->getLocation();
    1559. 

  1559. 

  1560.             $conv = null;
    1561. 

  1561. 

  1562.             if (!empty($this->conversation)) {
    1563. 

  1563.                 $conv = Conversation::staticGet('id', $this->conversation);
    1564. 

  1564.                 if (!empty($conv)) {
    1565. 

  1565.                     $ctx->conversation = $conv->uri;
    1566. 

  1566.                 }
    1567. 

  1567.             }
    1568. 

  1568. 

  1569.             $reply_ids = $this->getReplies();
    1570. 

  1570. 

  1571.             foreach ($reply_ids as $id) {
    1572. 

  1572.                 $rprofile = Profile::staticGet('id', $id);
    1573. 

  1573.                 if (!empty($rprofile)) {
    1574. 

  1574.                     $ctx->attention[] = $rprofile->getUri();
    1575. 

  1575.                 }
    1576. 

  1576.             }
    1577. 

  1577. 

  1578.             $groups = $this->getGroups();
    1579. 

  1579. 

  1580.             foreach ($groups as $group) {
    1581. 

  1581.                 $ctx->attention[] = $group->getUri();
    1582. 

  1582.             }
    1583. 

  1583. 

  1584.             // XXX: deprecated; use ActivityVerb::SHARE instead
    1585. 

  1585. 

  1586.             $repeat = null;
    1587. 

  1587. 

  1588.             if (!empty($this->repeat_of)) {
    1589. 

  1589.                 $repeat = Notice::staticGet('id', $this->repeat_of);
    1590. 

  1590.                 if (!empty($repeat)) {
    1591. 

  1591.                     $ctx->forwardID  = $repeat->uri;
    1592. 

  1592.                     $ctx->forwardUrl = $repeat->bestUrl();
    1593. 

  1593.                 }
    1594. 

  1594.             }
    1595. 

  1595. 

  1596.             $act->context = $ctx;
    1597. 

  1597. 

  1598.             // Source
    1599. 

  1599. 

  1600.             $atom_feed = $profile->getAtomFeed();
    1601. 

  1601. 

  1602.             if (!empty($atom_feed)) {
    1603. 

  1603. 

  1604.                 $act->source = new ActivitySource();
    1605. 

  1605. 

  1606.                 // XXX: we should store the actual feed ID
    1607. 

  1607. 

  1608.                 $act->source->id = $atom_feed;
    1609. 

  1609. 

  1610.                 // XXX: we should store the actual feed title
    1611. 

  1611. 

  1612.                 $act->source->title = $profile->getBestName();
    1613. 

  1613. 

  1614.                 $act->source->links['alternate'] = $profile->profileurl;
    1615. 

  1615.                 $act->source->links['self']      = $atom_feed;
    1616. 

  1616. 

  1617.                 $act->source->icon = $profile->avatarUrl(AVATAR_PROFILE_SIZE);
    1618. 

  1618. 

  1619.                 $notice = $profile->getCurrentNotice();
    1620. 

  1620. 

  1621.                 if (!empty($notice)) {
    1622. 

  1622.                     $act->source->updated = self::utcDate($notice->created);
    1623. 

  1623.                 }
    1624. 

  1624. 

  1625.                 $user = User::staticGet('id', $profile->id);
    1626. 

  1626. 

  1627.                 if (!empty($user)) {
    1628. 

  1628.                     $act->source->links['license'] = common_config('license', 'url');
    1629. 

  1629.                 }
    1630. 

  1630.             }
    1631. 

  1631. 

  1632.             if ($this->isLocal()) {
    1633. 

  1633.                 $act->selfLink = common_local_url('ApiStatusesShow', array('id' => $this->id,
    1634. 

  1634.                                                                            'format' => 'atom'));
    1635. 

  1635.                 $act->editLink = $act->selfLink;
    1636. 

  1636.             }
    1637. 

  1637. 

  1638.             Event::handle('EndNoticeAsActivity', array($this, &$act));
    1639. 

  1639.         }
    1640. 

  1640. 

  1641.         self::cacheSet(Cache::codeKey('notice:as-activity:'.$this->id), $act);
    1642. 

  1642. 

  1643.         return $act;
    1644. 

  1644.     }
    1645. 

  1645. 

  1646.     // This has gotten way too long. Needs to be sliced up into functional bits
    1647. 

  1647.     // or ideally exported to a utility class.
    1648. 

  1648. 

  1649.     function asAtomEntry($namespace=false,
    1650. 

  1650.                          $source=false,
    1651. 

  1651.                          $author=true,
    1652. 

  1652.                          $cur=null)
    1653. 

  1653.     {
    1654. 

  1654.         $act = $this->asActivity($cur);
    1655. 

  1655.         $act->extra[] = $this->noticeInfo($cur);
    1656. 

  1656.         return $act->asString($namespace, $author, $source);
    1657. 

  1657.     }
    1658. 

  1658. 

  1659.     /**
    1660. 

  1660.      * Extra notice info for atom entries
    1661. 

  1661.      *
    1662. 

  1662.      * Clients use some extra notice info in the atom stream.
    1663. 

  1663.      * This gives it to them.
    1664. 

  1664.      *
    1665. 

  1665.      * @param User $cur Current user
    1666. 

  1666.      *
    1667. 

  1667.      * @return array representation of <statusnet:notice_info> element
    1668. 

  1668.      */
    1669. 

  1669. 

  1670.     function noticeInfo($cur)
    1671. 

  1671.     {
    1672. 

  1672.         // local notice ID (useful to clients for ordering)
    1673. 

  1673. 

  1674.         $noticeInfoAttr = array('local_id' => $this->id);
    1675. 

  1675. 

  1676.         // notice source
    1677. 

  1677. 

  1678.         $ns = $this->getSource();
    1679. 

  1679. 

  1680.         if (!empty($ns)) {
    1681. 

  1681.             $noticeInfoAttr['source'] =  $ns->code;
    1682. 

  1682.             if (!empty($ns->url)) {
    1683. 

  1683.                 $noticeInfoAttr['source_link'] = $ns->url;
    1684. 

  1684.                 if (!empty($ns->name)) {
    1685. 

  1685.                     $noticeInfoAttr['source'] =  '<a href="'
    1686. 

  1686.                         . htmlspecialchars($ns->url)
    1687. 

  1687.                         . '" rel="nofollow">'
    1688. 

  1688.                         . htmlspecialchars($ns->name)
    1689. 

  1689.                         . '</a>';
    1690. 

  1690.                 }
    1691. 

  1691.             }
    1692. 

  1692.         }
    1693. 

  1693. 

  1694.         // favorite and repeated
    1695. 

  1695. 

  1696.         if (!empty($cur)) {
    1697. 

  1697.             $noticeInfoAttr['favorite'] = ($cur->hasFave($this)) ? "true" : "false";
    1698. 

  1698.             $cp = $cur->getProfile();
    1699. 

  1699.             $noticeInfoAttr['repeated'] = ($cp->hasRepeated($this->id)) ? "true" : "false";
    1700. 

  1700.         }
    1701. 

  1701. 

  1702.         if (!empty($this->repeat_of)) {
    1703. 

  1703.             $noticeInfoAttr['repeat_of'] = $this->repeat_of;
    1704. 

  1704.         }
    1705. 

  1705. 

  1706.         return array('statusnet:notice_info', $noticeInfoAttr, null);
    1707. 

  1707.     }
    1708. 

  1708. 

  1709.     /**
    1710. 

  1710.      * Returns an XML string fragment with a reference to a notice as an
    1711. 

  1711.      * Activity Streams noun object with the given element type.
    1712. 

  1712.      *
    1713. 

  1713.      * Assumes that 'activity' namespace has been previously defined.
    1714. 

  1714.      *
    1715. 

  1715.      * @param string $element one of 'subject', 'object', 'target'
    1716. 

  1716.      * @return string
    1717. 

  1717.      */
    1718. 

  1718. 

  1719.     function asActivityNoun($element)
    1720. 

  1720.     {
    1721. 

  1721.         $noun = ActivityObject::fromNotice($this);
    1722. 

  1722.         return $noun->asString('activity:' . $element);
    1723. 

  1723.     }
    1724. 

  1724. 

  1725.     function bestUrl()
    1726. 

  1726.     {
    1727. 

  1727.         if (!empty($this->url)) {
    1728. 

  1728.             return $this->url;
    1729. 

  1729.         } else if (!empty($this->uri) && preg_match('/^https?:/', $this->uri)) {
    1730. 

  1730.             return $this->uri;
    1731. 

  1731.         } else {
    1732. 

  1732.             return common_local_url('shownotice',
    1733. 

  1733.                                     array('notice' => $this->id));
    1734. 

  1734.         }
    1735. 

  1735.     }
    1736. 

  1736. 

  1737. 

  1738.     /**
    1739. 

  1739.      * Determine which notice, if any, a new notice is in reply to.
    1740. 

  1740.      *
    1741. 

  1741.      * For conversation tracking, we try to see where this notice fits
    1742. 

  1742.      * in the tree. Rough algorithm is:
    1743. 

  1743.      *
    1744. 

  1744.      * if (reply_to is set and valid) {
    1745. 

  1745.      *     return reply_to;
    1746. 

  1746.      * } else if ((source not API or Web) and (content starts with "T NAME" or "@name ")) {
    1747. 

  1747.      *     return ID of last notice by initial @name in content;
    1748. 

  1748.      * }
    1749. 

  1749.      *
    1750. 

  1750.      * Note that all @nickname instances will still be used to save "reply" records,
    1751. 

  1751.      * so the notice shows up in the mentioned users' "replies" tab.
    1752. 

  1752.      *
    1753. 

  1753.      * @param integer $reply_to   ID passed in by Web or API
    1754. 

  1754.      * @param integer $profile_id ID of author
    1755. 

  1755.      * @param string  $source     Source tag, like 'web' or 'gwibber'
    1756. 

  1756.      * @param string  $content    Final notice content
    1757. 

  1757.      *
    1758. 

  1758.      * @return integer ID of replied-to notice, or null for not a reply.
    1759. 

  1759.      */
    1760. 

  1760. 

  1761.     static function getReplyTo($reply_to, $profile_id, $source, $content)
    1762. 

  1762.     {
    1763. 

  1763.         static $lb = array('xmpp', 'mail', 'sms', 'omb');
    1764. 

  1764. 

  1765.         // If $reply_to is specified, we check that it exists, and then
    1766. 

  1766.         // return it if it does
    1767. 

  1767. 

  1768.         if (!empty($reply_to)) {
    1769. 

  1769.             $reply_notice = Notice::staticGet('id', $reply_to);
    1770. 

  1770.             if (!empty($reply_notice)) {
    1771. 

  1771.                 return $reply_notice;
    1772. 

  1772.             }
    1773. 

  1773.         }
    1774. 

  1774. 

  1775.         // If it's not a "low bandwidth" source (one where you can't set
    1776. 

  1776.         // a reply_to argument), we return. This is mostly web and API
    1777. 

  1777.         // clients.
    1778. 

  1778. 

  1779.         if (!in_array($source, $lb)) {
    1780. 

  1780.             return null;
    1781. 

  1781.         }
    1782. 

  1782. 

  1783.         // Is there an initial @ or T?
    1784. 

  1784. 

  1785.         if (preg_match('/^T ([A-Z0-9]{1,64}) /', $content, $match) ||
    1786. 

  1786.             preg_match('/^@([a-z0-9]{1,64})\s+/', $content, $match)) {
    1787. 

  1787.             $nickname = common_canonical_nickname($match[1]);
    1788. 

  1788.         } else {
    1789. 

  1789.             return null;
    1790. 

  1790.         }
    1791. 

  1791. 

  1792.         // Figure out who that is.
    1793. 

  1793. 

  1794.         $sender = Profile::staticGet('id', $profile_id);
    1795. 

  1795.         if (empty($sender)) {
    1796. 

  1796.             return null;
    1797. 

  1797.         }
    1798. 

  1798. 

  1799.         $recipient = common_relative_profile($sender, $nickname, common_sql_now());
    1800. 

  1800. 

  1801.         if (empty($recipient)) {
    1802. 

  1802.             return null;
    1803. 

  1803.         }
    1804. 

  1804. 

  1805.         // Get their last notice
    1806. 

  1806. 

  1807.         $last = $recipient->getCurrentNotice();
    1808. 

  1808. 

  1809.         if (!empty($last)) {
    1810. 

  1810.             return $last;
    1811. 

  1811.         }
    1812. 

  1812. 

  1813.         return null;
    1814. 

  1814.     }
    1815. 

  1815. 

  1816.     static function maxContent()
    1817. 

  1817.     {
    1818. 

  1818.         $contentlimit = common_config('notice', 'contentlimit');
    1819. 

  1819.         // null => use global limit (distinct from 0!)
    1820. 

  1820.         if (is_null($contentlimit)) {
    1821. 

  1821.             $contentlimit = common_config('site', 'textlimit');
    1822. 

  1822.         }
    1823. 

  1823.         return $contentlimit;
    1824. 

  1824.     }
    1825. 

  1825. 

  1826.     static function contentTooLong($content)
    1827. 

  1827.     {
    1828. 

  1828.         $contentlimit = self::maxContent();
    1829. 

  1829.         return ($contentlimit > 0 && !empty($content) && (mb_strlen($content) > $contentlimit));
    1830. 

  1830.     }
    1831. 

  1831. 

  1832.     function getLocation()
    1833. 

  1833.     {
    1834. 

  1834.         $location = null;
    1835. 

  1835. 

  1836.         if (!empty($this->location_id) && !empty($this->location_ns)) {
    1837. 

  1837.             $location = Location::fromId($this->location_id, $this->location_ns);
    1838. 

  1838.         }
    1839. 

  1839. 

  1840.         if (is_null($location)) { // no ID, or Location::fromId() failed
    1841. 

  1841.             if (!empty($this->lat) && !empty($this->lon)) {
    1842. 

  1842.                 $location = Location::fromLatLon($this->lat, $this->lon);
    1843. 

  1843.             }
    1844. 

  1844.         }
    1845. 

  1845. 

  1846.         return $location;
    1847. 

  1847.     }
    1848. 

  1848. 

  1849.     /**
    1850. 

  1850.      * Convenience function for posting a repeat of an existing message.
    1851. 

  1851.      *
    1852. 

  1852.      * @param int $repeater_id: profile ID of user doing the repeat
    1853. 

  1853.      * @param string $source: posting source key, eg 'web', 'api', etc
    1854. 

  1854.      * @return Notice
    1855. 

  1855.      *
    1856. 

  1856.      * @throws Exception on failure or permission problems
    1857. 

  1857.      */
    1858. 

  1858.     function repeat($repeater_id, $source)
    1859. 

  1859.     {
    1860. 

  1860.         $author = Profile::staticGet('id', $this->profile_id);
    1861. 

  1861. 

  1862.         // TRANS: Message used to repeat a notice. RT is the abbreviation of 'retweet'.
    1863. 

  1863.         // TRANS: %1$s is the repeated user's name, %2$s is the repeated notice.
    1864. 

  1864.         $content = sprintf(_('RT @%1$s %2$s'),
    1865. 

  1865.                            $author->nickname,
    1866. 

  1866.                            $this->content);
    1867. 

  1867. 

  1868.         $maxlen = common_config('site', 'textlimit');
    1869. 

  1869.         if ($maxlen > 0 && mb_strlen($content) > $maxlen) {
    1870. 

  1870.             // Web interface and current Twitter API clients will
    1871. 

  1871.             // pull the original notice's text, but some older
    1872. 

  1872.             // clients and RSS/Atom feeds will see this trimmed text.
    1873. 

  1873.             //
    1874. 

  1874.             // Unfortunately this is likely to lose tags or URLs
    1875. 

  1875.             // at the end of long notices.
    1876. 

  1876.             $content = mb_substr($content, 0, $maxlen - 4) . ' ...';
    1877. 

  1877.         }
    1878. 

  1878. 

  1879.         // Scope is same as this one's
    1880. 

  1880. 

  1881.         return self::saveNew($repeater_id,
    1882. 

  1882.                              $content,
    1883. 

  1883.                              $source,
    1884. 

  1884.                              array('repeat_of' => $this->id,
    1885. 

  1885.                                    'scope' => $this->scope));
    1886. 

  1886.     }
    1887. 

  1887. 

  1888.     // These are supposed to be in chron order!
    1889. 

  1889. 

  1890.     function repeatStream($limit=100)
    1891. 

  1891.     {
    1892. 

  1892.         $cache = Cache::instance();
    1893. 

  1893. 

  1894.         if (empty($cache)) {
    1895. 

  1895.             $ids = $this->_repeatStreamDirect($limit);
    1896. 

  1896.         } else {
    1897. 

  1897.             $idstr = $cache->get(Cache::key('notice:repeats:'.$this->id));
    1898. 

  1898.             if ($idstr !== false) {
    1899. 

  1899.             	if (empty($idstr)) {
    1900. 

  1900.             		$ids = array();
    1901. 

  1901.             	} else {
    1902. 

  1902.                 	$ids = explode(',', $idstr);
    1903. 

  1903.             	}
    1904. 

  1904.             } else {
    1905. 

  1905.                 $ids = $this->_repeatStreamDirect(100);
    1906. 

  1906.                 $cache->set(Cache::key('notice:repeats:'.$this->id), implode(',', $ids));
    1907. 

  1907.             }
    1908. 

  1908.             if ($limit < 100) {
    1909. 

  1909.                 // We do a max of 100, so slice down to limit
    1910. 

  1910.                 $ids = array_slice($ids, 0, $limit);
    1911. 

  1911.             }
    1912. 

  1912.         }
    1913. 

  1913. 

  1914.         return NoticeStream::getStreamByIds($ids);
    1915. 

  1915.     }
    1916. 

  1916. 

  1917.     function _repeatStreamDirect($limit)
    1918. 

  1918.     {
    1919. 

  1919.         $notice = new Notice();
    1920. 

  1920. 

  1921.         $notice->selectAdd(); // clears it
    1922. 

  1922.         $notice->selectAdd('id');
    1923. 

  1923. 

  1924.         $notice->repeat_of = $this->id;
    1925. 

  1925. 

  1926.         $notice->orderBy('created, id'); // NB: asc!
    1927. 

  1927. 

  1928.         if (!is_null($limit)) {
    1929. 

  1929.             $notice->limit(0, $limit);
    1930. 

  1930.         }
    1931. 

  1931. 

  1932.         return $notice->fetchAll('id');
    1933. 

  1933.     }
    1934. 

  1934. 

  1935.     function locationOptions($lat, $lon, $location_id, $location_ns, $profile = null)
    1936. 

  1936.     {
    1937. 

  1937.         $options = array();
    1938. 

  1938. 

  1939.         if (!empty($location_id) && !empty($location_ns)) {
    1940. 

  1940.             $options['location_id'] = $location_id;
    1941. 

  1941.             $options['location_ns'] = $location_ns;
    1942. 

  1942. 

  1943.             $location = Location::fromId($location_id, $location_ns);
    1944. 

  1944. 

  1945.             if (!empty($location)) {
    1946. 

  1946.                 $options['lat'] = $location->lat;
    1947. 

  1947.                 $options['lon'] = $location->lon;
    1948. 

  1948.             }
    1949. 

  1949. 

  1950.         } else if (!empty($lat) && !empty($lon)) {
    1951. 

  1951.             $options['lat'] = $lat;
    1952. 

  1952.             $options['lon'] = $lon;
    1953. 

  1953. 

  1954.             $location = Location::fromLatLon($lat, $lon);
    1955. 

  1955. 

  1956.             if (!empty($location)) {
    1957. 

  1957.                 $options['location_id'] = $location->location_id;
    1958. 

  1958.                 $options['location_ns'] = $location->location_ns;
    1959. 

  1959.             }
    1960. 

  1960.         } else if (!empty($profile)) {
    1961. 

  1961.             if (isset($profile->lat) && isset($profile->lon)) {
    1962. 

  1962.                 $options['lat'] = $profile->lat;
    1963. 

  1963.                 $options['lon'] = $profile->lon;
    1964. 

  1964.             }
    1965. 

  1965. 

  1966.             if (isset($profile->location_id) && isset($profile->location_ns)) {
    1967. 

  1967.                 $options['location_id'] = $profile->location_id;
    1968. 

  1968.                 $options['location_ns'] = $profile->location_ns;
    1969. 

  1969.             }
    1970. 

  1970.         }
    1971. 

  1971. 

  1972.         return $options;
    1973. 

  1973.     }
    1974. 

  1974. 

  1975.     function clearReplies()
    1976. 

  1976.     {
    1977. 

  1977.         $replyNotice = new Notice();
    1978. 

  1978.         $replyNotice->reply_to = $this->id;
    1979. 

  1979. 

  1980.         //Null any notices that are replies to this notice
    1981. 

  1981. 

  1982.         if ($replyNotice->find()) {
    1983. 

  1983.             while ($replyNotice->fetch()) {
    1984. 

  1984.                 $orig = clone($replyNotice);
    1985. 

  1985.                 $replyNotice->reply_to = null;
    1986. 

  1986.                 $replyNotice->update($orig);
    1987. 

  1987.             }
    1988. 

  1988.         }
    1989. 

  1989. 

  1990.         // Reply records
    1991. 

  1991. 

  1992.         $reply = new Reply();
    1993. 

  1993.         $reply->notice_id = $this->id;
    1994. 

  1994. 

  1995.         if ($reply->find()) {
    1996. 

  1996.             while($reply->fetch()) {
    1997. 

  1997.                 self::blow('reply:stream:%d', $reply->profile_id);
    1998. 

  1998.                 $reply->delete();
    1999. 

  1999.             }
    2000. 

  2000.         }
    2001. 

  2001. 

  2002.         $reply->free();
    2003. 

  2003.     }
    2004. 

  2004. 

  2005.     function clearFiles()
    2006. 

  2006.     {
    2007. 

  2007.         $f2p = new File_to_post();
    2008. 

  2008. 

  2009.         $f2p->post_id = $this->id;
    2010. 

  2010. 

  2011.         if ($f2p->find()) {
    2012. 

  2012.             while ($f2p->fetch()) {
    2013. 

  2013.                 $f2p->delete();
    2014. 

  2014.             }
    2015. 

  2015.         }
    2016. 

  2016.         // FIXME: decide whether to delete File objects
    2017. 

  2017.         // ...and related (actual) files
    2018. 

  2018.     }
    2019. 

  2019. 

  2020.     function clearRepeats()
    2021. 

  2021.     {
    2022. 

  2022.         $repeatNotice = new Notice();
    2023. 

  2023.         $repeatNotice->repeat_of = $this->id;
    2024. 

  2024. 

  2025.         //Null any notices that are repeats of this notice
    2026. 

  2026. 

  2027.         if ($repeatNotice->find()) {
    2028. 

  2028.             while ($repeatNotice->fetch()) {
    2029. 

  2029.                 $orig = clone($repeatNotice);
    2030. 

  2030.                 $repeatNotice->repeat_of = null;
    2031. 

  2031.                 $repeatNotice->update($orig);
    2032. 

  2032.             }
    2033. 

  2033.         }
    2034. 

  2034.     }
    2035. 

  2035. 

  2036.     function clearFaves()
    2037. 

  2037.     {
    2038. 

  2038.         $fave = new Fave();
    2039. 

  2039.         $fave->notice_id = $this->id;
    2040. 

  2040. 

  2041.         if ($fave->find()) {
    2042. 

  2042.             while ($fave->fetch()) {
    2043. 

  2043.                 self::blow('fave:ids_by_user_own:%d', $fave->user_id);
    2044. 

  2044.                 self::blow('fave:ids_by_user_own:%d;last', $fave->user_id);
    2045. 

  2045.                 self::blow('fave:ids_by_user:%d', $fave->user_id);
    2046. 

  2046.                 self::blow('fave:ids_by_user:%d;last', $fave->user_id);
    2047. 

  2047.                 $fave->delete();
    2048. 

  2048.             }
    2049. 

  2049.         }
    2050. 

  2050. 

  2051.         $fave->free();
    2052. 

  2052.     }
    2053. 

  2053. 

  2054.     function clearTags()
    2055. 

  2055.     {
    2056. 

  2056.         $tag = new Notice_tag();
    2057. 

  2057.         $tag->notice_id = $this->id;
    2058. 

  2058. 

  2059.         if ($tag->find()) {
    2060. 

  2060.             while ($tag->fetch()) {
    2061. 

  2061.                 self::blow('profile:notice_ids_tagged:%d:%s', $this->profile_id, Cache::keyize($tag->tag));
    2062. 

  2062.                 self::blow('profile:notice_ids_tagged:%d:%s;last', $this->profile_id, Cache::keyize($tag->tag));
    2063. 

  2063.                 self::blow('notice_tag:notice_ids:%s', Cache::keyize($tag->tag));
    2064. 

  2064.                 self::blow('notice_tag:notice_ids:%s;last', Cache::keyize($tag->tag));
    2065. 

  2065.                 $tag->delete();
    2066. 

  2066.             }
    2067. 

  2067.         }
    2068. 

  2068. 

  2069.         $tag->free();
    2070. 

  2070.     }
    2071. 

  2071. 

  2072.     function clearGroupInboxes()
    2073. 

  2073.     {
    2074. 

  2074.         $gi = new Group_inbox();
    2075. 

  2075. 

  2076.         $gi->notice_id = $this->id;
    2077. 

  2077. 

  2078.         if ($gi->find()) {
    2079. 

  2079.             while ($gi->fetch()) {
    2080. 

  2080.                 self::blow('user_group:notice_ids:%d', $gi->group_id);
    2081. 

  2081.                 $gi->delete();
    2082. 

  2082.             }
    2083. 

  2083.         }
    2084. 

  2084. 

  2085.         $gi->free();
    2086. 

  2086.     }
    2087. 

  2087. 

  2088.     function distribute()
    2089. 

  2089.     {
    2090. 

  2090.         // We always insert for the author so they don't
    2091. 

  2091.         // have to wait
    2092. 

  2092.         Event::handle('StartNoticeDistribute', array($this));
    2093. 

  2093. 

  2094.         $user = User::staticGet('id', $this->profile_id);
    2095. 

  2095.         if (!empty($user)) {
    2096. 

  2096.             Inbox::insertNotice($user->id, $this->id);
    2097. 

  2097.         }
    2098. 

  2098. 

  2099.         if (common_config('queue', 'inboxes')) {
    2100. 

  2100.             // If there's a failure, we want to _force_
    2101. 

  2101.             // distribution at this point.
    2102. 

  2102.             try {
    2103. 

  2103.                 $qm = QueueManager::get();
    2104. 

  2104.                 $qm->enqueue($this, 'distrib');
    2105. 

  2105.             } catch (Exception $e) {
    2106. 

  2106.                 // If the exception isn't transient, this
    2107. 

  2107.                 // may throw more exceptions as DQH does
    2108. 

  2108.                 // its own enqueueing. So, we ignore them!
    2109. 

  2109.                 try {
    2110. 

  2110.                     $handler = new DistribQueueHandler();
    2111. 

  2111.                     $handler->handle($this);
    2112. 

  2112.                 } catch (Exception $e) {
    2113. 

  2113.                     common_log(LOG_ERR, "emergency redistribution resulted in " . $e->getMessage());
    2114. 

  2114.                 }
    2115. 

  2115.                 // Re-throw so somebody smarter can handle it.
    2116. 

  2116.                 throw $e;
    2117. 

  2117.             }
    2118. 

  2118.         } else {
    2119. 

  2119.             $handler = new DistribQueueHandler();
    2120. 

  2120.             $handler->handle($this);
    2121. 

  2121.         }
    2122. 

  2122.     }
    2123. 

  2123. 

  2124.     function insert()
    2125. 

  2125.     {
    2126. 

  2126.         $result = parent::insert();
    2127. 

  2127. 

  2128.         if ($result) {
    2129. 

  2129.             // Profile::hasRepeated() abuses pkeyGet(), so we
    2130. 

  2130.             // have to clear manually
    2131. 

  2131.             if (!empty($this->repeat_of)) {
    2132. 

  2132.                 $c = self::memcache();
    2133. 

  2133.                 if (!empty($c)) {
    2134. 

  2134.                     $ck = self::multicacheKey('Notice',
    2135. 

  2135.                                               array('profile_id' => $this->profile_id,
    2136. 

  2136.                                                     'repeat_of' => $this->repeat_of));
    2137. 

  2137.                     $c->delete($ck);
    2138. 

  2138.                 }
    2139. 

  2139.             }
    2140. 

  2140.         }
    2141. 

  2141. 

  2142.         return $result;
    2143. 

  2143.     }
    2144. 

  2144. 

  2145.     /**
    2146. 

  2146.      * Get the source of the notice
    2147. 

  2147.      *
    2148. 

  2148.      * @return Notice_source $ns A notice source object. 'code' is the only attribute
    2149. 

  2149.      *                           guaranteed to be populated.
    2150. 

  2150.      */
    2151. 

  2151.     function getSource()
    2152. 

  2152.     {
    2153. 

  2153.         $ns = new Notice_source();
    2154. 

  2154.         if (!empty($this->source)) {
    2155. 

  2155.             switch ($this->source) {
    2156. 

  2156.             case 'web':
    2157. 

  2157.             case 'xmpp':
    2158. 

  2158.             case 'mail':
    2159. 

  2159.             case 'omb':
    2160. 

  2160.             case 'system':
    2161. 

  2161.             case 'api':
    2162. 

  2162.                 $ns->code = $this->source;
    2163. 

  2163.                 break;
    2164. 

  2164.             default:
    2165. 

  2165.                 $ns = Notice_source::staticGet($this->source);
    2166. 

  2166.                 if (!$ns) {
    2167. 

  2167.                     $ns = new Notice_source();
    2168. 

  2168.                     $ns->code = $this->source;
    2169. 

  2169.                     $app = Oauth_application::staticGet('name', $this->source);
    2170. 

  2170.                     if ($app) {
    2171. 

  2171.                         $ns->name = $app->name;
    2172. 

  2172.                         $ns->url  = $app->source_url;
    2173. 

  2173.                     }
    2174. 

  2174.                 }
    2175. 

  2175.                 break;
    2176. 

  2176.             }
    2177. 

  2177.         }
    2178. 

  2178.         return $ns;
    2179. 

  2179.     }
    2180. 

  2180. 

  2181.     /**
    2182. 

  2182.      * Determine whether the notice was locally created
    2183. 

  2183.      *
    2184. 

  2184.      * @return boolean locality
    2185. 

  2185.      */
    2186. 

  2186. 

  2187.     public function isLocal()
    2188. 

  2188.     {
    2189. 

  2189.         return ($this->is_local == Notice::LOCAL_PUBLIC ||
    2190. 

  2190.                 $this->is_local == Notice::LOCAL_NONPUBLIC);
    2191. 

  2191.     }
    2192. 

  2192. 

  2193.     /**
    2194. 

  2194.      * Get the list of hash tags saved with this notice.
    2195. 

  2195.      *
    2196. 

  2196.      * @return array of strings
    2197. 

  2197.      */
    2198. 

  2198.     public function getTags()
    2199. 

  2199.     {
    2200. 

  2200.         $tags = array();
    2201. 

  2201. 

  2202.         $keypart = sprintf('notice:tags:%d', $this->id);
    2203. 

  2203. 

  2204.         $tagstr = self::cacheGet($keypart);
    2205. 

  2205. 

  2206.         if ($tagstr !== false) {
    2207. 

  2207.             $tags = explode(',', $tagstr);
    2208. 

  2208.         } else {
    2209. 

  2209.             $tag = new Notice_tag();
    2210. 

  2210.             $tag->notice_id = $this->id;
    2211. 

  2211.             if ($tag->find()) {
    2212. 

  2212.                 while ($tag->fetch()) {
    2213. 

  2213.                     $tags[] = $tag->tag;
    2214. 

  2214.                 }
    2215. 

  2215.             }
    2216. 

  2216.             self::cacheSet($keypart, implode(',', $tags));
    2217. 

  2217.         }
    2218. 

  2218. 

  2219.         return $tags;
    2220. 

  2220.     }
    2221. 

  2221. 

  2222.     static private function utcDate($dt)
    2223. 

  2223.     {
    2224. 

  2224.         $dateStr = date('d F Y H:i:s', strtotime($dt));
    2225. 

  2225.         $d = new DateTime($dateStr, new DateTimeZone('UTC'));
    2226. 

  2226.         return $d->format(DATE_W3C);
    2227. 

  2227.     }
    2228. 

  2228. 

  2229.     /**
    2230. 

  2230.      * Look up the creation timestamp for a given notice ID, even
    2231. 

  2231.      * if it's been deleted.
    2232. 

  2232.      *
    2233. 

  2233.      * @param int $id
    2234. 

  2234.      * @return mixed string recorded creation timestamp, or false if can't be found
    2235. 

  2235.      */
    2236. 

  2236.     public static function getAsTimestamp($id)
    2237. 

  2237.     {
    2238. 

  2238.         if (!$id) {
    2239. 

  2239.             return false;
    2240. 

  2240.         }
    2241. 

  2241. 

  2242.         $notice = Notice::staticGet('id', $id);
    2243. 

  2243.         if ($notice) {
    2244. 

  2244.             return $notice->created;
    2245. 

  2245.         }
    2246. 

  2246. 

  2247.         $deleted = Deleted_notice::staticGet('id', $id);
    2248. 

  2248.         if ($deleted) {
    2249. 

  2249.             return $deleted->created;
    2250. 

  2250.         }
    2251. 

  2251. 

  2252.         return false;
    2253. 

  2253.     }
    2254. 

  2254. 

  2255.     /**
    2256. 

  2256.      * Build an SQL 'where' fragment for timestamp-based sorting from a since_id
    2257. 

  2257.      * parameter, matching notices posted after the given one (exclusive).
    2258. 

  2258.      *
    2259. 

  2259.      * If the referenced notice can't be found, will return false.
    2260. 

  2260.      *
    2261. 

  2261.      * @param int $id
    2262. 

  2262.      * @param string $idField
    2263. 

  2263.      * @param string $createdField
    2264. 

  2264.      * @return mixed string or false if no match
    2265. 

  2265.      */
    2266. 

  2266.     public static function whereSinceId($id, $idField='id', $createdField='created')
    2267. 

  2267.     {
    2268. 

  2268.         $since = Notice::getAsTimestamp($id);
    2269. 

  2269.         if ($since) {
    2270. 

  2270.             return sprintf("($createdField = '%s' and $idField > %d) or ($createdField > '%s')", $since, $id, $since);
    2271. 

  2271.         }
    2272. 

  2272.         return false;
    2273. 

  2273.     }
    2274. 

  2274. 

  2275.     /**
    2276. 

  2276.      * Build an SQL 'where' fragment for timestamp-based sorting from a since_id
    2277. 

  2277.      * parameter, matching notices posted after the given one (exclusive), and
    2278. 

  2278.      * if necessary add it to the data object's query.
    2279. 

  2279.      *
    2280. 

  2280.      * @param DB_DataObject $obj
    2281. 

  2281.      * @param int $id
    2282. 

  2282.      * @param string $idField
    2283. 

  2283.      * @param string $createdField
    2284. 

  2284.      * @return mixed string or false if no match
    2285. 

  2285.      */
    2286. 

  2286.     public static function addWhereSinceId(DB_DataObject $obj, $id, $idField='id', $createdField='created')
    2287. 

  2287.     {
    2288. 

  2288.         $since = self::whereSinceId($id, $idField, $createdField);
    2289. 

  2289.         if ($since) {
    2290. 

  2290.             $obj->whereAdd($since);
    2291. 

  2291.         }
    2292. 

  2292.     }
    2293. 

  2293. 

  2294.     /**
    2295. 

  2295.      * Build an SQL 'where' fragment for timestamp-based sorting from a max_id
    2296. 

  2296.      * parameter, matching notices posted before the given one (inclusive).
    2297. 

  2297.      *
    2298. 

  2298.      * If the referenced notice can't be found, will return false.
    2299. 

  2299.      *
    2300. 

  2300.      * @param int $id
    2301. 

  2301.      * @param string $idField
    2302. 

  2302.      * @param string $createdField
    2303. 

  2303.      * @return mixed string or false if no match
    2304. 

  2304.      */
    2305. 

  2305.     public static function whereMaxId($id, $idField='id', $createdField='created')
    2306. 

  2306.     {
    2307. 

  2307.         $max = Notice::getAsTimestamp($id);
    2308. 

  2308.         if ($max) {
    2309. 

  2309.             return sprintf("($createdField < '%s') or ($createdField = '%s' and $idField <= %d)", $max, $max, $id);
    2310. 

  2310.         }
    2311. 

  2311.         return false;
    2312. 

  2312.     }
    2313. 

  2313. 

  2314.     /**
    2315. 

  2315.      * Build an SQL 'where' fragment for timestamp-based sorting from a max_id
    2316. 

  2316.      * parameter, matching notices posted before the given one (inclusive), and
    2317. 

  2317.      * if necessary add it to the data object's query.
    2318. 

  2318.      *
    2319. 

  2319.      * @param DB_DataObject $obj
    2320. 

  2320.      * @param int $id
    2321. 

  2321.      * @param string $idField
    2322. 

  2322.      * @param string $createdField
    2323. 

  2323.      * @return mixed string or false if no match
    2324. 

  2324.      */
    2325. 

  2325.     public static function addWhereMaxId(DB_DataObject $obj, $id, $idField='id', $createdField='created')
    2326. 

  2326.     {
    2327. 

  2327.         $max = self::whereMaxId($id, $idField, $createdField);
    2328. 

  2328.         if ($max) {
    2329. 

  2329.             $obj->whereAdd($max);
    2330. 

  2330.         }
    2331. 

  2331.     }
    2332. 

  2332. 

  2333.     function isPublic()
    2334. 

  2334.     {
    2335. 

  2335.         if (common_config('public', 'localonly')) {
    2336. 

  2336.             return ($this->is_local == Notice::LOCAL_PUBLIC);
    2337. 

  2337.         } else {
    2338. 

  2338.             return (($this->is_local != Notice::LOCAL_NONPUBLIC) &&
    2339. 

  2339.                     ($this->is_local != Notice::GATEWAY));
    2340. 

  2340.         }
    2341. 

  2341.     }
    2342. 

  2342. 

  2343.     /**
    2344. 

  2344.      * Check that the given profile is allowed to read, respond to, or otherwise
    2345. 

  2345.      * act on this notice.
    2346. 

  2346.      *
    2347. 

  2347.      * The $scope member is a bitmask of scopes, representing a logical AND of the
    2348. 

  2348.      * scope requirement. So, 0x03 (Notice::ADDRESSEE_SCOPE | Notice::SITE_SCOPE) means
    2349. 

  2349.      * "only visible to people who are mentioned in the notice AND are users on this site."
    2350. 

  2350.      * Users on the site who are not mentioned in the notice will not be able to see the
    2351. 

  2351.      * notice.
    2352. 

  2352.      *
    2353. 

  2353.      * @param Profile $profile The profile to check; pass null to check for public/unauthenticated users.
    2354. 

  2354.      *
    2355. 

  2355.      * @return boolean whether the profile is in the notice's scope
    2356. 

  2356.      */
    2357. 

  2357.     function inScope($profile)
    2358. 

  2358.     {
    2359. 

  2359.         if (is_null($profile)) {
    2360. 

  2360.             $keypart = sprintf('notice:in-scope-for:%d:null', $this->id);
    2361. 

  2361.         } else {
    2362. 

  2362.             $keypart = sprintf('notice:in-scope-for:%d:%d', $this->id, $profile->id);
    2363. 

  2363.         }
    2364. 

  2364. 

  2365.         $result = self::cacheGet($keypart);
    2366. 

  2366. 

  2367.         if ($result === false) {
    2368. 

  2368.             $bResult = false;
    2369. 

  2369.             if (Event::handle('StartNoticeInScope', array($this, $profile, &$bResult))) {
    2370. 

  2370.                 $bResult = $this->_inScope($profile);
    2371. 

  2371.                 Event::handle('EndNoticeInScope', array($this, $profile, &$bResult));
    2372. 

  2372.             }
    2373. 

  2373.             $result = ($bResult) ? 1 : 0;
    2374. 

  2374.             self::cacheSet($keypart, $result, 0, 300);
    2375. 

  2375.         }
    2376. 

  2376. 

  2377.         return ($result == 1) ? true : false;
    2378. 

  2378.     }
    2379. 

  2379. 

  2380.     protected function _inScope($profile)
    2381. 

  2381.     {
    2382. 

  2382.         if (!is_null($this->scope)) {
    2383. 

  2383.             $scope = $this->scope;
    2384. 

  2384.         } else {
    2385. 

  2385.             $scope = self::defaultScope();
    2386. 

  2386.         }
    2387. 

  2387. 

  2388.         // If there's no scope, anyone (even anon) is in scope.
    2389. 

  2389. 

  2390.         if ($scope == 0) { // Not private
    2391. 

  2391. 

  2392.             return !$this->isHiddenSpam($profile);
    2393. 

  2393. 

  2394.         } else { // Private, somehow
    2395. 

  2395. 

  2396.             // If there's scope, anon cannot be in scope
    2397. 

  2397. 

  2398.             if (empty($profile)) {
    2399. 

  2399.                 return false;
    2400. 

  2400.             }
    2401. 

  2401. 

  2402.             // Author is always in scope
    2403. 

  2403. 

  2404.             if ($this->profile_id == $profile->id) {
    2405. 

  2405.                 return true;
    2406. 

  2406.             }
    2407. 

  2407. 

  2408.             // Only for users on this site
    2409. 

  2409. 

  2410.             if ($scope & Notice::SITE_SCOPE) {
    2411. 

  2411.                 $user = $profile->getUser();
    2412. 

  2412.                 if (empty($user)) {
    2413. 

  2413.                     return false;
    2414. 

  2414.                 }
    2415. 

  2415.             }
    2416. 

  2416. 

  2417.             // Only for users mentioned in the notice
    2418. 

  2418. 

  2419.             if ($scope & Notice::ADDRESSEE_SCOPE) {
    2420. 

  2420. 

  2421.                 $repl = Reply::pkeyGet(array('notice_id' => $this->id,
    2422. 

  2422.                                              'profile_id' => $profile->id));
    2423. 

  2423. 										 
    2424. 

  2424.                 if (empty($repl)) {
    2425. 

  2425.                     return false;
    2426. 

  2426.                 }
    2427. 

  2427.             }
    2428. 

  2428. 

  2429.             // Only for members of the given group
    2430. 

  2430. 

  2431.             if ($scope & Notice::GROUP_SCOPE) {
    2432. 

  2432. 

  2433.                 // XXX: just query for the single membership
    2434. 

  2434. 

  2435.                 $groups = $this->getGroups();
    2436. 

  2436. 

  2437.                 $foundOne = false;
    2438. 

  2438. 

  2439.                 foreach ($groups as $group) {
    2440. 

  2440.                     if ($profile->isMember($group)) {
    2441. 

  2441.                         $foundOne = true;
    2442. 

  2442.                         break;
    2443. 

  2443.                     }
    2444. 

  2444.                 }
    2445. 

  2445. 

  2446.                 if (!$foundOne) {
    2447. 

  2447.                     return false;
    2448. 

  2448.                 }
    2449. 

  2449.             }
    2450. 

  2450. 

  2451.             // Only for followers of the author
    2452. 

  2452. 

  2453.             $author = null;
    2454. 

  2454. 

  2455.             if ($scope & Notice::FOLLOWER_SCOPE) {
    2456. 

  2456. 

  2457.                 try {
    2458. 

  2458.                     $author = $this->getProfile();
    2459. 

  2459.                 } catch (Exception $e) {
    2460. 

  2460.                     return false;
    2461. 

  2461.                 }
    2462. 

  2462.         
    2463. 

  2463.                 if (!Subscription::exists($profile, $author)) {
    2464. 

  2464.                     return false;
    2465. 

  2465.                 }
    2466. 

  2466.             }
    2467. 

  2467. 

  2468.             return !$this->isHiddenSpam($profile);
    2469. 

  2469.         }
    2470. 

  2470.     }
    2471. 

  2471. 

  2472.     function isHiddenSpam($profile) {
    2473. 

  2473.         
    2474. 

  2474.         // Hide posts by silenced users from everyone but moderators.
    2475. 

  2475. 

  2476.         if (common_config('notice', 'hidespam')) {
    2477. 

  2477. 

  2478.             try {
    2479. 

  2479.                 $author = $this->getProfile();
    2480. 

  2480.             } catch(Exception $e) {
    2481. 

  2481.                 // If we can't get an author, keep it hidden.
    2482. 

  2482.                 // XXX: technically not spam, but, whatever.
    2483. 

  2483.                 return true;
    2484. 

  2484.             }
    2485. 

  2485. 

  2486.             if ($author->hasRole(Profile_role::SILENCED)) {
    2487. 

  2487.                 if (empty($profile) || (($profile->id !== $author->id) && (!$profile->hasRight(Right::REVIEWSPAM)))) {
    2488. 

  2488.                     return true;
    2489. 

  2489.                 }
    2490. 

  2490.             }
    2491. 

  2491.         }
    2492. 

  2492. 

  2493.         return false;
    2494. 

  2494.     }
    2495. 

  2495. 

  2496.     static function groupsFromText($text, $profile)
    2497. 

  2497.     {
    2498. 

  2498.         $groups = array();
    2499. 

  2499. 

  2500.         /* extract all !group */
    2501. 

  2501.         $count = preg_match_all('/(?:^|\s)!(' . Nickname::DISPLAY_FMT . ')/',
    2502. 

  2502.                                 strtolower($text),
    2503. 

  2503.                                 $match);
    2504. 

  2504. 

  2505.         if (!$count) {
    2506. 

  2506.             return $groups;
    2507. 

  2507.         }
    2508. 

  2508. 

  2509.         foreach (array_unique($match[1]) as $nickname) {
    2510. 

  2510.             $group = User_group::getForNickname($nickname, $profile);
    2511. 

  2511.             if (!empty($group) && $profile->isMember($group)) {
    2512. 

  2512.                 $groups[] = $group->id;
    2513. 

  2513.             }
    2514. 

  2514.         }
    2515. 

  2515. 

  2516.         return $groups;
    2517. 

  2517.     }
    2518. 

  2518. 

  2519.     protected $_original = -1;
    2520. 

  2520. 

  2521.     function getOriginal()
    2522. 

  2522.     {
    2523. 

  2523.         if (is_int($this->_original) && $this->_original == -1) {
    2524. 

  2524.             if (empty($this->reply_to)) {
    2525. 

  2525.                 $this->_original = null;
    2526. 

  2526.             } else {
    2527. 

  2527.                 $this->_original = Notice::staticGet('id', $this->reply_to);
    2528. 

  2528.             }
    2529. 

  2529.         }
    2530. 

  2530.         return $this->_original;
    2531. 

  2531.     }
    2532. 

  2532. 

  2533.     /**
    2534. 

  2534.      * Magic function called at serialize() time.
    2535. 

  2535.      *
    2536. 

  2536.      * We use this to drop a couple process-specific references
    2537. 

  2537.      * from DB_DataObject which can cause trouble in future
    2538. 

  2538.      * processes.
    2539. 

  2539.      *
    2540. 

  2540.      * @return array of variable names to include in serialization.
    2541. 

  2541.      */
    2542. 

  2542. 

  2543.     function __sleep()
    2544. 

  2544.     {
    2545. 

  2545.         $vars = parent::__sleep();
    2546. 

  2546.         $skip = array('_original', '_profile', '_groups', '_attachments', '_faves', '_replies', '_repeats');
    2547. 

  2547.         return array_diff($vars, $skip);
    2548. 

  2548.     }
    2549. 

  2549.     
    2550. 

  2550.     static function defaultScope()
    2551. 

  2551.     {
    2552. 

  2552.     	$scope = common_config('notice', 'defaultscope');
    2553. 

  2553.     	if (is_null($scope)) {
    2554. 

  2554.     		if (common_config('site', 'private')) {
    2555. 

  2555.     			$scope = 1;
    2556. 

  2556.     		} else {
    2557. 

  2557.     			$scope = 0;
    2558. 

  2558.     		}
    2559. 

  2559.     	}
    2560. 

  2560.     	return $scope;
    2561. 

  2561.     }
    2562. 

  2562. 

  2563. 	static function fillProfiles($notices)
    2564. 

  2564. 	{
    2565. 

  2565. 		$map = self::getProfiles($notices);
    2566. 

  2566. 		
    2567. 

  2567. 		foreach ($notices as $notice) {
    2568. 

  2568. 			if (array_key_exists($notice->profile_id, $map)) {
    2569. 

  2569. 				$notice->_setProfile($map[$notice->profile_id]);    
    2570. 

  2570. 			}
    2571. 

  2571. 		}
    2572. 

  2572. 		
    2573. 

  2573. 		return array_values($map);
    2574. 

  2574. 	}
    2575. 

  2575. 	
    2576. 

  2576. 	static function getProfiles(&$notices)
    2577. 

  2577. 	{
    2578. 

  2578. 		$ids = array();
    2579. 

  2579. 		foreach ($notices as $notice) {
    2580. 

  2580. 			$ids[] = $notice->profile_id;
    2581. 

  2581. 		}
    2582. 

  2582. 		
    2583. 

  2583. 		$ids = array_unique($ids);
    2584. 

  2584. 		
    2585. 

  2585. 		return Memcached_DataObject::pivotGet('Profile', 'id', $ids); 
    2586. 

  2586. 	}
    2587. 

  2587. 	
    2588. 

  2588. 	static function fillGroups(&$notices)
    2589. 

  2589. 	{
    2590. 

  2590.         $ids = self::_idsOf($notices);
    2591. 

  2591. 		
    2592. 

  2592. 		$gis = Memcached_DataObject::listGet('Group_inbox', 'notice_id', $ids);
    2593. 

  2593. 		
    2594. 

  2594.         $gids = array();
    2595. 

  2595. 

  2596. 		foreach ($gis as $id => $gi)
    2597. 

  2597. 		{
    2598. 

  2598. 		    foreach ($gi as $g)
    2599. 

  2599. 		    {
    2600. 

  2600. 		        $gids[] = $g->group_id;
    2601. 

  2601. 		    }
    2602. 

  2602. 		}
    2603. 

  2603. 		
    2604. 

  2604. 		$gids = array_unique($gids);
    2605. 

  2605. 		
    2606. 

  2606. 		$group = Memcached_DataObject::pivotGet('User_group', 'id', $gids);
    2607. 

  2607. 		
    2608. 

  2608. 		foreach ($notices as $notice)
    2609. 

  2609. 		{
    2610. 

  2610. 			$grps = array();
    2611. 

  2611. 			$gi = $gis[$notice->id];
    2612. 

  2612. 			foreach ($gi as $g) {
    2613. 

  2613. 			    $grps[] = $group[$g->group_id];
    2614. 

  2614. 			}
    2615. 

  2615. 		    $notice->_setGroups($grps);
    2616. 

  2616. 		}
    2617. 

  2617. 	}
    2618. 

  2618. 

  2619.     static function _idsOf(&$notices)
    2620. 

  2620.     {
    2621. 

  2621. 		$ids = array();
    2622. 

  2622. 		foreach ($notices as $notice) {
    2623. 

  2623. 			$ids[] = $notice->id;
    2624. 

  2624. 		}
    2625. 

  2625. 		$ids = array_unique($ids);
    2626. 

  2626.         return $ids;
    2627. 

  2627.     }
    2628. 

  2628. 

  2629.     static function fillAttachments(&$notices)
    2630. 

  2630.     {
    2631. 

  2631.         $ids = self::_idsOf($notices);
    2632. 

  2632. 

  2633. 		$f2pMap = Memcached_DataObject::listGet('File_to_post', 'post_id', $ids);
    2634. 

  2634. 		
    2635. 

  2635. 		$fileIds = array();
    2636. 

  2636. 		
    2637. 

  2637. 		foreach ($f2pMap as $noticeId => $f2ps) {
    2638. 

  2638.             foreach ($f2ps as $f2p) {
    2639. 

  2639.                 $fileIds[] = $f2p->file_id;    
    2640. 

  2640.             }
    2641. 

  2641.         }
    2642. 

  2642. 

  2643.         $fileIds = array_unique($fileIds);
    2644. 

  2644. 

  2645. 		$fileMap = Memcached_DataObject::pivotGet('File', 'id', $fileIds);
    2646. 

  2646. 

  2647. 		foreach ($notices as $notice)
    2648. 

  2648. 		{
    2649. 

  2649. 			$files = array();
    2650. 

  2650. 			$f2ps = $f2pMap[$notice->id];
    2651. 

  2651. 			foreach ($f2ps as $f2p) {
    2652. 

  2652. 			    $files[] = $fileMap[$f2p->file_id];
    2653. 

  2653. 			}
    2654. 

  2654. 		    $notice->_setAttachments($files);
    2655. 

  2655. 		}
    2656. 

  2656.     }
    2657. 

  2657. 

  2658.     protected $_faves;
    2659. 

  2659. 

  2660.     /**
    2661. 

  2661.      * All faves of this notice
    2662. 

  2662.      *
    2663. 

  2663.      * @return array Array of Fave objects
    2664. 

  2664.      */
    2665. 

  2665. 

  2666.     function getFaves()
    2667. 

  2667.     {
    2668. 

  2668.         if (isset($this->_faves) && is_array($this->_faves)) {
    2669. 

  2669.             return $this->_faves;
    2670. 

  2670.         }
    2671. 

  2671.         $faveMap = Memcached_DataObject::listGet('Fave', 'notice_id', array($this->id));
    2672. 

  2672.         $this->_faves = $faveMap[$this->id];
    2673. 

  2673.         return $this->_faves;
    2674. 

  2674.     }
    2675. 

  2675. 

  2676.     function _setFaves($faves)
    2677. 

  2677.     {
    2678. 

  2678.         $this->_faves = $faves;
    2679. 

  2679.     }
    2680. 

  2680. 

  2681.     static function fillFaves(&$notices)
    2682. 

  2682.     {
    2683. 

  2683.         $ids = self::_idsOf($notices);
    2684. 

  2684.         $faveMap = Memcached_DataObject::listGet('Fave', 'notice_id', $ids);
    2685. 

  2685.         $cnt = 0;
    2686. 

  2686.         $faved = array();
    2687. 

  2687.         foreach ($faveMap as $id => $faves) {
    2688. 

  2688.             $cnt += count($faves);
    2689. 

  2689.             if (count($faves) > 0) {
    2690. 

  2690.                 $faved[] = $id;
    2691. 

  2691.             }
    2692. 

  2692.         }
    2693. 

  2693.         foreach ($notices as $notice) {
    2694. 

  2694.         	$faves = $faveMap[$notice->id];
    2695. 

  2695.             $notice->_setFaves($faves);
    2696. 

  2696.         }
    2697. 

  2697.     }
    2698. 

  2698. 

  2699.     static function fillReplies(&$notices)
    2700. 

  2700.     {
    2701. 

  2701.         $ids = self::_idsOf($notices);
    2702. 

  2702.         $replyMap = Memcached_DataObject::listGet('Reply', 'notice_id', $ids);
    2703. 

  2703.         foreach ($notices as $notice) {
    2704. 

  2704.             $replies = $replyMap[$notice->id];
    2705. 

  2705.             $ids = array();
    2706. 

  2706.             foreach ($replies as $reply) {
    2707. 

  2707.                 $ids[] = $reply->profile_id;
    2708. 

  2708.             }
    2709. 

  2709.             $notice->_setReplies($ids);
    2710. 

  2710.         }
    2711. 

  2711.     }
    2712. 

  2712. 

  2713.     protected $_repeats;
    2714. 

  2714. 

  2715.     function getRepeats()
    2716. 

  2716.     {
    2717. 

  2717.         if (isset($this->_repeats) && is_array($this->_repeats)) {
    2718. 

  2718.             return $this->_repeats;
    2719. 

  2719.         }
    2720. 

  2720.         $repeatMap = Memcached_DataObject::listGet('Notice', 'repeat_of', array($this->id));
    2721. 

  2721.         $this->_repeats = $repeatMap[$this->id];
    2722. 

  2722.         return $this->_repeats;
    2723. 

  2723.     }
    2724. 

  2724. 

  2725.     function _setRepeats($repeats)
    2726. 

  2726.     {
    2727. 

  2727.         $this->_repeats = $repeats;
    2728. 

  2728.     }
    2729. 

  2729. 

  2730.     static function fillRepeats(&$notices)
    2731. 

  2731.     {
    2732. 

  2732.         $ids = self::_idsOf($notices);
    2733. 

  2733.         $repeatMap = Memcached_DataObject::listGet('Notice', 'repeat_of', $ids);
    2734. 

  2734.         foreach ($notices as $notice) {
    2735. 

  2735.         	$repeats = $repeatMap[$notice->id];
    2736. 

  2736.             $notice->_setRepeats($repeats);
    2737. 

  2737.         }
    2738. 

  2738.     }
    2739. 

  2739. }
    2740. 

  2740.