]> git.mxchange.org Git - quix0rs-gnu-social.git/blobdiff - classes/Notice.php
Save attentions to Reply table for backwards compatibility
[quix0rs-gnu-social.git] / classes / Notice.php
index aadfc78cd06c790a765b814ae4f9bc258858b687..6781918be4ae410e2b654466673ff0bbee31f859 100644 (file)
@@ -55,23 +55,19 @@ class Notice extends Managed_DataObject
     public $__table = 'notice';                          // table name
     public $id;                              // int(4)  primary_key not_null
     public $profile_id;                      // int(4)  multiple_key not_null
-    public $uri;                             // varchar(255)  unique_key
+    public $uri;                             // varchar(191)  unique_key   not 255 because utf8mb4 takes more space
     public $content;                         // text
     public $rendered;                        // text
-    public $url;                             // varchar(255)
+    public $url;                             // varchar(191)   not 255 because utf8mb4 takes more space
     public $created;                         // datetime  multiple_key not_null default_0000-00-00%2000%3A00%3A00
     public $modified;                        // timestamp   not_null default_CURRENT_TIMESTAMP
     public $reply_to;                        // int(4)
     public $is_local;                        // int(4)
     public $source;                          // varchar(32)
     public $conversation;                    // int(4)
-    public $lat;                             // decimal(10,7)
-    public $lon;                             // decimal(10,7)
-    public $location_id;                     // int(4)
-    public $location_ns;                     // int(4)
     public $repeat_of;                       // int(4)
-    public $verb;                            // varchar(255)
-    public $object_type;                     // varchar(255)
+    public $verb;                            // varchar(191)   not 255 because utf8mb4 takes more space
+    public $object_type;                     // varchar(191)   not 255 because utf8mb4 takes more space
     public $scope;                           // int(4)
 
     /* the code above is auto generated do not remove the tag below */
@@ -83,23 +79,19 @@ class Notice extends Managed_DataObject
             'fields' => array(
                 'id' => array('type' => 'serial', 'not null' => true, 'description' => 'unique identifier'),
                 'profile_id' => array('type' => 'int', 'not null' => true, 'description' => 'who made the update'),
-                'uri' => array('type' => 'varchar', 'length' => 255, 'description' => 'universally unique identifier, usually a tag URI'),
-                'content' => array('type' => 'text', 'description' => 'update content', 'collate' => 'utf8_general_ci'),
+                'uri' => array('type' => 'varchar', 'length' => 191, 'description' => 'universally unique identifier, usually a tag URI'),
+                'content' => array('type' => 'text', 'description' => 'update content', 'collate' => 'utf8mb4_general_ci'),
                 'rendered' => array('type' => 'text', 'description' => 'HTML version of the content'),
-                'url' => array('type' => 'varchar', 'length' => 255, 'description' => 'URL of any attachment (image, video, bookmark, whatever)'),
+                'url' => array('type' => 'varchar', 'length' => 191, 'description' => 'URL of any attachment (image, video, bookmark, whatever)'),
                 'created' => array('type' => 'datetime', 'not null' => true, 'description' => 'date this record was created'),
                 'modified' => array('type' => 'timestamp', 'not null' => true, 'description' => 'date this record was modified'),
                 'reply_to' => array('type' => 'int', 'description' => 'notice replied to (usually a guess)'),
                 'is_local' => array('type' => 'int', 'size' => 'tiny', 'default' => 0, 'description' => 'notice was generated by a user'),
                 'source' => array('type' => 'varchar', 'length' => 32, 'description' => 'source of comment, like "web", "im", or "clientname"'),
                 'conversation' => array('type' => 'int', 'description' => 'id of root notice in this conversation'),
-                'lat' => array('type' => 'numeric', 'precision' => 10, 'scale' => 7, 'description' => 'latitude'),
-                'lon' => array('type' => 'numeric', 'precision' => 10, 'scale' => 7, 'description' => 'longitude'),
-                'location_id' => array('type' => 'int', 'description' => 'location id if possible'),
-                'location_ns' => array('type' => 'int', 'description' => 'namespace for location'),
                 'repeat_of' => array('type' => 'int', 'description' => 'notice this is a repeat of'),
-                'object_type' => array('type' => 'varchar', 'length' => 255, 'description' => 'URI representing activity streams object type', 'default' => 'http://activitystrea.ms/schema/1.0/note'),
-                'verb' => array('type' => 'varchar', 'length' => 255, 'description' => 'URI representing activity streams verb', 'default' => 'http://activitystrea.ms/schema/1.0/post'),
+                'object_type' => array('type' => 'varchar', 'length' => 191, 'description' => 'URI representing activity streams object type', 'default' => null),
+                'verb' => array('type' => 'varchar', 'length' => 191, 'description' => 'URI representing activity streams verb', 'default' => 'http://activitystrea.ms/schema/1.0/post'),
                 'scope' => array('type' => 'int',
                                  'description' => 'bit map for distribution scope; 0 = everywhere; 1 = this server only; 2 = addressees; 4 = followers; null = default'),
             ),
@@ -118,6 +110,7 @@ class Notice extends Managed_DataObject
                 'notice_profile_id_idx' => array('profile_id', 'created', 'id'),
                 'notice_repeat_of_created_id_idx' => array('repeat_of', 'created', 'id'),
                 'notice_conversation_created_id_idx' => array('conversation', 'created', 'id'),
+                'notice_verb_idx' => array('verb'),
                 'notice_replyto_idx' => array('reply_to')
             )
         );
@@ -128,7 +121,7 @@ class Notice extends Managed_DataObject
 
         return $def;
     }
-       
+
     /* Notice types */
     const LOCAL_PUBLIC    =  1;
     const REMOTE          =  0;
@@ -141,64 +134,61 @@ class Notice extends Managed_DataObject
     const GROUP_SCOPE     = 4;
     const FOLLOWER_SCOPE  = 8;
 
-    protected $_profile = -1;
-    
+    protected $_profile = array();
+
+    /**
+     * Will always return a profile, if anything fails it will
+     * (through _setProfile) throw a NoProfileException.
+     */
     public function getProfile()
     {
-        if ($this->_profile === -1) {
-            $this->_setProfile(Profile::getKV('id', $this->profile_id));
+        if (!isset($this->_profile[$this->profile_id])) {
+            // We could've sent getKV directly to _setProfile, but occasionally we get
+            // a "false" (instead of null), likely because it indicates a cache miss.
+            $profile = Profile::getKV('id', $this->profile_id);
+            $this->_setProfile($profile instanceof Profile ? $profile : null);
         }
-        return $this->_profile;
+        return $this->_profile[$this->profile_id];
     }
-    
+
     public function _setProfile(Profile $profile=null)
     {
         if (!$profile instanceof Profile) {
             throw new NoProfileException($this->profile_id);
         }
-        $this->_profile = $profile;
+        $this->_profile[$this->profile_id] = $profile;
     }
 
-    function delete($useWhere=false)
+    public function deleteAs(Profile $actor, $delete_event=true)
     {
-        // For auditing purposes, save a record that the notice
-        // was deleted.
-
-        // @fixme we have some cases where things get re-run and so the
-        // insert fails.
-        $deleted = Deleted_notice::getKV('id', $this->id);
-
-        if (!$deleted instanceof Deleted_notice) {
-            $deleted = Deleted_notice::getKV('uri', $this->uri);
-        }
-
-        if (!$deleted instanceof Deleted_notice) {
-            $deleted = new Deleted_notice();
-
-            $deleted->id         = $this->id;
-            $deleted->profile_id = $this->profile_id;
-            $deleted->uri        = $this->uri;
-            $deleted->created    = $this->created;
-            $deleted->deleted    = common_sql_now();
-
-            $deleted->insert();
+        if (!$this->getProfile()->sameAs($actor) && !$actor->hasRight(Right::DELETEOTHERSNOTICE)) {
+            throw new AuthorizationException(_('You are not allowed to delete another user\'s notice.'));
         }
 
         if (Event::handle('NoticeDeleteRelated', array($this))) {
-
             // Clear related records
-
             $this->clearReplies();
+            $this->clearLocation();
             $this->clearRepeats();
-            $this->clearFaves();
             $this->clearTags();
             $this->clearGroupInboxes();
             $this->clearFiles();
             $this->clearAttentions();
-
             // NOTE: we don't clear queue items
         }
 
+        $result = null;
+        if (!$delete_event || Event::handle('DeleteNoticeAsProfile', array($this, $actor, &$result))) {
+            // If $delete_event is true, we run the event. If the Event then 
+            // returns false it is assumed everything was handled properly 
+            // and the notice was deleted.
+            $result = $this->delete();
+        }
+        return $result;
+    }
+
+    public function delete($useWhere=false)
+    {
         $result = parent::delete($useWhere);
 
         $this->blowOnDelete();
@@ -210,24 +200,105 @@ class Notice extends Managed_DataObject
         return $this->uri;
     }
 
-    public function getUrl()
+    /*
+     * Get a Notice object by URI. Will call external plugins for help
+     * using the event StartGetNoticeFromURI.
+     *
+     * @param string $uri A unique identifier for a resource (notice in this case)
+     */
+    static function fromUri($uri)
+    {
+        $notice = null;
+
+        if (Event::handle('StartGetNoticeFromUri', array($uri, &$notice))) {
+            $notice = Notice::getKV('uri', $uri);
+            Event::handle('EndGetNoticeFromUri', array($uri, $notice));
+        }
+
+        if (!$notice instanceof Notice) {
+            throw new UnknownUriException($uri);
+        }
+
+        return $notice;
+    }
+
+    /*
+     * @param $root boolean If true, link to just the conversation root.
+     *
+     * @return URL to conversation
+     */
+    public function getConversationUrl($anchor=true)
+    {
+        return Conversation::getUrlFromNotice($this, $anchor);
+    }
+
+    /*
+     * Get the local representation URL of this notice.
+     */
+    public function getLocalUrl()
+    {
+        return common_local_url('shownotice', array('notice' => $this->id), null, null, false);
+    }
+
+    public function getTitle()
+    {
+        $title = null;
+        if (Event::handle('GetNoticeTitle', array($this, &$title))) {
+            // TRANS: Title of a notice posted without a title value.
+            // TRANS: %1$s is a user name, %2$s is the notice creation date/time.
+            $title = sprintf(_('%1$s\'s status on %2$s'),
+                             $this->getProfile()->getFancyName(),
+                             common_exact_date($this->created));
+        }
+        return $title;
+    }
+
+    public function getContent()
+    {
+        return $this->content;
+    }
+
+    public function getRendered()
+    {
+        if (is_null($this->rendered) || $this->rendered === '') {
+            // update to include rendered content on-the-fly, so we don't have to have a fix-up script in upgrade.php
+            common_debug('Rendering notice '.$this->getID().' as it had no rendered HTML content.');
+            $orig = clone($this);
+            $this->rendered = common_render_content($this->getContent(),
+                                                    $this->getProfile(),
+                                                    $this->hasParent() ? $this->getParent() : null);
+            $this->update($orig);
+        }
+        return $this->rendered;
+    }
+
+    /*
+     * Get the original representation URL of this notice.
+     *
+     * @param boolean $fallback     Whether to fall back to generate a local URL or throw InvalidUrlException
+     */
+    public function getUrl($fallback=false)
     {
         // The risk is we start having empty urls and non-http uris...
         // and we can't really handle any other protocol right now.
         switch (true) {
-        case common_valid_http_url($this->url):
+        case $this->isLocal():
+            return common_local_url('shownotice', array('notice' => $this->getID()), null, null, false);
+        case common_valid_http_url($this->url): // should we allow non-http/https URLs?
             return $this->url;
-        case common_valid_http_url($this->uri):
+        case common_valid_http_url($this->uri): // Sometimes we only have the URI for remote posts.
             return $this->uri;
+        case $fallback:
+            // let's generate a valid link to our locally available notice on demand
+            return common_local_url('shownotice', array('notice' => $this->getID()), null, null, false);
         default:
-            throw new ServerException('No URL available for notice.');
+            common_debug('No URL available for notice: id='.$this->getID());
+            throw new InvalidUrlException($this->url);
         }
     }
 
-    public function get_object_type($canonical=false) {
-        return $canonical
-                ? ActivityObject::canonicalType($this->object_type)
-                : $this->object_type;
+    public function getObjectType($canonical=false) {
+        return ActivityUtils::resolveUri($this->object_type, $canonical);
     }
 
     public static function getByUri($uri)
@@ -346,8 +417,9 @@ class Notice extends Managed_DataObject
     static function saveNew($profile_id, $content, $source, array $options=null) {
         $defaults = array('uri' => null,
                           'url' => null,
-                          'reply_to' => null,
-                          'repeat_of' => null,
+                          'conversation' => null,   // URI of conversation
+                          'reply_to' => null,       // This will override convo URI if the parent is known
+                          'repeat_of' => null,      // This will override convo URI if the repeated notice is known
                           'scope' => null,
                           'distribute' => true,
                           'object_type' => null,
@@ -424,6 +496,16 @@ class Notice extends Managed_DataObject
             $notice->created = common_sql_now();
         }
 
+        if (!$notice->isLocal()) {
+            // Only do these checks for non-local notices. Local notices will generate these values later.
+            if (!common_valid_http_url($url)) {
+                common_debug('Bad notice URL: ['.$url.'], URI: ['.$uri.']. Cannot link back to original! This is normal for shared notices etc.');
+            }
+            if (empty($uri)) {
+                throw new ServerException('No URI for remote notice. Cannot accept that.');
+            }
+        }
+
         $notice->content = $final;
 
         $notice->source = $source;
@@ -439,18 +521,13 @@ class Notice extends Managed_DataObject
 
         // Handle repeat case
 
-        if (isset($repeat_of)) {
+        if (!empty($options['repeat_of'])) {
 
             // Check for a private one
 
-            $repeat = Notice::getKV('id', $repeat_of);
+            $repeat = Notice::getByID($options['repeat_of']);
 
-            if (!($repeat instanceof Notice)) {
-                // TRANS: Client exception thrown in notice when trying to repeat a missing or deleted notice.
-                throw new ClientException(_('Cannot repeat; original notice is missing or deleted.'));
-            }
-
-            if ($profile->id == $repeat->profile_id) {
+            if ($profile->sameAs($repeat->getProfile())) {
                 // TRANS: Client error displayed when trying to repeat an own notice.
                 throw new ClientException(_('You cannot repeat your own notice.'));
             }
@@ -472,12 +549,22 @@ class Notice extends Managed_DataObject
                 throw new ClientException(_('You already repeated that notice.'));
             }
 
-            $notice->repeat_of = $repeat_of;
+            $notice->repeat_of = $repeat->id;
+            $notice->conversation = $repeat->conversation;
         } else {
-            $reply = self::getReplyTo($reply_to, $profile_id, $source, $final);
+            $reply = null;
 
-            if (!empty($reply)) {
+            // If $reply_to is specified, we check that it exists, and then
+            // return it if it does
+            if (!empty($reply_to)) {
+                $reply = Notice::getKV('id', $reply_to);
+            } elseif (in_array($source, array('xmpp', 'mail', 'sms'))) {
+                // If the source lacks capability of sending the "reply_to"
+                // metadata, let's try to find an inline replyto-reference.
+                $reply = self::getInlineReplyTo($profile, $final);
+            }
 
+            if ($reply instanceof Notice) {
                 if (!$reply->inScope($profile)) {
                     // TRANS: Client error displayed when trying to reply to a notice a the target has no access to.
                     // TRANS: %1$s is a user nickname, %2$d is a notice ID (number).
@@ -485,11 +572,17 @@ class Notice extends Managed_DataObject
                                                       $profile->nickname, $reply->id), 403);
                 }
 
-                $notice->reply_to     = $reply->id;
+                // If it's a repeat, the reply_to should be to the original
+                if ($reply->isRepeat()) {
+                    $notice->reply_to = $reply->repeat_of;
+                } else {
+                    $notice->reply_to = $reply->id;
+                }
+                // But the conversation ought to be the same :)
                 $notice->conversation = $reply->conversation;
 
-                // If the original is private to a group, and notice has no group specified,
-                // make it to the same group(s)
+                // If the original is private to a group, and notice has
+                // no group specified, make it to the same group(s)
 
                 if (empty($groups) && ($reply->scope & Notice::GROUP_SCOPE)) {
                     $groups = array();
@@ -503,26 +596,54 @@ class Notice extends Managed_DataObject
 
                 // Scope set below
             }
+
+            // If we don't know the reply, we might know the conversation!
+            // This will happen if a known remote user replies to an
+            // unknown remote user - within a known conversation.
+            if (empty($notice->conversation) and !empty($options['conversation'])) {
+                $conv = Conversation::getKV('uri', $options['conversation']);
+                if ($conv instanceof Conversation) {
+                    common_debug('Conversation stitched together from (probably) a reply to unknown remote user. Activity creation time ('.$notice->created.') should maybe be compared to conversation creation time ('.$conv->created.').');
+                } else {
+                    // Conversation entry with specified URI was not found, so we must create it.
+                    common_debug('Conversation URI not found, so we will create it with the URI given in the options to Notice::saveNew: '.$options['conversation']);
+                    // The insert in Conversation::create throws exception on failure
+                    $conv = Conversation::create($options['conversation'], $notice->created);
+                }
+                $notice->conversation = $conv->getID();
+                unset($conv);
+            }
         }
 
+        // If it's not part of a conversation, it's the beginning of a new conversation.
+        if (empty($notice->conversation)) {
+            $conv = Conversation::create();
+            $notice->conversation = $conv->getID();
+            unset($conv);
+        }
+
+
+        $notloc = new Notice_location();
         if (!empty($lat) && !empty($lon)) {
-            $notice->lat = $lat;
-            $notice->lon = $lon;
+            $notloc->lat = $lat;
+            $notloc->lon = $lon;
         }
 
         if (!empty($location_ns) && !empty($location_id)) {
-            $notice->location_id = $location_id;
-            $notice->location_ns = $location_ns;
+            $notloc->location_id = $location_id;
+            $notloc->location_ns = $location_ns;
         }
 
         if (!empty($rendered)) {
             $notice->rendered = $rendered;
         } else {
-            $notice->rendered = common_render_content($final, $notice);
+            $notice->rendered = common_render_content($final,
+                                                      $notice->getProfile(),
+                                                      $notice->hasParent() ? $notice->getParent() : null);
         }
 
         if (empty($verb)) {
-            if (!empty($notice->repeat_of)) {
+            if ($notice->isRepeat()) {
                 $notice->verb        = ActivityVerb::SHARE;
                 $notice->object_type = ActivityObject::ACTIVITY;
             } else {
@@ -538,124 +659,376 @@ class Notice extends Managed_DataObject
             $notice->object_type = $object_type;
         }
 
-        if (is_null($scope)) { // 0 is a valid value
-            if (!empty($reply)) {
-                $notice->scope = $reply->scope;
-            } else {
-                $notice->scope = self::defaultScope();
-            }
+        if (is_null($scope) && $reply instanceof Notice) {
+            $notice->scope = $reply->scope;
         } else {
             $notice->scope = $scope;
         }
 
-        // For private streams
+        $notice->scope = self::figureOutScope($profile, $groups, $notice->scope);
 
-        try {
-            $user = $profile->getUser();
+        if (Event::handle('StartNoticeSave', array(&$notice))) {
+
+            // XXX: some of these functions write to the DB
+
+            try {
+                $notice->insert();  // throws exception on failure, if successful we have an ->id
 
-            if ($user->private_stream &&
-                ($notice->scope == Notice::PUBLIC_SCOPE ||
-                 $notice->scope == Notice::SITE_SCOPE)) {
-                $notice->scope |= Notice::FOLLOWER_SCOPE;
+                if (($notloc->lat && $notloc->lon) || ($notloc->location_id && $notloc->location_ns)) {
+                    $notloc->notice_id = $notice->getID();
+                    $notloc->insert();  // store the notice location if it had any information
+                }
+            } catch (Exception $e) {
+                // Let's test if we managed initial insert, which would imply
+                // failing on some update-part (check 'insert()'). Delete if
+                // something had been stored to the database.
+                if (!empty($notice->id)) {
+                    $notice->delete();
+                }
+                throw $e;
             }
-        } catch (NoSuchUserException $e) {
-            // Cannot handle private streams for remote profiles
         }
 
-        // Force the scope for private groups
+        // Only save 'attention' and metadata stuff (URLs, tags...) stuff if
+        // the activityverb is a POST (since stuff like repeat, favorite etc.
+        // reasonably handle notifications themselves.
+        if (ActivityUtils::compareVerbs($notice->verb, array(ActivityVerb::POST))) {
+            if (isset($replies)) {
+                $notice->saveKnownReplies($replies);
+            } else {
+                $notice->saveReplies();
+            }
 
-        foreach ($groups as $groupId) {
-            $group = User_group::getKV('id', $groupId);
-            if ($group instanceof User_group) {
-                if ($group->force_scope) {
-                    $notice->scope |= Notice::GROUP_SCOPE;
-                    break;
-                }
+            if (isset($tags)) {
+                $notice->saveKnownTags($tags);
+            } else {
+                $notice->saveTags();
+            }
+
+            // Note: groups may save tags, so must be run after tags are saved
+            // to avoid errors on duplicates.
+            // Note: groups should always be set.
+
+            $notice->saveKnownGroups($groups);
+
+            if (isset($urls)) {
+                $notice->saveKnownUrls($urls);
+            } else {
+                $notice->saveUrls();
             }
         }
 
-        if (Event::handle('StartNoticeSave', array(&$notice))) {
+        if ($distribute) {
+            // Prepare inbox delivery, may be queued to background.
+            $notice->distribute();
+        }
 
-            // XXX: some of these functions write to the DB
+        return $notice;
+    }
 
-            $id = $notice->insert();
+    static function saveActivity(Activity $act, Profile $actor, array $options=array())
+    {
+        // First check if we're going to let this Activity through from the specific actor
+        if (!$actor->hasRight(Right::NEWNOTICE)) {
+            common_log(LOG_WARNING, "Attempted post from user disallowed to post: " . $actor->getNickname());
 
-            if (!$id) {
-                common_log_db_error($notice, 'INSERT', __FILE__);
-                // TRANS: Server exception thrown when a notice cannot be saved.
-                throw new ServerException(_('Problem saving notice.'));
+            // TRANS: Client exception thrown when a user tries to post while being banned.
+            throw new ClientException(_m('You are banned from posting notices on this site.'), 403);
+        }
+        if (common_config('throttle', 'enabled') && !self::checkEditThrottle($actor->id)) {
+            common_log(LOG_WARNING, 'Excessive posting by profile #' . $actor->id . '; throttled.');
+            // TRANS: Client exception thrown when a user tries to post too many notices in a given time frame.
+            throw new ClientException(_m('Too many notices too fast; take a breather '.
+                                        'and post again in a few minutes.'));
+        }
+
+        // Get ActivityObject properties
+        $actobj = null;
+        if (!empty($act->id)) {
+            // implied object
+            $options['uri'] = $act->id;
+            $options['url'] = $act->link;
+        } else {
+            $actobj = count($act->objects)==1 ? $act->objects[0] : null;
+            if (!is_null($actobj) && !empty($actobj->id)) {
+                $options['uri'] = $actobj->id;
+                if ($actobj->link) {
+                    $options['url'] = $actobj->link;
+                } elseif (preg_match('!^https?://!', $actobj->id)) {
+                    $options['url'] = $actobj->id;
+                }
             }
+        }
 
-            // Update ID-dependent columns: URI, conversation
+        $defaults = array(
+                          'groups'   => array(),
+                          'is_local' => $actor->isLocal() ? self::LOCAL_PUBLIC : self::REMOTE,
+                          'mentions' => array(),
+                          'reply_to' => null,
+                          'repeat_of' => null,
+                          'scope' => null,
+                          'source' => 'unknown',
+                          'tags' => array(),
+                          'uri' => null,
+                          'url' => null,
+                          'urls' => array(),
+                          'distribute' => true);
 
-            $orig = clone($notice);
+        // options will have default values when nothing has been supplied
+        $options = array_merge($defaults, $options);
+        foreach (array_keys($defaults) as $key) {
+            // Only convert the keynames we specify ourselves from 'defaults' array into variables
+            $$key = $options[$key];
+        }
+        extract($options, EXTR_SKIP);
 
-            $changed = false;
+        // dupe check
+        $stored = new Notice();
+        if (!empty($uri) && !ActivityUtils::compareVerbs($act->verb, array(ActivityVerb::DELETE))) {
+            $stored->uri = $uri;
+            if ($stored->find()) {
+                common_debug('cannot create duplicate Notice URI: '.$stored->uri);
+                // I _assume_ saving a Notice with a colliding URI means we're really trying to
+                // save the same notice again...
+                throw new AlreadyFulfilledException('Notice URI already exists');
+            }
+        }
 
+        $autosource = common_config('public', 'autosource');
+
+        // Sandboxed are non-false, but not 1, either
+        if (!$actor->hasRight(Right::PUBLICNOTICE) ||
+                ($source && $autosource && in_array($source, $autosource))) {
+            // FIXME: ...what about remote nonpublic? Hmmm. That is, if we sandbox remote profiles...
+            $stored->is_local = Notice::LOCAL_NONPUBLIC;
+        } else {
+            $stored->is_local = intval($is_local);
+        }
+
+        if (!$stored->isLocal()) {
+            // Only do these checks for non-local notices. Local notices will generate these values later.
+            if (!common_valid_http_url($url)) {
+                common_debug('Bad notice URL: ['.$url.'], URI: ['.$uri.']. Cannot link back to original! This is normal for shared notices etc.');
+            }
             if (empty($uri)) {
-                $notice->uri = sprintf('%s:%s=%d:%s=%s',
-                                    TagURI::mint(),
-                                    'noticeId', $notice->id,
-                                    'objectType', $notice->get_object_type(true));
-                $changed = true;
+                throw new ServerException('No URI for remote notice. Cannot accept that.');
             }
+        }
+
+        $stored->profile_id = $actor->id;
+        $stored->source = $source;
+        $stored->uri = $uri;
+        $stored->url = $url;
+        $stored->verb = $act->verb;
+
+        // Notice content. We trust local users to provide HTML we like, but of course not remote users.
+        // FIXME: What about local users importing feeds? Mirror functions must filter out bad HTML first...
+        $content = $act->content ?: $act->summary;
+        if (is_null($content) && !is_null($actobj)) {
+            $content = $actobj->content ?: $actobj->summary;
+        }
+        $stored->rendered = $actor->isLocal() ? $content : common_purify($content);
+        // yeah, just don't use getRendered() here since it's not inserted yet ;)
+        $stored->content = common_strip_html($stored->rendered);
+
+        // Maybe a missing act-time should be fatal if the actor is not local?
+        if (!empty($act->time)) {
+            $stored->created = common_sql_date($act->time);
+        } else {
+            $stored->created = common_sql_now();
+        }
 
-            // If it's not part of a conversation, it's
-            // the beginning of a new conversation.
+        $reply = null;
+        if ($act->context instanceof ActivityContext && !empty($act->context->replyToID)) {
+            $reply = self::getKV('uri', $act->context->replyToID);
+        }
+        if (!$reply instanceof Notice && $act->target instanceof ActivityObject) {
+            $reply = self::getKV('uri', $act->target->id);
+        }
 
-            if (empty($notice->conversation)) {
-                $conv = Conversation::create($notice);
-                $notice->conversation = $conv->id;
-                $changed = true;
+        if ($reply instanceof Notice) {
+            if (!$reply->inScope($actor)) {
+                // TRANS: Client error displayed when trying to reply to a notice a the target has no access to.
+                // TRANS: %1$s is a user nickname, %2$d is a notice ID (number).
+                throw new ClientException(sprintf(_m('%1$s has no right to reply to notice %2$d.'), $actor->getNickname(), $reply->id), 403);
             }
 
-            if ($changed) {
-                if ($notice->update($orig) === false) {
-                    common_log_db_error($notice, 'UPDATE', __FILE__);
-                    // TRANS: Server exception thrown when a notice cannot be updated.
-                    throw new ServerException(_('Problem saving notice.'));
+            $stored->reply_to     = $reply->id;
+            $stored->conversation = $reply->conversation;
+
+            // If the original is private to a group, and notice has no group specified,
+            // make it to the same group(s)
+            if (empty($groups) && ($reply->scope & Notice::GROUP_SCOPE)) {
+                $replyGroups = $reply->getGroups();
+                foreach ($replyGroups as $group) {
+                    if ($actor->isMember($group)) {
+                        $groups[] = $group->id;
+                    }
                 }
             }
 
+            if (is_null($scope)) {
+                $scope = $reply->scope;
+            }
+        } else {
+            // If we don't know the reply, we might know the conversation!
+            // This will happen if a known remote user replies to an
+            // unknown remote user - within a known conversation.
+            if (empty($stored->conversation) and !empty($act->context->conversation)) {
+                $conv = Conversation::getKV('uri', $act->context->conversation);
+                if ($conv instanceof Conversation) {
+                    common_debug('Conversation stitched together from (probably) a reply activity to unknown remote user. Activity creation time ('.$stored->created.') should maybe be compared to conversation creation time ('.$conv->created.').');
+                } else {
+                    // Conversation entry with specified URI was not found, so we must create it.
+                    common_debug('Conversation URI not found, so we will create it with the URI given in the context of the activity: '.$act->context->conversation);
+                    // The insert in Conversation::create throws exception on failure
+                    $conv = Conversation::create($act->context->conversation, $stored->created);
+                }
+                $stored->conversation = $conv->getID();
+                unset($conv);
+            }
         }
 
-        // Clear the cache for subscribed users, so they'll update at next request
-        // XXX: someone clever could prepend instead of clearing the cache
+        // If it's not part of a conversation, it's the beginning of a new conversation.
+        if (empty($stored->conversation)) {
+            $conv = Conversation::create();
+            $stored->conversation = $conv->getID();
+            unset($conv);
+        }
 
-        $notice->blowOnInsert();
+        $notloc = null;
+        if ($act->context instanceof ActivityContext) {
+            if ($act->context->location instanceof Location) {
+                $notloc = Notice_location::fromLocation($act->context->location);
+            }
+        } else {
+            $act->context = new ActivityContext();
+        }
 
-        // Save per-notice metadata...
+        $stored->scope = self::figureOutScope($actor, $groups, $scope);
 
-        if (isset($replies)) {
-            $notice->saveKnownReplies($replies);
-        } else {
-            $notice->saveReplies();
+        foreach ($act->categories as $cat) {
+            if ($cat->term) {
+                $term = common_canonical_tag($cat->term);
+                if (!empty($term)) {
+                    $tags[] = $term;
+                }
+            }
         }
 
-        if (isset($tags)) {
-            $notice->saveKnownTags($tags);
-        } else {
-            $notice->saveTags();
+        foreach ($act->enclosures as $href) {
+            // @todo FIXME: Save these locally or....?
+            $urls[] = $href;
+        }
+
+        if (ActivityUtils::compareVerbs($stored->verb, array(ActivityVerb::POST))) {
+            if (empty($act->objects[0]->type)) {
+                // Default type for the post verb is 'note', but we know it's
+                // a 'comment' if it is in reply to something.
+                $stored->object_type = empty($stored->reply_to) ? ActivityObject::NOTE : ActivityObject::COMMENT;
+            } else {
+                //TODO: Is it safe to always return a relative URI? The
+                // JSON version of ActivityStreams always use it, so we
+                // should definitely be able to handle it...
+                $stored->object_type = ActivityUtils::resolveUri($act->objects[0]->type, true);
+            }
         }
 
-        // Note: groups may save tags, so must be run after tags are saved
-        // to avoid errors on duplicates.
-        // Note: groups should always be set.
+        if (Event::handle('StartNoticeSave', array(&$stored))) {
+            // XXX: some of these functions write to the DB
 
-        $notice->saveKnownGroups($groups);
+            try {
+                $result = $stored->insert();    // throws exception on error
 
-        if (isset($urls)) {
-            $notice->saveKnownUrls($urls);
-        } else {
-            $notice->saveUrls();
+                if ($notloc instanceof Notice_location) {
+                    $notloc->notice_id = $stored->getID();
+                    $notloc->insert();
+                }
+
+                $orig = clone($stored); // for updating later in this try clause
+
+                $object = null;
+                Event::handle('StoreActivityObject', array($act, $stored, $options, &$object));
+                if (empty($object)) {
+                    throw new ServerException('Unsuccessful call to StoreActivityObject '.$stored->getUri() . ': '.$act->asString());
+                }
+
+                // If something changed in the Notice during StoreActivityObject
+                $stored->update($orig);
+            } catch (Exception $e) {
+                if (empty($stored->id)) {
+                    common_debug('Failed to save stored object entry in database ('.$e->getMessage().')');
+                } else {
+                    common_debug('Failed to store activity object in database ('.$e->getMessage().'), deleting notice id '.$stored->id);
+                    $stored->delete();
+                }
+                throw $e;
+            }
+        }
+        if (!$stored instanceof Notice) {
+            throw new ServerException('StartNoticeSave did not give back a Notice');
+        }
+
+        // Only save 'attention' and metadata stuff (URLs, tags...) stuff if
+        // the activityverb is a POST (since stuff like repeat, favorite etc.
+        // reasonably handle notifications themselves.
+        if (ActivityUtils::compareVerbs($stored->verb, array(ActivityVerb::POST))) {
+
+            $stored->saveAttentions($act->context->attention);
+
+            if (!empty($tags)) {
+                $stored->saveKnownTags($tags);
+            } else {
+                $stored->saveTags();
+            }
+
+            // Note: groups may save tags, so must be run after tags are saved
+            // to avoid errors on duplicates.
+            // Note: groups should always be set.
+
+            if (!empty($urls)) {
+                $stored->saveKnownUrls($urls);
+            } else {
+                $stored->saveUrls();
+            }
         }
 
         if ($distribute) {
             // Prepare inbox delivery, may be queued to background.
-            $notice->distribute();
+            $stored->distribute();
         }
 
-        return $notice;
+        return $stored;
+    }
+
+    static public function figureOutScope(Profile $actor, array $groups, $scope=null) {
+        $scope = is_null($scope) ? self::defaultScope() : intval($scope);
+
+        // For private streams
+        try {
+            $user = $actor->getUser();
+            // FIXME: We can't do bit comparison with == (Legacy StatusNet thing. Let's keep it for now.)
+            if ($user->private_stream && ($scope === Notice::PUBLIC_SCOPE || $scope === Notice::SITE_SCOPE)) {
+                $scope |= Notice::FOLLOWER_SCOPE;
+            }
+        } catch (NoSuchUserException $e) {
+            // TODO: Not a local user, so we don't know about scope preferences... yet!
+        }
+
+        // Force the scope for private groups
+        foreach ($groups as $group_id) {
+            try {
+                $group = User_group::getByID($group_id);
+                if ($group->force_scope) {
+                    $scope |= Notice::GROUP_SCOPE;
+                    break;
+                }
+            } catch (Exception $e) {
+                common_log(LOG_ERR, 'Notice figureOutScope threw exception: '.$e->getMessage());
+            }
+        }
+
+        return $scope;
     }
 
     function blowOnInsert($conversation = false)
@@ -664,12 +1037,15 @@ class Notice extends Managed_DataObject
 
         if ($this->isPublic()) {
             $this->blowStream('public');
+            $this->blowStream('networkpublic');
         }
 
-        self::blow('notice:list-ids:conversation:%s', $this->conversation);
-        self::blow('conversation:notice_count:%d', $this->conversation);
+        if ($this->conversation) {
+            self::blow('notice:list-ids:conversation:%s', $this->conversation);
+            self::blow('conversation:notice_count:%d', $this->conversation);
+        }
 
-        if (!empty($this->repeat_of)) {
+        if ($this->isRepeat()) {
             // XXX: we should probably only use one of these
             $this->blowStream('notice:repeats:%d', $this->repeat_of);
             self::blow('notice:list-ids:repeat_of:%d', $this->repeat_of);
@@ -708,6 +1084,7 @@ class Notice extends Managed_DataObject
 
         if ($this->isPublic()) {
             self::blow('public;last');
+            self::blow('networkpublic;last');
         }
 
         self::blow('fave:by_notice', $this->id);
@@ -732,13 +1109,9 @@ class Notice extends Managed_DataObject
         }
 
         $args = func_get_args();
-
         $format = array_shift($args);
-
         $keyPart = vsprintf($format, $args);
-
         $cacheKey = Cache::key($keyPart);
-        
         $c->delete($cacheKey);
 
         // delete the "last" stream, too, if this notice is
@@ -768,7 +1141,7 @@ class Notice extends Managed_DataObject
      */
     function saveUrls() {
         if (common_config('attachments', 'process_links')) {
-            common_replace_urls_callback($this->content, array($this, 'saveUrl'), $this->id);
+            common_replace_urls_callback($this->content, array($this, 'saveUrl'), $this);
         }
     }
 
@@ -785,7 +1158,7 @@ class Notice extends Managed_DataObject
         if (common_config('attachments', 'process_links')) {
             // @fixme validation?
             foreach (array_unique($urls) as $url) {
-                File::processNew($url, $this->id);
+                $this->saveUrl($url, $this);
             }
         }
     }
@@ -793,8 +1166,12 @@ class Notice extends Managed_DataObject
     /**
      * @private callback
      */
-    function saveUrl($url, $notice_id) {
-        File::processNew($url, $notice_id);
+    function saveUrl($url, Notice $notice) {
+        try {
+            File::processNew($url, $notice);
+        } catch (ServerException $e) {
+            // Could not save URL. Log it?
+        }
     }
 
     static function checkDupes($profile_id, $content) {
@@ -843,45 +1220,38 @@ class Notice extends Managed_DataObject
         return true;
     }
 
-       protected $_attachments = -1;
-       
-    function attachments() {
+       protected $_attachments = array();
 
-               if ($this->_attachments != -1)  {
-            return $this->_attachments;
+    function attachments() {
+               if (isset($this->_attachments[$this->id])) {
+            return $this->_attachments[$this->id];
         }
-               
+
         $f2ps = File_to_post::listGet('post_id', array($this->id));
-               
                $ids = array();
-               
                foreach ($f2ps[$this->id] as $f2p) {
-            $ids[] = $f2p->file_id;    
+            $ids[] = $f2p->file_id;
         }
-               
-               $files = File::multiGet('id', $ids);
 
-               $this->_attachments = $files->fetchAll();
-               
-        return $this->_attachments;
+               $files = File::multiGet('id', $ids);
+               $this->_attachments[$this->id] = $files->fetchAll();
+        return $this->_attachments[$this->id];
     }
 
        function _setAttachments($attachments)
        {
-           $this->_attachments = $attachments;
+           $this->_attachments[$this->id] = $attachments;
        }
 
-    function publicStream($offset=0, $limit=20, $since_id=0, $max_id=0)
+    static function publicStream($offset=0, $limit=20, $since_id=null, $max_id=null)
     {
         $stream = new PublicNoticeStream();
         return $stream->getNotices($offset, $limit, $since_id, $max_id);
     }
 
-
-    function conversationStream($id, $offset=0, $limit=20, $since_id=0, $max_id=0)
+    static function conversationStream($id, $offset=0, $limit=20, $since_id=null, $max_id=null)
     {
         $stream = new ConversationNoticeStream($id);
-
         return $stream->getNotices($offset, $limit, $since_id, $max_id);
     }
 
@@ -893,18 +1263,17 @@ class Notice extends Managed_DataObject
      */
     function hasConversation()
     {
-        if (!empty($this->conversation)) {
-            $conversation = Notice::conversationStream(
-                $this->conversation,
-                1,
-                1
-            );
-
-            if ($conversation->N > 0) {
-                return true;
-            }
+        if (empty($this->conversation)) {
+            // this notice is not part of a conversation apparently
+            // FIXME: all notices should have a conversation value, right?
+            return false;
         }
-        return false;
+
+        $stream = new ConversationNoticeStream($this->conversation);
+        $notice = $stream->getNotices(/*offset*/ 1, /*limit*/ 1);
+
+        // if our "offset 1, limit 1" query got a result, return true else false
+        return $notice->N > 0;
     }
 
     /**
@@ -933,12 +1302,17 @@ class Notice extends Managed_DataObject
         }
 
         // If this isn't a reply to anything, then it's its own
-        // root.
+        // root if it's the earliest notice in the conversation:
 
         if (empty($this->reply_to)) {
-            return $this;
+            $root = new Notice;
+            $root->conversation = $this->conversation;
+            $root->orderBy('notice.created ASC');
+            $root->find(true);  // true means "fetch first result"
+            $root->free();
+            return $root;
         }
-        
+
         if (is_null($profile)) {
             $keypart = sprintf('notice:conversation_root:%d:null', $this->id);
         } else {
@@ -946,7 +1320,7 @@ class Notice extends Managed_DataObject
                                $this->id,
                                $profile->id);
         }
-            
+
         $root = self::cacheGet($keypart);
 
         if ($root !== false && $root->inScope($profile)) {
@@ -961,8 +1335,12 @@ class Notice extends Managed_DataObject
                     $last = $parent;
                     continue;
                 }
-            } catch (Exception $e) {
+            } catch (NoParentNoticeException $e) {
                 // Latest notice has no parent
+            } catch (NoResultException $e) {
+                // Notice was not found, so we can't go further up in the tree.
+                // FIXME: Maybe we should do this in a more stable way where deleted
+                // notices won't break conversation chains?
             }
             // No parent, or parent out of scope
             $root = $last;
@@ -1038,7 +1416,7 @@ class Notice extends Managed_DataObject
             // Exclude any deleted, non-local, or blocking recipients.
             $profile = $this->getProfile();
             $originalProfile = null;
-            if ($this->repeat_of) {
+            if ($this->isRepeat()) {
                 // Check blocks against the original notice's poster as well.
                 $original = Notice::getKV('id', $this->repeat_of);
                 if ($original instanceof Notice) {
@@ -1134,18 +1512,13 @@ class Notice extends Managed_DataObject
      *        best with generalizations on user_group to support
      *        remote groups better.
      */
-    function saveKnownGroups($group_ids)
+    function saveKnownGroups(array $group_ids)
     {
-        if (!is_array($group_ids)) {
-            // TRANS: Server exception thrown when no array is provided to the method saveKnownGroups().
-            throw new ServerException(_('Bad type provided to saveKnownGroups.'));
-        }
-
         $groups = array();
         foreach (array_unique($group_ids) as $id) {
             $group = User_group::getKV('id', $id);
             if ($group instanceof User_group) {
-                common_log(LOG_ERR, "Local delivery to group id $id, $group->nickname");
+                common_log(LOG_DEBUG, "Local delivery to group id $id, $group->nickname");
                 $result = $this->addToGroupInbox($group);
                 if (!$result) {
                     common_log_db_error($gi, 'INSERT', __FILE__);
@@ -1198,6 +1571,48 @@ class Notice extends Managed_DataObject
         return true;
     }
 
+    function saveAttentions(array $uris)
+    {
+        foreach ($uris as $uri=>$type) {
+            try {
+                $target = Profile::fromUri($uri);
+            } catch (UnknownUriException $e) {
+                common_log(LOG_WARNING, "Unable to determine profile for URI '$uri'");
+                continue;
+            }
+
+            $this->saveAttention($target);
+        }
+    }
+
+    function saveAttention(Profile $target, $reason=null)
+    {
+        if ($target->isGroup()) {
+            // FIXME: Make sure we check that users are in the groups they send to!
+        } else {
+            if ($target->hasBlocked($this->getProfile())) {
+                common_log(LOG_INFO, "Not saving reply to profile {$target->id} ($uri) from sender {$sender->id} because of a block.");
+                return false;
+            }
+        }
+
+        if ($target->isLocal()) {
+            // is local user
+            $this->saveReply($target->getID());   // since we still have the Reply table which some apparently use!
+        }
+
+        try {
+            $att = Attention::saveNew($this, $target, $reason);
+        } catch (AlreadyFulfilledException $e) {
+            common_debug('Could not save Attention: '.$e->getMessage());
+        } catch (Exception $e) {
+            common_log(LOG_ERR, 'Could not save Attention: '.$e->getMessage());
+        }
+
+        self::blow('reply:stream:%d', $target->getID());
+        return true;
+    }
+
     /**
      * Save reply records indicating that this notice needs to be
      * delivered to the local users with the given URIs.
@@ -1216,13 +1631,12 @@ class Notice extends Managed_DataObject
             return;
         }
 
-        $sender = Profile::getKV($this->profile_id);
+        $sender = $this->getProfile();
 
         foreach (array_unique($uris) as $uri) {
-
-            $profile = Profile::fromURI($uri);
-
-            if (!$profile instanceof Profile) {
+            try {
+                $profile = Profile::fromUri($uri);
+            } catch (UnknownUriException $e) {
                 common_log(LOG_WARNING, "Unable to determine profile for URI '$uri'");
                 continue;
             }
@@ -1232,11 +1646,9 @@ class Notice extends Managed_DataObject
                 continue;
             }
 
-            $this->saveReply($profile->id);
-            self::blow('reply:stream:%d', $profile->id);
+            $this->saveReply($profile->getID());
+            self::blow('reply:stream:%d', $profile->getID());
         }
-
-        return;
     }
 
     /**
@@ -1251,51 +1663,41 @@ class Notice extends Managed_DataObject
 
     function saveReplies()
     {
-        // Don't save reply data for repeats
-
-        if (!empty($this->repeat_of)) {
-            return array();
-        }
-
-        $sender = Profile::getKV($this->profile_id);
+        $sender = $this->getProfile();
 
         $replied = array();
 
         // If it's a reply, save for the replied-to author
         try {
             $parent = $this->getParent();
-            $author = $parent->getProfile();
-            if ($author instanceof Profile) {
-                $this->saveReply($author->id);
-                $replied[$author->id] = 1;
-                self::blow('reply:stream:%d', $author->id);
-            }
-        } catch (Exception $e) {
+            $parentauthor = $parent->getProfile();
+            $this->saveReply($parentauthor->getID());
+            $replied[$parentauthor->getID()] = 1;
+            self::blow('reply:stream:%d', $parentauthor->getID());
+        } catch (NoParentNoticeException $e) {
             // Not a reply, since it has no parent!
+            $parent = null;
+        } catch (NoResultException $e) {
+            // Parent notice was probably deleted
+            $parent = null;
         }
 
         // @todo ideally this parser information would only
         // be calculated once.
 
-        $mentions = common_find_mentions($this->content, $this);
-
-        // store replied only for first @ (what user/notice what the reply directed,
-        // we assume first @ is it)
+        $mentions = common_find_mentions($this->content, $sender, $parent);
 
         foreach ($mentions as $mention) {
 
             foreach ($mention['mentioned'] as $mentioned) {
 
                 // skip if they're already covered
-
-                if (!empty($replied[$mentioned->id])) {
+                if (array_key_exists($mentioned->id, $replied)) {
                     continue;
                 }
 
                 // Don't save replies from blocked profile to local user
-
-                $mentioned_user = User::getKV('id', $mentioned->id);
-                if ($mentioned_user instanceof User && $mentioned_user->hasBlocked($sender)) {
+                if ($mentioned->hasBlocked($sender)) {
                     continue;
                 }
 
@@ -1323,35 +1725,42 @@ class Notice extends Managed_DataObject
         return $reply;
     }
 
-    protected $_replies = -1;
+    protected $_attentionids = array();
 
     /**
-     * Pull the complete list of @-reply targets for this notice.
+     * Pull the complete list of known activity context attentions for this notice.
      *
-     * @return array of integer profile ids
+     * @return array of integer profile ids (also group profiles)
      */
-    function getReplies()
+    function getAttentionProfileIDs()
     {
-        if ($this->_replies != -1) {
-            return $this->_replies;
+        if (!isset($this->_attentionids[$this->getID()])) {
+            $atts = Attention::multiGet('notice_id', array($this->getID()));
+            // (array)null means empty array
+            $this->_attentionids[$this->getID()] = (array)$atts->fetchAll('profile_id');
         }
+        return $this->_attentionids[$this->getID()];
+    }
 
-        $replyMap = Reply::listGet('notice_id', array($this->id));
-
-        $ids = array();
+    protected $_replies = array();
 
-        foreach ($replyMap[$this->id] as $reply) {
-            $ids[] = $reply->profile_id;
+    /**
+     * Pull the complete list of @-mentioned profile IDs for this notice.
+     *
+     * @return array of integer profile ids
+     */
+    function getReplies()
+    {
+        if (!isset($this->_replies[$this->getID()])) {
+            $mentions = Reply::multiGet('notice_id', array($this->getID()));
+            $this->_replies[$this->getID()] = $mentions->fetchAll('profile_id');
         }
-
-        $this->_replies = $ids;
-
-        return $ids;
+        return $this->_replies[$this->getID()];
     }
 
     function _setReplies($replies)
     {
-        $this->_replies = $replies;
+        $this->_replies[$this->getID()] = $replies;
     }
 
     /**
@@ -1359,12 +1768,12 @@ class Notice extends Managed_DataObject
      *
      * @return array of Profiles
      */
-    function getReplyProfiles()
+    function getAttentionProfiles()
     {
-        $ids = $this->getReplies();
-        
-        $profiles = Profile::multiGet('id', $ids);
-        
+        $ids = array_unique(array_merge($this->getReplies(), $this->getGroupProfileIDs(), $this->getAttentionProfileIDs()));
+
+        $profiles = Profile::multiGet('id', (array)$ids);
+
         return $profiles->fetchAll();
     }
 
@@ -1377,30 +1786,52 @@ class Notice extends Managed_DataObject
     function sendReplyNotifications()
     {
         // Don't send reply notifications for repeats
-
-        if (!empty($this->repeat_of)) {
+        if ($this->isRepeat()) {
             return array();
         }
 
         $recipientIds = $this->getReplies();
+        if (Event::handle('StartNotifyMentioned', array($this, &$recipientIds))) {
+            require_once INSTALLDIR.'/lib/mail.php';
 
-        foreach ($recipientIds as $recipientId) {
-            $user = User::getKV('id', $recipientId);
-            if ($user instanceof User) {
-                mail_notify_attn($user, $this);
+            foreach ($recipientIds as $recipientId) {
+                try {
+                    $user = User::getByID($recipientId);
+                    mail_notify_attn($user, $this);
+                } catch (NoResultException $e) {
+                    // No such user
+                }
             }
+            Event::handle('EndNotifyMentioned', array($this, $recipientIds));
         }
     }
 
+    /**
+     * Pull list of Profile IDs of groups this notice addresses.
+     *
+     * @return array of Group _profile_ IDs
+     */
+
+    function getGroupProfileIDs()
+    {
+        $ids = array();
+
+               foreach ($this->getGroups() as $group) {
+                   $ids[] = $group->profile_id;
+               }
+
+        return $ids;
+    }
+
     /**
      * Pull list of groups this notice needs to be delivered to,
      * as previously recorded by saveKnownGroups().
      *
      * @return array of Group objects
      */
-    
-    protected $_groups = -1;
-    
+
+    protected $_groups = array();
+
     function getGroups()
     {
         // Don't save groups for repeats
@@ -1408,42 +1839,38 @@ class Notice extends Managed_DataObject
         if (!empty($this->repeat_of)) {
             return array();
         }
-        
-        if ($this->_groups != -1)
-        {
-            return $this->_groups;
+
+        if (isset($this->_groups[$this->id])) {
+            return $this->_groups[$this->id];
         }
-        
+
         $gis = Group_inbox::listGet('notice_id', array($this->id));
 
         $ids = array();
 
-               foreach ($gis[$this->id] as $gi)
-               {
+               foreach ($gis[$this->id] as $gi) {
                    $ids[] = $gi->group_id;
                }
-               
+
                $groups = User_group::multiGet('id', $ids);
-               
-               $this->_groups = $groups->fetchAll();
-               
-               return $this->_groups;
+               $this->_groups[$this->id] = $groups->fetchAll();
+               return $this->_groups[$this->id];
     }
-    
+
     function _setGroups($groups)
     {
-        $this->_groups = $groups;
+        $this->_groups[$this->id] = $groups;
     }
 
     /**
      * Convert a notice into an activity for export.
      *
-     * @param User $cur Current user
+     * @param Profile $scoped   The currently logged in/scoped profile
      *
      * @return Activity activity object representing this Notice.
      */
 
-    function asActivity($cur=null)
+    function asActivity(Profile $scoped=null)
     {
         $act = self::cacheGet(Cache::codeKey('notice:as-activity:'.$this->id));
 
@@ -1452,27 +1879,27 @@ class Notice extends Managed_DataObject
         }
         $act = new Activity();
 
-        if (Event::handle('StartNoticeAsActivity', array($this, &$act))) {
+        if (Event::handle('StartNoticeAsActivity', array($this, $act, $scoped))) {
 
             $act->id      = $this->uri;
             $act->time    = strtotime($this->created);
-            $act->link    = $this->bestUrl();
-            $act->content = common_xml_safe_str($this->rendered);
+            try {
+                $act->link    = $this->getUrl();
+            } catch (InvalidUrlException $e) {
+                // The notice is probably a share or similar, which don't
+                // have a representational URL of their own.
+            }
+            $act->content = common_xml_safe_str($this->getRendered());
 
             $profile = $this->getProfile();
 
-            $act->actor            = ActivityObject::fromProfile($profile);
-            $act->actor->extra[]   = $profile->profileInfo($cur);
+            $act->actor            = $profile->asActivityObject();
+            $act->actor->extra[]   = $profile->profileInfo($scoped);
 
             $act->verb = $this->verb;
 
-            if ($this->repeat_of) {
-                $repeated = Notice::getKV('id', $this->repeat_of);
-                if ($repeated instanceof Notice) {
-                    $act->objects[] = $repeated->asActivity($cur);
-                }
-            } else {
-                $act->objects[] = ActivityObject::fromNotice($this);
+            if (!$this->repeat_of) {
+                $act->objects[] = $this->asActivityObject();
             }
 
             // XXX: should this be handled by default processing for object entry?
@@ -1494,9 +1921,9 @@ class Notice extends Managed_DataObject
             $attachments = $this->attachments();
 
             foreach ($attachments as $attachment) {
-                // Save local attachments
+                // Include local attachments in Activity
                 if (!empty($attachment->filename)) {
-                    $act->attachments[] = ActivityObject::fromFile($attachment);
+                    $act->enclosures[] = $attachment->getEnclosure();
                 }
             }
 
@@ -1504,13 +1931,19 @@ class Notice extends Managed_DataObject
 
             try {
                 $reply = $this->getParent();
-                $ctx->replyToID  = $reply->uri;
-                $ctx->replyToUrl = $reply->bestUrl();
-            } catch (Exception $e) {
+                $ctx->replyToID  = $reply->getUri();
+                $ctx->replyToUrl = $reply->getUrl(true);    // true for fallback to local URL, less messy
+            } catch (NoParentNoticeException $e) {
                 // This is not a reply to something
+            } catch (NoResultException $e) {
+                // Parent notice was probably deleted
             }
 
-            $ctx->location = $this->getLocation();
+            try {
+                $ctx->location = Notice_location::locFromStored($this);
+            } catch (ServerException $e) {
+                $ctx->location = null;
+            }
 
             $conv = null;
 
@@ -1594,7 +2027,7 @@ class Notice extends Managed_DataObject
                 $act->editLink = $act->selfLink;
             }
 
-            Event::handle('EndNoticeAsActivity', array($this, &$act));
+            Event::handle('EndNoticeAsActivity', array($this, $act, $scoped));
         }
 
         self::cacheSet(Cache::codeKey('notice:as-activity:'.$this->id), $act);
@@ -1608,10 +2041,10 @@ class Notice extends Managed_DataObject
     function asAtomEntry($namespace=false,
                          $source=false,
                          $author=true,
-                         $cur=null)
+                         Profile $scoped=null)
     {
-        $act = $this->asActivity($cur);
-        $act->extra[] = $this->noticeInfo($cur);
+        $act = $this->asActivity($scoped);
+        $act->extra[] = $this->noticeInfo($scoped);
         return $act->asString($namespace, $author, $source);
     }
 
@@ -1621,12 +2054,12 @@ class Notice extends Managed_DataObject
      * Clients use some extra notice info in the atom stream.
      * This gives it to them.
      *
-     * @param User $cur Current user
+     * @param Profile $scoped   The currently logged in/scoped profile
      *
      * @return array representation of <statusnet:notice_info> element
      */
 
-    function noticeInfo($cur)
+    function noticeInfo(Profile $scoped=null)
     {
         // local notice ID (useful to clients for ordering)
 
@@ -1652,16 +2085,16 @@ class Notice extends Managed_DataObject
 
         // favorite and repeated
 
-        if (!empty($cur)) {
-            $cp = $cur->getProfile();
-            $noticeInfoAttr['favorite'] = ($cp->hasFave($this)) ? "true" : "false";
-            $noticeInfoAttr['repeated'] = ($cp->hasRepeated($this)) ? "true" : "false";
+        if ($scoped instanceof Profile) {
+            $noticeInfoAttr['repeated'] = ($scoped->hasRepeated($this)) ? "true" : "false";
         }
 
         if (!empty($this->repeat_of)) {
             $noticeInfoAttr['repeat_of'] = $this->repeat_of;
         }
 
+        Event::handle('StatusNetApiNoticeInfo', array($this, &$noticeInfoAttr, $scoped));
+
         return array('statusnet:notice_info', $noticeInfoAttr, null);
     }
 
@@ -1677,96 +2110,65 @@ class Notice extends Managed_DataObject
 
     function asActivityNoun($element)
     {
-        $noun = ActivityObject::fromNotice($this);
+        $noun = $this->asActivityObject();
         return $noun->asString('activity:' . $element);
     }
 
-    function bestUrl()
+    public function asActivityObject()
     {
-        if (!empty($this->url)) {
-            return $this->url;
-        } else if (!empty($this->uri) && preg_match('/^https?:/', $this->uri)) {
-            return $this->uri;
-        } else {
-            return common_local_url('shownotice',
-                                    array('notice' => $this->id));
+        $object = new ActivityObject();
+
+        if (Event::handle('StartActivityObjectFromNotice', array($this, &$object))) {
+            $object->type    = $this->object_type ?: ActivityObject::NOTE;
+            $object->id      = $this->getUri();
+            //FIXME: = $object->title ?: sprintf(... because we might get a title from StartActivityObjectFromNotice
+            $object->title   = sprintf('New %1$s by %2$s', ActivityObject::canonicalType($object->type), $this->getProfile()->getNickname());
+            $object->content = $this->getRendered();
+            $object->link    = $this->getUrl();
+
+            $object->extra[] = array('status_net', array('notice_id' => $this->id));
+
+            Event::handle('EndActivityObjectFromNotice', array($this, &$object));
         }
-    }
 
+        return $object;
+    }
 
     /**
      * Determine which notice, if any, a new notice is in reply to.
      *
      * For conversation tracking, we try to see where this notice fits
-     * in the tree. Rough algorithm is:
-     *
-     * if (reply_to is set and valid) {
-     *     return reply_to;
-     * } else if ((source not API or Web) and (content starts with "T NAME" or "@name ")) {
-     *     return ID of last notice by initial @name in content;
-     * }
+     * in the tree. Beware that this may very well give false positives
+     * and add replies to wrong threads (if there have been newer posts
+     * by the same user as we're replying to).
      *
-     * Note that all @nickname instances will still be used to save "reply" records,
-     * so the notice shows up in the mentioned users' "replies" tab.
-     *
-     * @param integer $reply_to   ID passed in by Web or API
-     * @param integer $profile_id ID of author
-     * @param string  $source     Source tag, like 'web' or 'gwibber'
+     * @param Profile $sender     Author profile
      * @param string  $content    Final notice content
      *
      * @return integer ID of replied-to notice, or null for not a reply.
      */
 
-    static function getReplyTo($reply_to, $profile_id, $source, $content)
+    static function getInlineReplyTo(Profile $sender, $content)
     {
-        static $lb = array('xmpp', 'mail', 'sms', 'omb');
-
-        // If $reply_to is specified, we check that it exists, and then
-        // return it if it does
-
-        if (!empty($reply_to)) {
-            $reply_notice = Notice::getKV('id', $reply_to);
-            if ($reply_notice instanceof Notice) {
-                return $reply_notice;
-            }
-        }
-
-        // If it's not a "low bandwidth" source (one where you can't set
-        // a reply_to argument), we return. This is mostly web and API
-        // clients.
-
-        if (!in_array($source, $lb)) {
-            return null;
-        }
-
         // Is there an initial @ or T?
-
-        if (preg_match('/^T ([A-Z0-9]{1,64}) /', $content, $match) ||
-            preg_match('/^@([a-z0-9]{1,64})\s+/', $content, $match)) {
+        if (preg_match('/^T ([A-Z0-9]{1,64}) /', $content, $match)
+                || preg_match('/^@([a-z0-9]{1,64})\s+/', $content, $match)) {
             $nickname = common_canonical_nickname($match[1]);
         } else {
             return null;
         }
 
         // Figure out who that is.
-
-        $sender = Profile::getKV('id', $profile_id);
-        if (!$sender instanceof Profile) {
-            return null;
-        }
-
         $recipient = common_relative_profile($sender, $nickname, common_sql_now());
 
-        if (!$recipient instanceof Profile) {
-            return null;
-        }
-
-        // Get their last notice
-
-        $last = $recipient->getCurrentNotice();
-
-        if ($last instanceof Notice) {
-            return $last;
+        if ($recipient instanceof Profile) {
+            // Get their last notice
+            $last = $recipient->getCurrentNotice();
+            if ($last instanceof Notice) {
+                return $last;
+            }
+            // Maybe in the future we want to handle something else below
+            // so don't return getCurrentNotice() immediately.
         }
 
         return null;
@@ -1788,43 +2190,26 @@ class Notice extends Managed_DataObject
         return ($contentlimit > 0 && !empty($content) && (mb_strlen($content) > $contentlimit));
     }
 
-    function getLocation()
-    {
-        $location = null;
-
-        if (!empty($this->location_id) && !empty($this->location_ns)) {
-            $location = Location::fromId($this->location_id, $this->location_ns);
-        }
-
-        if (is_null($location)) { // no ID, or Location::fromId() failed
-            if (!empty($this->lat) && !empty($this->lon)) {
-                $location = Location::fromLatLon($this->lat, $this->lon);
-            }
-        }
-
-        return $location;
-    }
-
     /**
      * Convenience function for posting a repeat of an existing message.
      *
-     * @param int $repeater_id: profile ID of user doing the repeat
+     * @param Profile $repeater Profile which is doing the repeat
      * @param string $source: posting source key, eg 'web', 'api', etc
      * @return Notice
      *
      * @throws Exception on failure or permission problems
      */
-    function repeat($repeater_id, $source)
+    function repeat(Profile $repeater, $source)
     {
-        $author = Profile::getKV('id', $this->profile_id);
+        $author = $this->getProfile();
 
         // TRANS: Message used to repeat a notice. RT is the abbreviation of 'retweet'.
         // TRANS: %1$s is the repeated user's name, %2$s is the repeated notice.
         $content = sprintf(_('RT @%1$s %2$s'),
-                           $author->nickname,
+                           $author->getNickname(),
                            $this->content);
 
-        $maxlen = common_config('site', 'textlimit');
+        $maxlen = self::maxContent();
         if ($maxlen > 0 && mb_strlen($content) > $maxlen) {
             // Web interface and current Twitter API clients will
             // pull the original notice's text, but some older
@@ -1835,9 +2220,9 @@ class Notice extends Managed_DataObject
             $content = mb_substr($content, 0, $maxlen - 4) . ' ...';
         }
 
-        // Scope is same as this one's
 
-        return self::saveNew($repeater_id,
+        // Scope is same as this one's
+        return self::saveNew($repeater->id,
                              $content,
                              $source,
                              array('repeat_of' => $this->id,
@@ -1891,7 +2276,7 @@ class Notice extends Managed_DataObject
         return $notice->fetchAll('id');
     }
 
-    function locationOptions($lat, $lon, $location_id, $location_ns, $profile = null)
+    static function locationOptions($lat, $lon, $location_id, $location_ns, $profile = null)
     {
         $options = array();
 
@@ -1975,6 +2360,16 @@ class Notice extends Managed_DataObject
         $reply->free();
     }
 
+    function clearLocation()
+    {
+        $loc = new Notice_location();
+        $loc->notice_id = $this->id;
+
+        if ($loc->find()) {
+            $loc->delete();
+        }
+    }
+
     function clearFiles()
     {
         $f2p = new File_to_post();
@@ -2006,24 +2401,6 @@ class Notice extends Managed_DataObject
         }
     }
 
-    function clearFaves()
-    {
-        $fave = new Fave();
-        $fave->notice_id = $this->id;
-
-        if ($fave->find()) {
-            while ($fave->fetch()) {
-                self::blow('fave:ids_by_user_own:%d', $fave->user_id);
-                self::blow('fave:ids_by_user_own:%d;last', $fave->user_id);
-                self::blow('fave:ids_by_user:%d', $fave->user_id);
-                self::blow('fave:ids_by_user:%d;last', $fave->user_id);
-                $fave->delete();
-            }
-        }
-
-        $fave->free();
-    }
-
     function clearTags()
     {
         $tag = new Notice_tag();
@@ -2067,8 +2444,11 @@ class Notice extends Managed_DataObject
         // If there's a failure, we want to _force_
         // distribution at this point.
         try {
+            $json = json_encode((object)array('id' => $this->getID(),
+                                              'type' => 'Notice',
+                                              ));
             $qm = QueueManager::get();
-            $qm->enqueue($this, 'distrib');
+            $qm->enqueue($json, 'distrib');
         } catch (Exception $e) {
             // If the exception isn't transient, this
             // may throw more exceptions as DQH does
@@ -2088,20 +2468,47 @@ class Notice extends Managed_DataObject
     {
         $result = parent::insert();
 
-        if ($result !== false) {
-            // Profile::hasRepeated() abuses pkeyGet(), so we
-            // have to clear manually
-            if (!empty($this->repeat_of)) {
-                $c = self::memcache();
-                if (!empty($c)) {
-                    $ck = self::multicacheKey('Notice',
-                                              array('profile_id' => $this->profile_id,
-                                                    'repeat_of' => $this->repeat_of));
-                    $c->delete($ck);
-                }
+        if ($result === false) {
+            common_log_db_error($this, 'INSERT', __FILE__);
+            // TRANS: Server exception thrown when a stored object entry cannot be saved.
+            throw new ServerException('Could not save Notice');
+        }
+
+        // Profile::hasRepeated() abuses pkeyGet(), so we
+        // have to clear manually
+        if (!empty($this->repeat_of)) {
+            $c = self::memcache();
+            if (!empty($c)) {
+                $ck = self::multicacheKey('Notice',
+                                          array('profile_id' => $this->profile_id,
+                                                'repeat_of' => $this->repeat_of));
+                $c->delete($ck);
             }
         }
 
+        // Update possibly ID-dependent columns: URI, conversation
+        // (now that INSERT has added the notice's local id)
+        $orig = clone($this);
+        $changed = false;
+
+        // We can only get here if it's a local notice, since remote notices
+        // should've bailed out earlier due to lacking a URI.
+        if (empty($this->uri)) {
+            $this->uri = sprintf('%s%s=%d:%s=%s',
+                                TagURI::mint(),
+                                'noticeId', $this->id,
+                                'objectType', $this->getObjectType(true));
+            $changed = true;
+        }
+
+        if ($changed && $this->update($orig) === false) {
+            common_log_db_error($notice, 'UPDATE', __FILE__);
+            // TRANS: Server exception thrown when a notice cannot be updated.
+            throw new ServerException(_('Problem saving notice.'));
+        }
+
+        $this->blowOnInsert();
+
         return $result;
     }
 
@@ -2113,31 +2520,34 @@ class Notice extends Managed_DataObject
      */
     function getSource()
     {
+        if (empty($this->source)) {
+            return false;
+        }
+
         $ns = new Notice_source();
-        if (!empty($this->source)) {
-            switch ($this->source) {
-            case 'web':
-            case 'xmpp':
-            case 'mail':
-            case 'omb':
-            case 'system':
-            case 'api':
+        switch ($this->source) {
+        case 'web':
+        case 'xmpp':
+        case 'mail':
+        case 'omb':
+        case 'system':
+        case 'api':
+            $ns->code = $this->source;
+            break;
+        default:
+            $ns = Notice_source::getKV($this->source);
+            if (!$ns) {
+                $ns = new Notice_source();
                 $ns->code = $this->source;
-                break;
-            default:
-                $ns = Notice_source::getKV($this->source);
-                if (!$ns) {
-                    $ns = new Notice_source();
-                    $ns->code = $this->source;
-                    $app = Oauth_application::getKV('name', $this->source);
-                    if ($app) {
-                        $ns->name = $app->name;
-                        $ns->url  = $app->source_url;
-                    }
+                $app = Oauth_application::getKV('name', $this->source);
+                if ($app) {
+                    $ns->name = $app->name;
+                    $ns->url  = $app->source_url;
                 }
-                break;
             }
+            break;
         }
+
         return $ns;
     }
 
@@ -2149,8 +2559,18 @@ class Notice extends Managed_DataObject
 
     public function isLocal()
     {
-        return ($this->is_local == Notice::LOCAL_PUBLIC ||
-                $this->is_local == Notice::LOCAL_NONPUBLIC);
+        $is_local = intval($this->is_local);
+        return ($is_local === self::LOCAL_PUBLIC || $is_local === self::LOCAL_NONPUBLIC);
+    }
+
+    public function getScope()
+    {
+        return intval($this->scope);
+    }
+
+    public function isRepeat()
+    {
+        return !empty($this->repeat_of);
     }
 
     /**
@@ -2295,12 +2715,8 @@ class Notice extends Managed_DataObject
 
     function isPublic()
     {
-        if (common_config('public', 'localonly')) {
-            return ($this->is_local == Notice::LOCAL_PUBLIC);
-        } else {
-            return (($this->is_local != Notice::LOCAL_NONPUBLIC) &&
-                    ($this->is_local != Notice::GATEWAY));
-        }
+        return (($this->is_local != Notice::LOCAL_NONPUBLIC) &&
+                ($this->is_local != Notice::GATEWAY));
     }
 
     /**
@@ -2342,95 +2758,71 @@ class Notice extends Managed_DataObject
 
     protected function _inScope($profile)
     {
-        if (!is_null($this->scope)) {
-            $scope = $this->scope;
-        } else {
-            $scope = self::defaultScope();
-        }
-
-        // If there's no scope, anyone (even anon) is in scope.
-
-        if ($scope == 0) { // Not private
+        $scope = is_null($this->scope) ? self::defaultScope() : $this->getScope();
 
+        if ($scope === 0 && !$this->getProfile()->isPrivateStream()) { // Not scoping, so it is public.
             return !$this->isHiddenSpam($profile);
+        }
 
-        } else { // Private, somehow
-
-            // If there's scope, anon cannot be in scope
+        // If there's scope, anon cannot be in scope
+        if (empty($profile)) {
+            return false;
+        }
 
-            if (empty($profile)) {
-                return false;
-            }
+        // Author is always in scope
+        if ($this->profile_id == $profile->id) {
+            return true;
+        }
 
-            // Author is always in scope
+        // Only for users on this site
+        if (($scope & Notice::SITE_SCOPE) && !$profile->isLocal()) {
+            return false;
+        }
 
-            if ($this->profile_id == $profile->id) {
-                return true;
-            }
+        // Only for users mentioned in the notice
+        if ($scope & Notice::ADDRESSEE_SCOPE) {
 
-            // Only for users on this site
+            $reply = Reply::pkeyGet(array('notice_id' => $this->id,
+                                         'profile_id' => $profile->id));
 
-            if (($scope & Notice::SITE_SCOPE) && !$profile->isLocal()) {
+            if (!$reply instanceof Reply) {
                 return false;
             }
+        }
 
-            // Only for users mentioned in the notice
-
-            if ($scope & Notice::ADDRESSEE_SCOPE) {
-
-                $reply = Reply::pkeyGet(array('notice_id' => $this->id,
-                                             'profile_id' => $profile->id));
-                                                                                
-                if (!$reply instanceof Reply) {
-                    return false;
-                }
-            }
-
-            // Only for members of the given group
-
-            if ($scope & Notice::GROUP_SCOPE) {
-
-                // XXX: just query for the single membership
+        // Only for members of the given group
+        if ($scope & Notice::GROUP_SCOPE) {
 
-                $groups = $this->getGroups();
+            // XXX: just query for the single membership
 
-                $foundOne = false;
+            $groups = $this->getGroups();
 
-                foreach ($groups as $group) {
-                    if ($profile->isMember($group)) {
-                        $foundOne = true;
-                        break;
-                    }
-                }
+            $foundOne = false;
 
-                if (!$foundOne) {
-                    return false;
+            foreach ($groups as $group) {
+                if ($profile->isMember($group)) {
+                    $foundOne = true;
+                    break;
                 }
             }
 
-            // Only for followers of the author
-
-            $author = null;
+            if (!$foundOne) {
+                return false;
+            }
+        }
 
-            if ($scope & Notice::FOLLOWER_SCOPE) {
+        if ($scope & Notice::FOLLOWER_SCOPE || $this->getProfile()->isPrivateStream()) {
 
-                try {
-                    $author = $this->getProfile();
-                } catch (Exception $e) {
-                    return false;
-                }
-        
-                if (!Subscription::exists($profile, $author)) {
-                    return false;
-                }
+            if (!Subscription::exists($profile, $this->getProfile())) {
+                return false;
             }
-
-            return !$this->isHiddenSpam($profile);
         }
+
+        return !$this->isHiddenSpam($profile);
     }
 
     function isHiddenSpam($profile) {
-        
+
         // Hide posts by silenced users from everyone but moderators.
 
         if (common_config('notice', 'hidespam')) {
@@ -2453,15 +2845,35 @@ class Notice extends Managed_DataObject
         return false;
     }
 
+    public function hasParent()
+    {
+        try {
+            $this->getParent();
+        } catch (NoParentNoticeException $e) {
+            return false;
+        }
+        return true;
+    }
+
     public function getParent()
     {
-        $parent = Notice::getKV('id', $this->reply_to);
+        $reply_to_id = null;
 
-        if (!$parent instanceof Notice) {
-            throw new ServerException('Notice has no parent');
+        if (empty($this->reply_to)) {
+            throw new NoParentNoticeException($this);
         }
 
-        return $parent;
+        // The reply_to ID in the table Notice could exist with a number
+        // however, the replied to notice might not exist in the database.
+        // Thus we need to catch the exception and throw the NoParentNoticeException else
+        // the timeline will not display correctly.
+        try {
+            $reply_to_id = self::getByID($this->reply_to);
+        } catch(Exception $e){
+            throw new NoParentNoticeException($this);
+        }
+
+        return $reply_to_id;
     }
 
     /**
@@ -2480,7 +2892,7 @@ class Notice extends Managed_DataObject
         $skip = array('_profile', '_groups', '_attachments', '_faves', '_replies', '_repeats');
         return array_diff($vars, $skip);
     }
-    
+
     static function defaultScope()
     {
        $scope = common_config('notice', 'defaultscope');
@@ -2497,53 +2909,45 @@ class Notice extends Managed_DataObject
        static function fillProfiles($notices)
        {
                $map = self::getProfiles($notices);
-               
                foreach ($notices as $entry=>$notice) {
             try {
                        if (array_key_exists($notice->profile_id, $map)) {
                                $notice->_setProfile($map[$notice->profile_id]);
                        }
             } catch (NoProfileException $e) {
-                common_log(LOG_WARNING, "Failed to fill profile in Notice with non-existing entry for profile_id: {$e->id}");
+                common_log(LOG_WARNING, "Failed to fill profile in Notice with non-existing entry for profile_id: {$e->profile_id}");
                 unset($notices[$entry]);
             }
                }
-               
+
                return array_values($map);
        }
-       
+
        static function getProfiles(&$notices)
        {
                $ids = array();
                foreach ($notices as $notice) {
                        $ids[] = $notice->profile_id;
                }
-               
                $ids = array_unique($ids);
-               
-               return Profile::pivotGet('id', $ids); 
+               return Profile::pivotGet('id', $ids);
        }
-       
+
        static function fillGroups(&$notices)
        {
         $ids = self::_idsOf($notices);
-               
         $gis = Group_inbox::listGet('notice_id', $ids);
-               
         $gids = array();
 
-               foreach ($gis as $id => $gi)
-               {
+               foreach ($gis as $id => $gi) {
                    foreach ($gi as $g)
                    {
                        $gids[] = $g->group_id;
                    }
                }
-               
+
                $gids = array_unique($gids);
-               
                $group = User_group::pivotGet('id', $gids);
-               
                foreach ($notices as $notice)
                {
                        $grps = array();
@@ -2555,34 +2959,28 @@ class Notice extends Managed_DataObject
                }
        }
 
-    static function _idsOf(&$notices)
+    static function _idsOf(array &$notices)
     {
                $ids = array();
                foreach ($notices as $notice) {
-                       $ids[] = $notice->id;
+                       $ids[$notice->id] = true;
                }
-               $ids = array_unique($ids);
-        return $ids;
+               return array_keys($ids);
     }
 
     static function fillAttachments(&$notices)
     {
         $ids = self::_idsOf($notices);
-
         $f2pMap = File_to_post::listGet('post_id', $ids);
-               
                $fileIds = array();
-               
                foreach ($f2pMap as $noticeId => $f2ps) {
             foreach ($f2ps as $f2p) {
-                $fileIds[] = $f2p->file_id;    
+                $fileIds[] = $f2p->file_id;
             }
         }
 
         $fileIds = array_unique($fileIds);
-
                $fileMap = File::pivotGet('id', $fileIds);
-
                foreach ($notices as $notice)
                {
                        $files = array();
@@ -2594,47 +2992,6 @@ class Notice extends Managed_DataObject
                }
     }
 
-    protected $_faves;
-
-    /**
-     * All faves of this notice
-     *
-     * @return array Array of Fave objects
-     */
-
-    function getFaves()
-    {
-        if (isset($this->_faves) && is_array($this->_faves)) {
-            return $this->_faves;
-        }
-        $faveMap = Fave::listGet('notice_id', array($this->id));
-        $this->_faves = $faveMap[$this->id];
-        return $this->_faves;
-    }
-
-    function _setFaves($faves)
-    {
-        $this->_faves = $faves;
-    }
-
-    static function fillFaves(&$notices)
-    {
-        $ids = self::_idsOf($notices);
-        $faveMap = Fave::listGet('notice_id', $ids);
-        $cnt = 0;
-        $faved = array();
-        foreach ($faveMap as $id => $faves) {
-            $cnt += count($faves);
-            if (count($faves) > 0) {
-                $faved[] = $id;
-            }
-        }
-        foreach ($notices as $notice) {
-               $faves = $faveMap[$notice->id];
-            $notice->_setFaves($faves);
-        }
-    }
-
     static function fillReplies(&$notices)
     {
         $ids = self::_idsOf($notices);
@@ -2649,30 +3006,50 @@ class Notice extends Managed_DataObject
         }
     }
 
-    protected $_repeats;
-
-    function getRepeats()
+    static public function beforeSchemaUpdate()
     {
-        if (isset($this->_repeats) && is_array($this->_repeats)) {
-            return $this->_repeats;
+        $table = strtolower(get_called_class());
+        $schema = Schema::get();
+        $schemadef = $schema->getTableDef($table);
+
+        // 2015-09-04 We move Notice location data to Notice_location
+        // First we see if we have to do this at all
+        if (!isset($schemadef['fields']['lat'])
+                && !isset($schemadef['fields']['lon'])
+                && !isset($schemadef['fields']['location_id'])
+                && !isset($schemadef['fields']['location_ns'])) {
+            // We have already removed the location fields, so no need to migrate.
+            return;
         }
-        $repeatMap = Notice::listGet('repeat_of', array($this->id));
-        $this->_repeats = $repeatMap[$this->id];
-        return $this->_repeats;
-    }
+        // Then we make sure the Notice_location table is created!
+        $schema->ensureTable('notice_location', Notice_location::schemaDef());
 
-    function _setRepeats($repeats)
-    {
-        $this->_repeats = $repeats;
-    }
+        // Then we continue on our road to migration!
+        echo "\nFound old $table table, moving location data to 'notice_location' table... (this will probably take a LONG time, but can be aborted and continued)";
 
-    static function fillRepeats(&$notices)
-    {
-        $ids = self::_idsOf($notices);
-        $repeatMap = Notice::listGet('repeat_of', $ids);
-        foreach ($notices as $notice) {
-               $repeats = $repeatMap[$notice->id];
-            $notice->_setRepeats($repeats);
+        $notice = new Notice();
+        $notice->query(sprintf('SELECT id, lat, lon, location_id, location_ns FROM %1$s ' .
+                             'WHERE lat IS NOT NULL ' .
+                                'OR lon IS NOT NULL ' .
+                                'OR location_id IS NOT NULL ' .
+                                'OR location_ns IS NOT NULL',
+                             $schema->quoteIdentifier($table)));
+        print "\nFound {$notice->N} notices with location data, inserting";
+        while ($notice->fetch()) {
+            $notloc = Notice_location::getKV('notice_id', $notice->id);
+            if ($notloc instanceof Notice_location) {
+                print "-";
+                continue;
+            }
+            $notloc = new Notice_location();
+            $notloc->notice_id = $notice->id;
+            $notloc->lat= $notice->lat;
+            $notloc->lon= $notice->lon;
+            $notloc->location_id= $notice->location_id;
+            $notloc->location_ns= $notice->location_ns;
+            $notloc->insert();
+            print ".";
         }
+        print "\n";
     }
 }