2008-05-07 18:15:42 +01:00
|
|
|
<?php
|
2009-10-03 23:14:26 +01:00
|
|
|
/**
|
2009-08-25 23:14:12 +01:00
|
|
|
* StatusNet - the distributed open-source microblogging tool
|
2011-07-15 20:13:57 +01:00
|
|
|
* Copyright (C) 2008-2011 StatusNet, Inc.
|
2008-05-20 20:14:12 +01:00
|
|
|
*
|
2008-05-14 20:26:48 +01:00
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
2008-05-20 20:14:12 +01:00
|
|
|
*
|
2008-05-14 20:26:48 +01:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2008-12-23 19:19:07 +00:00
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2008-05-14 20:26:48 +01:00
|
|
|
* GNU Affero General Public License for more details.
|
2008-05-20 20:14:12 +01:00
|
|
|
*
|
2008-05-14 20:26:48 +01:00
|
|
|
* You should have received a copy of the GNU Affero General Public License
|
2008-12-23 19:19:07 +00:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2009-10-04 01:34:40 +01:00
|
|
|
*
|
2009-10-03 23:14:26 +01:00
|
|
|
* @category Notices
|
|
|
|
* @package StatusNet
|
|
|
|
* @author Brenda Wallace <shiny@cpan.org>
|
|
|
|
* @author Christopher Vollick <psycotica0@gmail.com>
|
|
|
|
* @author CiaranG <ciaran@ciarang.com>
|
|
|
|
* @author Craig Andrews <candrews@integralblue.com>
|
|
|
|
* @author Evan Prodromou <evan@controlezvous.ca>
|
|
|
|
* @author Gina Haeussge <osd@foosel.net>
|
|
|
|
* @author Jeffery To <jeffery.to@gmail.com>
|
|
|
|
* @author Mike Cochrane <mikec@mikenz.geek.nz>
|
|
|
|
* @author Robin Millette <millette@controlyourself.ca>
|
|
|
|
* @author Sarven Capadisli <csarven@controlyourself.ca>
|
|
|
|
* @author Tom Adams <tom@holizz.com>
|
2013-10-28 21:18:00 +00:00
|
|
|
* @author Mikael Nordfeldth <mmn@hethane.se>
|
2010-05-27 23:26:47 +01:00
|
|
|
* @copyright 2009 Free Software Foundation, Inc http://www.fsf.org
|
2009-10-03 23:14:26 +01:00
|
|
|
* @license GNU Affero General Public License http://www.gnu.org/licenses/
|
2008-05-14 20:26:48 +01:00
|
|
|
*/
|
2008-05-14 20:00:09 +01:00
|
|
|
|
2013-11-01 13:04:40 +00:00
|
|
|
if (!defined('GNUSOCIAL')) { exit(1); }
|
2008-05-14 20:00:09 +01:00
|
|
|
|
2008-05-07 18:15:42 +01:00
|
|
|
/**
|
2009-10-04 01:34:40 +01:00
|
|
|
* Table Definition for notice
|
|
|
|
*/
|
2008-05-07 18:15:42 +01:00
|
|
|
|
2010-07-21 20:29:47 +01:00
|
|
|
/* We keep 200 notices, the max number of notices available per API request,
|
single function for important streams, with memcached support
I moved the 4 streams for a user (with friends, faves, replies,
personal) into functions on the User object. Added a helper function
in Notice for making notice streams. Also, will fetch notice streams
out of the memcached server, if possible. Made the API, RSS, and HTML
output all use the same streams (hopefully cached).
Added some code to Notice to blow the cache when a notice is posted.
Also, added code to favor and disfavor actions to blow the faves
cache, too.
darcs-hash:20080928120119-5ed1f-ead542348bcd3cf315be6f42934353154402eb16.gz
2008-09-28 13:01:19 +01:00
|
|
|
* in the memcached cache. */
|
|
|
|
|
2011-03-24 22:04:19 +00:00
|
|
|
define('NOTICE_CACHE_WINDOW', CachingNoticeStream::CACHE_WINDOW);
|
single function for important streams, with memcached support
I moved the 4 streams for a user (with friends, faves, replies,
personal) into functions on the User object. Added a helper function
in Notice for making notice streams. Also, will fetch notice streams
out of the memcached server, if possible. Made the API, RSS, and HTML
output all use the same streams (hopefully cached).
Added some code to Notice to blow the cache when a notice is posted.
Also, added code to favor and disfavor actions to blow the faves
cache, too.
darcs-hash:20080928120119-5ed1f-ead542348bcd3cf315be6f42934353154402eb16.gz
2008-09-28 13:01:19 +01:00
|
|
|
|
2009-06-26 08:47:27 +01:00
|
|
|
define('MAX_BOXCARS', 128);
|
|
|
|
|
2011-08-22 22:52:02 +01:00
|
|
|
class Notice extends Managed_DataObject
|
2008-05-07 18:15:42 +01:00
|
|
|
{
|
2008-12-23 19:19:07 +00:00
|
|
|
###START_AUTOCODE
|
|
|
|
/* the code below is auto generated do not remove the above tag */
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-02-16 23:26:15 +00:00
|
|
|
public $__table = 'notice'; // table name
|
|
|
|
public $id; // int(4) primary_key not_null
|
2009-12-11 15:22:56 +00:00
|
|
|
public $profile_id; // int(4) multiple_key not_null
|
2008-12-23 19:19:07 +00:00
|
|
|
public $uri; // varchar(255) unique_key
|
2009-12-11 15:22:56 +00:00
|
|
|
public $content; // text
|
|
|
|
public $rendered; // text
|
2008-12-23 19:19:07 +00:00
|
|
|
public $url; // varchar(255)
|
2009-12-11 15:22:56 +00:00
|
|
|
public $created; // datetime multiple_key not_null default_0000-00-00%2000%3A00%3A00
|
|
|
|
public $modified; // timestamp not_null default_CURRENT_TIMESTAMP
|
2009-02-16 23:26:15 +00:00
|
|
|
public $reply_to; // int(4)
|
2010-01-07 20:59:31 +00:00
|
|
|
public $is_local; // int(4)
|
2009-02-16 23:26:15 +00:00
|
|
|
public $source; // varchar(32)
|
2009-02-26 21:37:00 +00:00
|
|
|
public $conversation; // int(4)
|
2009-09-15 23:28:44 +01:00
|
|
|
public $lat; // decimal(10,7)
|
|
|
|
public $lon; // decimal(10,7)
|
|
|
|
public $location_id; // int(4)
|
|
|
|
public $location_ns; // int(4)
|
2009-12-11 15:22:56 +00:00
|
|
|
public $repeat_of; // int(4)
|
2011-08-22 21:02:14 +01:00
|
|
|
public $verb; // varchar(255)
|
2011-03-07 19:20:55 +00:00
|
|
|
public $object_type; // varchar(255)
|
2011-03-17 02:30:31 +00:00
|
|
|
public $scope; // int(4)
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2008-12-23 19:19:07 +00:00
|
|
|
/* the code above is auto generated do not remove the tag below */
|
|
|
|
###END_AUTOCODE
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2011-08-22 22:52:02 +01:00
|
|
|
public static function schemaDef()
|
|
|
|
{
|
2011-09-18 23:28:44 +01:00
|
|
|
$def = array(
|
2011-08-22 22:52:02 +01:00
|
|
|
'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'),
|
2011-08-27 21:33:15 +01:00
|
|
|
'content' => array('type' => 'text', 'description' => 'update content', 'collate' => 'utf8_general_ci'),
|
2011-08-22 22:52:02 +01:00
|
|
|
'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)'),
|
|
|
|
'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'),
|
2011-08-23 16:42:18 +01:00
|
|
|
'verb' => array('type' => 'varchar', 'length' => 255, 'description' => 'URI representing activity streams verb', 'default' => 'http://activitystrea.ms/schema/1.0/post'),
|
2011-08-22 22:52:02 +01:00
|
|
|
'scope' => array('type' => 'int',
|
2011-09-08 17:38:11 +01:00
|
|
|
'description' => 'bit map for distribution scope; 0 = everywhere; 1 = this server only; 2 = addressees; 4 = followers; null = default'),
|
2011-08-22 22:52:02 +01:00
|
|
|
),
|
|
|
|
'primary key' => array('id'),
|
|
|
|
'unique keys' => array(
|
|
|
|
'notice_uri_key' => array('uri'),
|
|
|
|
),
|
|
|
|
'foreign keys' => array(
|
|
|
|
'notice_profile_id_fkey' => array('profile', array('profile_id' => 'id')),
|
|
|
|
'notice_reply_to_fkey' => array('notice', array('reply_to' => 'id')),
|
|
|
|
'notice_conversation_fkey' => array('conversation', array('conversation' => 'id')), # note... used to refer to notice.id
|
|
|
|
'notice_repeat_of_fkey' => array('notice', array('repeat_of' => 'id')), # @fixme: what about repeats of deleted notices?
|
|
|
|
),
|
|
|
|
'indexes' => array(
|
2011-10-20 17:50:39 +01:00
|
|
|
'notice_created_id_is_local_idx' => array('created', 'id', 'is_local'),
|
2011-08-22 22:52:02 +01:00
|
|
|
'notice_profile_id_idx' => array('profile_id', 'created', 'id'),
|
2011-10-20 17:50:39 +01:00
|
|
|
'notice_repeat_of_created_id_idx' => array('repeat_of', 'created', 'id'),
|
|
|
|
'notice_conversation_created_id_idx' => array('conversation', 'created', 'id'),
|
|
|
|
'notice_replyto_idx' => array('reply_to')
|
2011-08-22 22:52:02 +01:00
|
|
|
)
|
|
|
|
);
|
2011-09-18 23:28:44 +01:00
|
|
|
|
|
|
|
if (common_config('search', 'type') == 'fulltext') {
|
|
|
|
$def['fulltext indexes'] = array('content' => array('content'));
|
|
|
|
}
|
|
|
|
|
|
|
|
return $def;
|
2011-08-22 22:52:02 +01:00
|
|
|
}
|
2011-07-14 17:02:58 +01:00
|
|
|
|
2009-08-28 04:09:07 +01:00
|
|
|
/* Notice types */
|
2009-08-19 07:34:17 +01:00
|
|
|
const LOCAL_PUBLIC = 1;
|
2011-07-15 20:13:57 +01:00
|
|
|
const REMOTE = 0;
|
2009-08-19 07:34:17 +01:00
|
|
|
const LOCAL_NONPUBLIC = -1;
|
|
|
|
const GATEWAY = -2;
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2011-03-29 16:53:26 +01:00
|
|
|
const PUBLIC_SCOPE = 0; // Useful fake constant
|
2011-03-17 02:54:57 +00:00
|
|
|
const SITE_SCOPE = 1;
|
|
|
|
const ADDRESSEE_SCOPE = 2;
|
2011-03-22 15:36:48 +00:00
|
|
|
const GROUP_SCOPE = 4;
|
|
|
|
const FOLLOWER_SCOPE = 8;
|
2011-03-17 02:54:57 +00:00
|
|
|
|
2014-06-03 11:22:07 +01:00
|
|
|
protected $_profile = array();
|
2014-03-05 00:27:27 +00:00
|
|
|
|
2014-06-04 23:07:04 +01:00
|
|
|
/**
|
|
|
|
* Will always return a profile, if anything fails it will
|
|
|
|
* (through _setProfile) throw a NoProfileException.
|
|
|
|
*/
|
2013-10-23 11:24:20 +01:00
|
|
|
public function getProfile()
|
2008-12-23 19:33:23 +00:00
|
|
|
{
|
2014-06-03 11:22:07 +01:00
|
|
|
if (!isset($this->_profile[$this->profile_id])) {
|
2013-08-18 12:04:58 +01:00
|
|
|
$this->_setProfile(Profile::getKV('id', $this->profile_id));
|
2010-07-13 15:51:25 +01:00
|
|
|
}
|
2014-06-03 11:22:07 +01:00
|
|
|
return $this->_profile[$this->profile_id];
|
2008-12-23 19:19:07 +00:00
|
|
|
}
|
2011-08-01 19:51:59 +01:00
|
|
|
|
2014-03-05 00:27:27 +00:00
|
|
|
public function _setProfile(Profile $profile=null)
|
2011-08-01 19:51:59 +01:00
|
|
|
{
|
2014-03-05 00:27:27 +00:00
|
|
|
if (!$profile instanceof Profile) {
|
|
|
|
throw new NoProfileException($this->profile_id);
|
|
|
|
}
|
2014-06-03 11:22:07 +01:00
|
|
|
$this->_profile[$this->profile_id] = $profile;
|
2011-08-01 19:51:59 +01:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2013-10-29 09:20:57 +00:00
|
|
|
function delete($useWhere=false)
|
2008-12-23 19:33:23 +00:00
|
|
|
{
|
2009-07-16 05:52:23 +01:00
|
|
|
// For auditing purposes, save a record that the notice
|
|
|
|
// was deleted.
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-05-24 15:47:15 +01:00
|
|
|
// @fixme we have some cases where things get re-run and so the
|
|
|
|
// insert fails.
|
2013-08-18 12:04:58 +01:00
|
|
|
$deleted = Deleted_notice::getKV('id', $this->id);
|
2010-12-28 06:58:13 +00:00
|
|
|
|
2013-10-29 09:20:57 +00:00
|
|
|
if (!$deleted instanceof Deleted_notice) {
|
2013-08-18 12:04:58 +01:00
|
|
|
$deleted = Deleted_notice::getKV('uri', $this->uri);
|
2010-12-28 06:58:13 +00:00
|
|
|
}
|
|
|
|
|
2013-10-29 09:20:57 +00:00
|
|
|
if (!$deleted instanceof Deleted_notice) {
|
2010-05-24 15:47:15 +01:00
|
|
|
$deleted = new Deleted_notice();
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-05-24 15:47:15 +01:00
|
|
|
$deleted->id = $this->id;
|
|
|
|
$deleted->profile_id = $this->profile_id;
|
|
|
|
$deleted->uri = $this->uri;
|
|
|
|
$deleted->created = $this->created;
|
|
|
|
$deleted->deleted = common_sql_now();
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-05-24 15:47:15 +01:00
|
|
|
$deleted->insert();
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-08-14 19:54:20 +01:00
|
|
|
if (Event::handle('NoticeDeleteRelated', array($this))) {
|
2009-12-12 21:02:44 +00:00
|
|
|
|
2010-08-14 19:54:20 +01:00
|
|
|
// Clear related records
|
2009-12-12 21:02:44 +00:00
|
|
|
|
2010-08-14 19:54:20 +01:00
|
|
|
$this->clearReplies();
|
|
|
|
$this->clearRepeats();
|
|
|
|
$this->clearTags();
|
|
|
|
$this->clearGroupInboxes();
|
2010-12-28 21:44:18 +00:00
|
|
|
$this->clearFiles();
|
2014-03-06 13:43:36 +00:00
|
|
|
$this->clearAttentions();
|
2010-08-14 19:54:20 +01:00
|
|
|
|
|
|
|
// NOTE: we don't clear queue items
|
|
|
|
}
|
2009-10-13 22:38:27 +01:00
|
|
|
|
2013-10-29 09:20:57 +00:00
|
|
|
$result = parent::delete($useWhere);
|
2010-03-15 21:19:22 +00:00
|
|
|
|
|
|
|
$this->blowOnDelete();
|
|
|
|
return $result;
|
2008-12-23 19:19:07 +00:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2013-10-06 20:30:29 +01:00
|
|
|
public function getUri()
|
|
|
|
{
|
|
|
|
return $this->uri;
|
|
|
|
}
|
|
|
|
|
2014-05-01 14:25:19 +01:00
|
|
|
/*
|
|
|
|
* @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.
|
|
|
|
*/
|
2014-05-01 13:28:18 +01:00
|
|
|
public function getLocalUrl()
|
|
|
|
{
|
|
|
|
return common_local_url('shownotice', array('notice' => $this->id), null, null, false);
|
|
|
|
}
|
|
|
|
|
2014-06-21 20:01:17 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-05-01 14:25:19 +01:00
|
|
|
/*
|
|
|
|
* Get the original representation URL of this notice.
|
|
|
|
*/
|
2013-10-20 14:32:56 +01:00
|
|
|
public function getUrl()
|
|
|
|
{
|
|
|
|
// The risk is we start having empty urls and non-http uris...
|
2014-04-18 22:17:15 +01:00
|
|
|
// and we can't really handle any other protocol right now.
|
|
|
|
switch (true) {
|
2014-04-18 22:53:16 +01:00
|
|
|
case common_valid_http_url($this->url): // should we allow non-http/https URLs?
|
2014-04-18 22:17:15 +01:00
|
|
|
return $this->url;
|
2014-04-18 22:53:16 +01:00
|
|
|
case $this->isLocal():
|
|
|
|
// let's generate a valid link to our locally available notice on demand
|
|
|
|
return common_local_url('shownotice', array('notice' => $this->id), null, null, false);
|
2014-04-18 22:17:15 +01:00
|
|
|
case common_valid_http_url($this->uri):
|
|
|
|
return $this->uri;
|
|
|
|
default:
|
2014-04-18 22:53:16 +01:00
|
|
|
common_debug('No URL available for notice: id='.$this->id);
|
2014-04-19 21:13:48 +01:00
|
|
|
throw new InvalidUrlException($this->url);
|
2014-04-18 22:17:15 +01:00
|
|
|
}
|
2013-10-20 14:32:56 +01:00
|
|
|
}
|
|
|
|
|
2014-04-18 21:42:01 +01:00
|
|
|
public function get_object_type($canonical=false) {
|
|
|
|
return $canonical
|
|
|
|
? ActivityObject::canonicalType($this->object_type)
|
|
|
|
: $this->object_type;
|
|
|
|
}
|
|
|
|
|
2014-01-12 21:41:30 +00:00
|
|
|
public static function getByUri($uri)
|
2014-01-12 21:37:41 +00:00
|
|
|
{
|
2014-01-12 21:46:50 +00:00
|
|
|
$notice = new Notice();
|
|
|
|
$notice->uri = $uri;
|
|
|
|
if (!$notice->find(true)) {
|
|
|
|
throw new NoResultException($notice);
|
|
|
|
}
|
|
|
|
return $notice;
|
2014-01-12 21:37:41 +00:00
|
|
|
}
|
|
|
|
|
2010-02-25 19:26:33 +00:00
|
|
|
/**
|
|
|
|
* Extract #hashtags from this notice's content and save them to the database.
|
|
|
|
*/
|
2008-12-23 19:33:23 +00:00
|
|
|
function saveTags()
|
|
|
|
{
|
2008-12-23 19:19:07 +00:00
|
|
|
/* extract all #hastags */
|
2011-02-24 00:37:55 +00:00
|
|
|
$count = preg_match_all('/(?:^|\s)#([\pL\pN_\-\.]{1,64})/u', strtolower($this->content), $match);
|
2008-12-23 19:19:07 +00:00
|
|
|
if (!$count) {
|
|
|
|
return true;
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-02-25 19:26:33 +00:00
|
|
|
/* Add them to the database */
|
|
|
|
return $this->saveKnownTags($match[1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Record the given set of hash tags in the db for this notice.
|
|
|
|
* Given tag strings will be normalized and checked for dupes.
|
|
|
|
*/
|
|
|
|
function saveKnownTags($hashtags)
|
|
|
|
{
|
2009-07-20 03:18:48 +01:00
|
|
|
//turn each into their canonical tag
|
|
|
|
//this is needed to remove dupes before saving e.g. #hash.tag = #hashtag
|
2010-02-25 19:26:33 +00:00
|
|
|
for($i=0; $i<count($hashtags); $i++) {
|
2010-04-14 10:09:54 +01:00
|
|
|
/* elide characters we don't want in the tag */
|
2010-02-25 19:26:33 +00:00
|
|
|
$hashtags[$i] = common_canonical_tag($hashtags[$i]);
|
2009-07-20 03:18:48 +01:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-07-20 03:18:48 +01:00
|
|
|
foreach(array_unique($hashtags) as $hashtag) {
|
2009-02-16 23:02:31 +00:00
|
|
|
$this->saveTag($hashtag);
|
2010-01-30 19:37:39 +00:00
|
|
|
self::blow('profile:notice_ids_tagged:%d:%s', $this->profile_id, $hashtag);
|
2008-12-23 19:19:07 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-02-25 19:26:33 +00:00
|
|
|
/**
|
|
|
|
* Record a single hash tag as associated with this notice.
|
|
|
|
* Tag format and uniqueness must be validated by caller.
|
|
|
|
*/
|
2009-02-16 23:02:31 +00:00
|
|
|
function saveTag($hashtag)
|
|
|
|
{
|
|
|
|
$tag = new Notice_tag();
|
|
|
|
$tag->notice_id = $this->id;
|
|
|
|
$tag->tag = $hashtag;
|
|
|
|
$tag->created = $this->created;
|
|
|
|
$id = $tag->insert();
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-02-16 23:02:31 +00:00
|
|
|
if (!$id) {
|
2010-04-11 00:08:51 +01:00
|
|
|
// TRANS: Server exception. %s are the error details.
|
2011-04-10 18:59:55 +01:00
|
|
|
throw new ServerException(sprintf(_('Database error inserting hashtag: %s.'),
|
2009-02-16 23:02:31 +00:00
|
|
|
$last_error->message));
|
|
|
|
return;
|
|
|
|
}
|
2010-01-25 23:08:21 +00:00
|
|
|
|
|
|
|
// if it's saved, blow its cache
|
|
|
|
$tag->blowCache(false);
|
2009-02-16 23:02:31 +00:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-12-15 23:27:03 +00:00
|
|
|
/**
|
|
|
|
* Save a new notice and push it out to subscribers' inboxes.
|
|
|
|
* Poster's permissions are checked before sending.
|
|
|
|
*
|
|
|
|
* @param int $profile_id Profile ID of the poster
|
|
|
|
* @param string $content source message text; links may be shortened
|
|
|
|
* per current user's preference
|
|
|
|
* @param string $source source key ('web', 'api', etc)
|
|
|
|
* @param array $options Associative array of optional properties:
|
|
|
|
* string 'created' timestamp of notice; defaults to now
|
|
|
|
* int 'is_local' source/gateway ID, one of:
|
|
|
|
* Notice::LOCAL_PUBLIC - Local, ok to appear in public timeline
|
2011-07-15 20:13:57 +01:00
|
|
|
* Notice::REMOTE - Sent from a remote service;
|
2009-12-15 23:27:03 +00:00
|
|
|
* hide from public timeline but show in
|
|
|
|
* local "and friends" timelines
|
|
|
|
* Notice::LOCAL_NONPUBLIC - Local, but hide from public timeline
|
2011-07-15 20:13:57 +01:00
|
|
|
* Notice::GATEWAY - From another non-OStatus service;
|
2009-12-15 23:27:03 +00:00
|
|
|
* will not appear in public views
|
|
|
|
* float 'lat' decimal latitude for geolocation
|
|
|
|
* float 'lon' decimal longitude for geolocation
|
|
|
|
* int 'location_id' geoname identifier
|
|
|
|
* int 'location_ns' geoname namespace to interpret location_id
|
|
|
|
* int 'reply_to'; notice ID this is a reply to
|
|
|
|
* int 'repeat_of'; notice ID this is a repeat of
|
2014-04-18 21:42:01 +01:00
|
|
|
* string 'uri' unique ID for notice; a unique tag uri (can be url or anything too)
|
2010-02-23 00:44:45 +00:00
|
|
|
* string 'url' permalink to notice; defaults to local notice URL
|
|
|
|
* string 'rendered' rendered HTML version of content
|
|
|
|
* array 'replies' list of profile URIs for reply delivery in
|
|
|
|
* place of extracting @-replies from content.
|
|
|
|
* array 'groups' list of group IDs to deliver to, in place of
|
|
|
|
* extracting ! tags from content
|
2010-02-25 19:26:33 +00:00
|
|
|
* array 'tags' list of hashtag strings to save with the notice
|
|
|
|
* in place of extracting # tags from content
|
2010-03-03 00:30:09 +00:00
|
|
|
* array 'urls' list of attached/referred URLs to save with the
|
|
|
|
* notice in place of extracting links from content
|
2010-12-16 21:17:38 +00:00
|
|
|
* boolean 'distribute' whether to distribute the notice, default true
|
2011-03-07 19:20:55 +00:00
|
|
|
* string 'object_type' URL of the associated object type (default ActivityObject::NOTE)
|
2011-08-22 21:02:14 +01:00
|
|
|
* string 'verb' URL of the associated verb (default ActivityVerb::POST)
|
2011-03-26 19:49:46 +00:00
|
|
|
* int 'scope' Scope bitmask; default to SITE_SCOPE on private sites, 0 otherwise
|
2011-01-28 23:33:13 +00:00
|
|
|
*
|
2010-02-23 00:44:45 +00:00
|
|
|
* @fixme tag override
|
2009-12-15 23:27:03 +00:00
|
|
|
*
|
|
|
|
* @return Notice
|
|
|
|
* @throws ClientException
|
|
|
|
*/
|
2013-08-29 09:27:39 +01:00
|
|
|
static function saveNew($profile_id, $content, $source, array $options=null) {
|
2009-12-15 21:05:05 +00:00
|
|
|
$defaults = array('uri' => null,
|
2010-02-21 14:17:00 +00:00
|
|
|
'url' => null,
|
2009-12-15 21:05:05 +00:00
|
|
|
'reply_to' => null,
|
2010-12-16 21:17:38 +00:00
|
|
|
'repeat_of' => null,
|
2011-03-26 19:49:46 +00:00
|
|
|
'scope' => null,
|
2011-08-22 21:02:14 +01:00
|
|
|
'distribute' => true,
|
|
|
|
'object_type' => null,
|
|
|
|
'verb' => null);
|
2009-12-11 16:29:51 +00:00
|
|
|
|
2011-07-20 16:53:47 +01:00
|
|
|
if (!empty($options) && is_array($options)) {
|
|
|
|
$options = array_merge($defaults, $options);
|
2009-12-11 16:29:51 +00:00
|
|
|
extract($options);
|
2010-08-12 23:18:50 +01:00
|
|
|
} else {
|
|
|
|
extract($defaults);
|
2009-12-11 16:29:51 +00:00
|
|
|
}
|
|
|
|
|
2010-01-02 18:36:47 +00:00
|
|
|
if (!isset($is_local)) {
|
2009-12-11 16:29:51 +00:00
|
|
|
$is_local = Notice::LOCAL_PUBLIC;
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2013-08-18 12:04:58 +01:00
|
|
|
$profile = Profile::getKV('id', $profile_id);
|
2013-10-28 21:18:00 +00:00
|
|
|
if (!$profile instanceof Profile) {
|
|
|
|
// TRANS: Client exception thrown when trying to save a notice for an unknown user.
|
|
|
|
throw new ClientException(_('Problem saving notice. Unknown user.'));
|
|
|
|
}
|
|
|
|
|
2013-08-18 12:04:58 +01:00
|
|
|
$user = User::getKV('id', $profile_id);
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($user instanceof User) {
|
2010-12-02 18:56:44 +00:00
|
|
|
// Use the local user's shortening preferences, if applicable.
|
|
|
|
$final = $user->shortenLinks($content);
|
|
|
|
} else {
|
|
|
|
$final = common_shorten_links($content);
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
|
|
|
if (Notice::contentTooLong($final)) {
|
2010-07-29 10:34:58 +01:00
|
|
|
// TRANS: Client exception thrown if a notice contains too many characters.
|
2009-10-04 01:34:40 +01:00
|
|
|
throw new ClientException(_('Problem saving notice. Too long.'));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (common_config('throttle', 'enabled') && !Notice::checkEditThrottle($profile_id)) {
|
|
|
|
common_log(LOG_WARNING, 'Excessive posting by profile #' . $profile_id . '; throttled.');
|
2010-07-29 10:34:58 +01:00
|
|
|
// TRANS: Client exception thrown when a user tries to post too many notices in a given time frame.
|
2009-10-04 01:34:40 +01:00
|
|
|
throw new ClientException(_('Too many notices too fast; take a breather '.
|
2009-09-29 22:16:07 +01:00
|
|
|
'and post again in a few minutes.'));
|
2009-10-04 01:34:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (common_config('site', 'dupelimit') > 0 && !Notice::checkDupes($profile_id, $final)) {
|
|
|
|
common_log(LOG_WARNING, 'Dupe posting by profile #' . $profile_id . '; throttled.');
|
2010-07-29 10:34:58 +01:00
|
|
|
// TRANS: Client exception thrown when a user tries to post too many duplicate notices in a given time frame.
|
2009-10-04 01:34:40 +01:00
|
|
|
throw new ClientException(_('Too many duplicate messages too quickly;'.
|
2009-09-29 22:16:07 +01:00
|
|
|
' take a breather and post again in a few minutes.'));
|
2009-10-04 01:34:40 +01:00
|
|
|
}
|
|
|
|
|
2009-11-16 18:03:59 +00:00
|
|
|
if (!$profile->hasRight(Right::NEWNOTICE)) {
|
|
|
|
common_log(LOG_WARNING, "Attempted post from user disallowed to post: " . $profile->nickname);
|
2010-07-29 21:44:11 +01:00
|
|
|
|
2010-07-29 10:34:58 +01:00
|
|
|
// TRANS: Client exception thrown when a user tries to post while being banned.
|
2010-07-29 19:47:28 +01:00
|
|
|
throw new ClientException(_('You are banned from posting notices on this site.'), 403);
|
2009-10-04 01:34:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
$notice = new Notice();
|
|
|
|
$notice->profile_id = $profile_id;
|
|
|
|
|
|
|
|
$autosource = common_config('public', 'autosource');
|
|
|
|
|
2011-03-22 15:54:23 +00:00
|
|
|
// Sandboxed are non-false, but not 1, either
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-11-17 16:48:16 +00:00
|
|
|
if (!$profile->hasRight(Right::PUBLICNOTICE) ||
|
2009-10-04 01:34:40 +01:00
|
|
|
($source && $autosource && in_array($source, $autosource))) {
|
|
|
|
$notice->is_local = Notice::LOCAL_NONPUBLIC;
|
|
|
|
} else {
|
|
|
|
$notice->is_local = $is_local;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!empty($created)) {
|
|
|
|
$notice->created = $created;
|
|
|
|
} else {
|
|
|
|
$notice->created = common_sql_now();
|
|
|
|
}
|
|
|
|
|
2014-04-18 22:36:01 +01:00
|
|
|
if (!$notice->isLocal()) {
|
|
|
|
// Only do these checks for non-local notices. Local notices will generate these values later.
|
|
|
|
if (!common_valid_http_url($url)) {
|
2014-04-18 22:53:16 +01:00
|
|
|
common_debug('Bad notice URL: ['.$url.'], URI: ['.$uri.']. Cannot link back to original! This is normal for shared notices etc.');
|
2014-04-18 22:36:01 +01:00
|
|
|
}
|
|
|
|
if (empty($uri)) {
|
|
|
|
throw new ServerException('No URI for remote notice. Cannot accept that.');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-04 01:34:40 +01:00
|
|
|
$notice->content = $final;
|
2010-02-21 14:17:00 +00:00
|
|
|
|
2009-10-04 01:34:40 +01:00
|
|
|
$notice->source = $source;
|
|
|
|
$notice->uri = $uri;
|
2010-02-21 14:17:00 +00:00
|
|
|
$notice->url = $url;
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2011-04-05 03:34:47 +01:00
|
|
|
// Get the groups here so we can figure out replies and such
|
|
|
|
if (!isset($groups)) {
|
2013-10-29 10:27:26 +00:00
|
|
|
$groups = User_group::idsFromText($notice->content, $profile);
|
2011-04-05 03:34:47 +01:00
|
|
|
}
|
|
|
|
|
2011-04-04 23:13:28 +01:00
|
|
|
$reply = null;
|
|
|
|
|
2009-12-11 16:51:09 +00:00
|
|
|
// Handle repeat case
|
|
|
|
|
|
|
|
if (isset($repeat_of)) {
|
2011-03-29 16:53:26 +01:00
|
|
|
|
|
|
|
// Check for a private one
|
|
|
|
|
2013-08-18 12:04:58 +01:00
|
|
|
$repeat = Notice::getKV('id', $repeat_of);
|
2011-03-29 16:53:26 +01:00
|
|
|
|
2013-10-06 20:30:29 +01:00
|
|
|
if (!($repeat instanceof Notice)) {
|
2011-03-31 21:48:03 +01:00
|
|
|
// TRANS: Client exception thrown in notice when trying to repeat a missing or deleted notice.
|
2011-03-30 00:20:12 +01:00
|
|
|
throw new ClientException(_('Cannot repeat; original notice is missing or deleted.'));
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($profile->id == $repeat->profile_id) {
|
|
|
|
// TRANS: Client error displayed when trying to repeat an own notice.
|
|
|
|
throw new ClientException(_('You cannot repeat your own notice.'));
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($repeat->scope != Notice::SITE_SCOPE &&
|
2011-03-29 16:53:26 +01:00
|
|
|
$repeat->scope != Notice::PUBLIC_SCOPE) {
|
2011-03-30 00:20:12 +01:00
|
|
|
// TRANS: Client error displayed when trying to repeat a non-public notice.
|
2011-03-29 16:53:26 +01:00
|
|
|
throw new ClientException(_('Cannot repeat a private notice.'), 403);
|
|
|
|
}
|
|
|
|
|
2011-03-30 00:20:12 +01:00
|
|
|
if (!$repeat->inScope($profile)) {
|
|
|
|
// The generic checks above should cover this, but let's be sure!
|
|
|
|
// TRANS: Client error displayed when trying to repeat a notice you cannot access.
|
|
|
|
throw new ClientException(_('Cannot repeat a notice you cannot read.'), 403);
|
|
|
|
}
|
|
|
|
|
2013-10-06 20:30:29 +01:00
|
|
|
if ($profile->hasRepeated($repeat)) {
|
2011-03-30 00:20:12 +01:00
|
|
|
// TRANS: Client error displayed when trying to repeat an already repeated notice.
|
|
|
|
throw new ClientException(_('You already repeated that notice.'));
|
|
|
|
}
|
2011-03-29 16:53:26 +01:00
|
|
|
|
2014-06-04 22:21:37 +01:00
|
|
|
$notice->repeat_of = $repeat->id;
|
|
|
|
$notice->conversation = $repeat->conversation;
|
2009-12-11 16:51:09 +00:00
|
|
|
} else {
|
2014-06-04 22:20:20 +01:00
|
|
|
$reply = null;
|
|
|
|
|
|
|
|
// 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);
|
|
|
|
}
|
2011-04-04 23:13:28 +01:00
|
|
|
|
2014-06-04 22:20:20 +01:00
|
|
|
if ($reply instanceof Notice) {
|
2011-04-04 23:13:28 +01:00
|
|
|
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).
|
|
|
|
throw new ClientException(sprintf(_('%1$s has no access to notice %2$d.'),
|
|
|
|
$profile->nickname, $reply->id), 403);
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2014-06-04 22:49:47 +01:00
|
|
|
// If it's a repeat, the reply_to should be to the original
|
|
|
|
if (!empty($reply->repeat_of)) {
|
|
|
|
$notice->reply_to = $reply->repeat_of;
|
|
|
|
} else {
|
|
|
|
$notice->reply_to = $reply->id;
|
|
|
|
}
|
|
|
|
// But the conversation ought to be the same :)
|
2011-04-04 23:13:28 +01:00
|
|
|
$notice->conversation = $reply->conversation;
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2014-06-04 22:20:20 +01:00
|
|
|
// If the original is private to a group, and notice has
|
|
|
|
// no group specified, make it to the same group(s)
|
2011-04-05 03:34:47 +01:00
|
|
|
|
2012-07-29 22:54:48 +01:00
|
|
|
if (empty($groups) && ($reply->scope & Notice::GROUP_SCOPE)) {
|
2011-04-05 03:34:47 +01:00
|
|
|
$groups = array();
|
|
|
|
$replyGroups = $reply->getGroups();
|
|
|
|
foreach ($replyGroups as $group) {
|
|
|
|
if ($profile->isMember($group)) {
|
|
|
|
$groups[] = $group->id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-04 23:13:28 +01:00
|
|
|
// Scope set below
|
2011-03-28 17:01:08 +01:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
}
|
|
|
|
|
2009-10-23 16:47:00 +01:00
|
|
|
if (!empty($lat) && !empty($lon)) {
|
|
|
|
$notice->lat = $lat;
|
|
|
|
$notice->lon = $lon;
|
2009-12-28 23:13:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!empty($location_ns) && !empty($location_id)) {
|
2009-10-23 16:47:00 +01:00
|
|
|
$notice->location_id = $location_id;
|
|
|
|
$notice->location_ns = $location_ns;
|
|
|
|
}
|
|
|
|
|
Use notice for context when deciding who @nickname refers to
In a federated system, "@nickname" is insufficient to uniquely
identify a user. However, it's a very convenient idiom. We need to
guess from context who 'nickname' refers to.
Previously, we were using the sender's profile (or what we knew about
them) as the only context. So, we assumed that they'd be mentioning to
someone they followed, or someone who followed them, or someone on
their own server.
Now, we include the notice information for context. We check to see if
the notice is a reply to another notice, and if the author of the
original notice has the nickname 'nickname', then the mention is
probably for them. Alternately, if the original notice mentions someone
with nickname 'nickname', then this notice is probably referring to
_them_.
Doing this kind of context sleuthing means we have to render the
content very late in the notice-saving process.
2010-02-27 21:06:46 +00:00
|
|
|
if (!empty($rendered)) {
|
|
|
|
$notice->rendered = $rendered;
|
|
|
|
} else {
|
|
|
|
$notice->rendered = common_render_content($final, $notice);
|
|
|
|
}
|
|
|
|
|
2011-08-22 21:02:14 +01:00
|
|
|
if (empty($verb)) {
|
|
|
|
if (!empty($notice->repeat_of)) {
|
|
|
|
$notice->verb = ActivityVerb::SHARE;
|
2011-09-19 21:11:43 +01:00
|
|
|
$notice->object_type = ActivityObject::ACTIVITY;
|
2011-08-22 21:02:14 +01:00
|
|
|
} else {
|
|
|
|
$notice->verb = ActivityVerb::POST;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
$notice->verb = $verb;
|
|
|
|
}
|
|
|
|
|
2011-03-07 19:20:55 +00:00
|
|
|
if (empty($object_type)) {
|
2011-03-07 19:27:23 +00:00
|
|
|
$notice->object_type = (empty($notice->reply_to)) ? ActivityObject::NOTE : ActivityObject::COMMENT;
|
2011-03-07 19:20:55 +00:00
|
|
|
} else {
|
|
|
|
$notice->object_type = $object_type;
|
|
|
|
}
|
|
|
|
|
2011-03-26 19:49:46 +00:00
|
|
|
if (is_null($scope)) { // 0 is a valid value
|
2011-04-04 23:13:28 +01:00
|
|
|
if (!empty($reply)) {
|
|
|
|
$notice->scope = $reply->scope;
|
|
|
|
} else {
|
2011-07-02 02:50:04 +01:00
|
|
|
$notice->scope = self::defaultScope();
|
2011-04-04 23:13:28 +01:00
|
|
|
}
|
2011-03-26 19:49:46 +00:00
|
|
|
} else {
|
|
|
|
$notice->scope = $scope;
|
|
|
|
}
|
|
|
|
|
2011-03-31 17:56:53 +01:00
|
|
|
// For private streams
|
|
|
|
|
2013-09-09 20:35:16 +01:00
|
|
|
try {
|
|
|
|
$user = $profile->getUser();
|
2011-03-31 17:56:53 +01:00
|
|
|
|
|
|
|
if ($user->private_stream &&
|
|
|
|
($notice->scope == Notice::PUBLIC_SCOPE ||
|
|
|
|
$notice->scope == Notice::SITE_SCOPE)) {
|
|
|
|
$notice->scope |= Notice::FOLLOWER_SCOPE;
|
|
|
|
}
|
2013-09-09 20:35:16 +01:00
|
|
|
} catch (NoSuchUserException $e) {
|
|
|
|
// Cannot handle private streams for remote profiles
|
2011-03-31 17:56:53 +01:00
|
|
|
}
|
|
|
|
|
2011-04-04 22:33:42 +01:00
|
|
|
// Force the scope for private groups
|
|
|
|
|
|
|
|
foreach ($groups as $groupId) {
|
2013-08-18 12:04:58 +01:00
|
|
|
$group = User_group::getKV('id', $groupId);
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($group instanceof User_group) {
|
2011-04-04 22:33:42 +01:00
|
|
|
if ($group->force_scope) {
|
|
|
|
$notice->scope |= Notice::GROUP_SCOPE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-04 01:34:40 +01:00
|
|
|
if (Event::handle('StartNoticeSave', array(&$notice))) {
|
|
|
|
|
2009-07-29 16:45:32 +01:00
|
|
|
// XXX: some of these functions write to the DB
|
2009-10-04 01:34:40 +01:00
|
|
|
|
|
|
|
$id = $notice->insert();
|
|
|
|
|
|
|
|
if (!$id) {
|
|
|
|
common_log_db_error($notice, 'INSERT', __FILE__);
|
2010-07-29 10:34:58 +01:00
|
|
|
// TRANS: Server exception thrown when a notice cannot be saved.
|
2009-10-04 01:34:40 +01:00
|
|
|
throw new ServerException(_('Problem saving notice.'));
|
|
|
|
}
|
|
|
|
|
2009-07-29 16:45:32 +01:00
|
|
|
// Update ID-dependent columns: URI, conversation
|
2009-10-04 01:34:40 +01:00
|
|
|
|
|
|
|
$orig = clone($notice);
|
|
|
|
|
|
|
|
$changed = false;
|
|
|
|
|
2014-04-18 22:53:16 +01:00
|
|
|
// 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($notice->uri)) {
|
2014-04-18 22:17:34 +01:00
|
|
|
$notice->uri = sprintf('%s%s=%d:%s=%s',
|
2014-04-18 21:42:01 +01:00
|
|
|
TagURI::mint(),
|
|
|
|
'noticeId', $notice->id,
|
|
|
|
'objectType', $notice->get_object_type(true));
|
2009-10-04 01:34:40 +01:00
|
|
|
$changed = true;
|
|
|
|
}
|
|
|
|
|
2009-07-29 16:45:32 +01:00
|
|
|
// If it's not part of a conversation, it's
|
|
|
|
// the beginning of a new conversation.
|
2009-10-04 01:34:40 +01:00
|
|
|
|
|
|
|
if (empty($notice->conversation)) {
|
2014-03-01 16:06:29 +00:00
|
|
|
$conv = Conversation::create($notice);
|
2010-02-17 09:12:13 +00:00
|
|
|
$notice->conversation = $conv->id;
|
2009-10-04 01:34:40 +01:00
|
|
|
$changed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($changed) {
|
2014-03-01 16:06:29 +00:00
|
|
|
if ($notice->update($orig) === false) {
|
2009-10-04 01:34:40 +01:00
|
|
|
common_log_db_error($notice, 'UPDATE', __FILE__);
|
2010-07-29 10:34:58 +01:00
|
|
|
// TRANS: Server exception thrown when a notice cannot be updated.
|
2009-10-04 01:34:40 +01:00
|
|
|
throw new ServerException(_('Problem saving notice.'));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-25 23:08:21 +00:00
|
|
|
}
|
|
|
|
|
2011-03-22 15:54:23 +00:00
|
|
|
// Clear the cache for subscribed users, so they'll update at next request
|
|
|
|
// XXX: someone clever could prepend instead of clearing the cache
|
2010-02-22 04:56:48 +00:00
|
|
|
|
2010-01-25 23:08:21 +00:00
|
|
|
$notice->blowOnInsert();
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-02-25 19:26:33 +00:00
|
|
|
// Save per-notice metadata...
|
|
|
|
|
2010-02-22 04:56:48 +00:00
|
|
|
if (isset($replies)) {
|
|
|
|
$notice->saveKnownReplies($replies);
|
|
|
|
} else {
|
|
|
|
$notice->saveReplies();
|
|
|
|
}
|
|
|
|
|
2010-02-25 19:26:33 +00:00
|
|
|
if (isset($tags)) {
|
|
|
|
$notice->saveKnownTags($tags);
|
|
|
|
} else {
|
|
|
|
$notice->saveTags();
|
|
|
|
}
|
|
|
|
|
2010-04-14 10:11:02 +01:00
|
|
|
// Note: groups may save tags, so must be run after tags are saved
|
|
|
|
// to avoid errors on duplicates.
|
2011-04-04 22:33:42 +01:00
|
|
|
// Note: groups should always be set.
|
|
|
|
|
|
|
|
$notice->saveKnownGroups($groups);
|
2010-04-14 10:11:02 +01:00
|
|
|
|
2010-03-03 00:30:09 +00:00
|
|
|
if (isset($urls)) {
|
|
|
|
$notice->saveKnownUrls($urls);
|
|
|
|
} else {
|
|
|
|
$notice->saveUrls();
|
|
|
|
}
|
2010-02-25 19:26:33 +00:00
|
|
|
|
2010-12-16 21:17:38 +00:00
|
|
|
if ($distribute) {
|
|
|
|
// Prepare inbox delivery, may be queued to background.
|
|
|
|
$notice->distribute();
|
|
|
|
}
|
2010-01-13 20:37:01 +00:00
|
|
|
|
2010-01-25 23:08:21 +00:00
|
|
|
return $notice;
|
|
|
|
}
|
2010-01-13 20:37:01 +00:00
|
|
|
|
2010-02-17 09:12:13 +00:00
|
|
|
function blowOnInsert($conversation = false)
|
2010-01-25 23:08:21 +00:00
|
|
|
{
|
2011-03-31 21:15:05 +01:00
|
|
|
$this->blowStream('profile:notice_ids:%d', $this->profile_id);
|
2011-02-03 18:58:56 +00:00
|
|
|
|
|
|
|
if ($this->isPublic()) {
|
2011-03-31 21:15:05 +01:00
|
|
|
$this->blowStream('public');
|
2011-02-03 18:58:56 +00:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2011-08-22 17:25:04 +01:00
|
|
|
self::blow('notice:list-ids:conversation:%s', $this->conversation);
|
2012-03-21 20:40:42 +00:00
|
|
|
self::blow('conversation:notice_count:%d', $this->conversation);
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-01-25 23:08:21 +00:00
|
|
|
if (!empty($this->repeat_of)) {
|
2011-08-22 17:39:37 +01:00
|
|
|
// XXX: we should probably only use one of these
|
2011-03-31 21:15:05 +01:00
|
|
|
$this->blowStream('notice:repeats:%d', $this->repeat_of);
|
2011-08-22 17:39:37 +01:00
|
|
|
self::blow('notice:list-ids:repeat_of:%d', $this->repeat_of);
|
2009-10-04 01:34:40 +01:00
|
|
|
}
|
|
|
|
|
2013-08-18 12:04:58 +01:00
|
|
|
$original = Notice::getKV('id', $this->repeat_of);
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($original instanceof Notice) {
|
2013-08-18 12:04:58 +01:00
|
|
|
$originalUser = User::getKV('id', $original->profile_id);
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($originalUser instanceof User) {
|
2011-03-31 21:15:05 +01:00
|
|
|
$this->blowStream('user:repeats_of_me:%d', $originalUser->id);
|
2010-01-25 23:08:21 +00:00
|
|
|
}
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2013-08-18 12:04:58 +01:00
|
|
|
$profile = Profile::getKV($this->profile_id);
|
2011-03-31 21:15:05 +01:00
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($profile instanceof Profile) {
|
2010-03-24 00:24:01 +00:00
|
|
|
$profile->blowNoticeCount();
|
|
|
|
}
|
2011-04-12 20:56:56 +01:00
|
|
|
|
|
|
|
$ptags = $this->getProfileTags();
|
|
|
|
foreach ($ptags as $ptag) {
|
|
|
|
$ptag->blowNoticeStreamCache();
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
}
|
|
|
|
|
2010-03-15 21:19:22 +00:00
|
|
|
/**
|
|
|
|
* Clear cache entries related to this notice at delete time.
|
|
|
|
* Necessary to avoid breaking paging on public, profile timelines.
|
|
|
|
*/
|
|
|
|
function blowOnDelete()
|
|
|
|
{
|
|
|
|
$this->blowOnInsert();
|
|
|
|
|
|
|
|
self::blow('profile:notice_ids:%d;last', $this->profile_id);
|
2011-02-03 18:58:56 +00:00
|
|
|
|
|
|
|
if ($this->isPublic()) {
|
|
|
|
self::blow('public;last');
|
|
|
|
}
|
2011-03-18 00:06:04 +00:00
|
|
|
|
|
|
|
self::blow('fave:by_notice', $this->id);
|
2011-03-18 00:36:53 +00:00
|
|
|
|
|
|
|
if ($this->conversation) {
|
|
|
|
// In case we're the first, will need to calc a new root.
|
|
|
|
self::blow('notice:conversation_root:%d', $this->conversation);
|
|
|
|
}
|
2011-04-12 20:56:56 +01:00
|
|
|
|
|
|
|
$ptags = $this->getProfileTags();
|
|
|
|
foreach ($ptags as $ptag) {
|
|
|
|
$ptag->blowNoticeStreamCache(true);
|
|
|
|
}
|
2010-03-15 21:19:22 +00:00
|
|
|
}
|
|
|
|
|
2011-03-31 21:15:05 +01:00
|
|
|
function blowStream()
|
|
|
|
{
|
|
|
|
$c = self::memcache();
|
|
|
|
|
|
|
|
if (empty($c)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
$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
|
|
|
|
// older than the top of that stream
|
|
|
|
|
|
|
|
$lastKey = $cacheKey.';last';
|
|
|
|
|
|
|
|
$lastStr = $c->get($lastKey);
|
|
|
|
|
|
|
|
if ($lastStr !== false) {
|
|
|
|
$window = explode(',', $lastStr);
|
|
|
|
$lastID = $window[0];
|
2013-08-18 12:04:58 +01:00
|
|
|
$lastNotice = Notice::getKV('id', $lastID);
|
2013-10-28 21:18:00 +00:00
|
|
|
if (!$lastNotice instanceof Notice // just weird
|
2011-03-31 21:15:05 +01:00
|
|
|
|| strtotime($lastNotice->created) >= strtotime($this->created)) {
|
|
|
|
$c->delete($lastKey);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-17 04:10:17 +01:00
|
|
|
/** save all urls in the notice to the db
|
2009-10-04 01:34:40 +01:00
|
|
|
*
|
|
|
|
* follow redirects and save all available file information
|
|
|
|
* (mimetype, date, size, oembed, etc.)
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
function saveUrls() {
|
2010-11-17 21:03:59 +00:00
|
|
|
if (common_config('attachments', 'process_links')) {
|
|
|
|
common_replace_urls_callback($this->content, array($this, 'saveUrl'), $this->id);
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
}
|
|
|
|
|
2010-03-03 00:30:09 +00:00
|
|
|
/**
|
|
|
|
* Save the given URLs as related links/attachments to the db
|
|
|
|
*
|
|
|
|
* follow redirects and save all available file information
|
|
|
|
* (mimetype, date, size, oembed, etc.)
|
|
|
|
*
|
|
|
|
* @return void
|
|
|
|
*/
|
|
|
|
function saveKnownUrls($urls)
|
|
|
|
{
|
2010-11-17 21:03:59 +00:00
|
|
|
if (common_config('attachments', 'process_links')) {
|
|
|
|
// @fixme validation?
|
|
|
|
foreach (array_unique($urls) as $url) {
|
2014-06-02 01:08:48 +01:00
|
|
|
try {
|
|
|
|
File::processNew($url, $this->id);
|
|
|
|
} catch (ServerException $e) {
|
|
|
|
// Could not save URL. Log it?
|
|
|
|
}
|
2010-11-17 21:03:59 +00:00
|
|
|
}
|
2010-03-03 00:30:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @private callback
|
|
|
|
*/
|
2010-12-02 18:56:44 +00:00
|
|
|
function saveUrl($url, $notice_id) {
|
2014-06-02 01:08:48 +01:00
|
|
|
try {
|
|
|
|
File::processNew($url, $notice_id);
|
|
|
|
} catch (ServerException $e) {
|
|
|
|
// Could not save URL. Log it?
|
|
|
|
}
|
2009-06-17 04:10:17 +01:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-03-07 17:43:50 +00:00
|
|
|
static function checkDupes($profile_id, $content) {
|
2013-08-18 12:04:58 +01:00
|
|
|
$profile = Profile::getKV($profile_id);
|
2013-10-28 21:18:00 +00:00
|
|
|
if (!$profile instanceof Profile) {
|
2009-03-07 17:43:50 +00:00
|
|
|
return false;
|
|
|
|
}
|
2011-03-24 22:04:19 +00:00
|
|
|
$notice = $profile->getNotices(0, CachingNoticeStream::CACHE_WINDOW);
|
2009-10-28 18:21:42 +00:00
|
|
|
if (!empty($notice)) {
|
2009-03-07 17:43:50 +00:00
|
|
|
$last = 0;
|
|
|
|
while ($notice->fetch()) {
|
|
|
|
if (time() - strtotime($notice->created) >= common_config('site', 'dupelimit')) {
|
|
|
|
return true;
|
|
|
|
} else if ($notice->content == $content) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-03-22 15:54:23 +00:00
|
|
|
// If we get here, oldest item in cache window is not
|
|
|
|
// old enough for dupe limit; do direct check against DB
|
2009-03-07 17:43:50 +00:00
|
|
|
$notice = new Notice();
|
|
|
|
$notice->profile_id = $profile_id;
|
|
|
|
$notice->content = $content;
|
2010-11-04 00:25:29 +00:00
|
|
|
$threshold = common_sql_date(time() - common_config('site', 'dupelimit'));
|
|
|
|
$notice->whereAdd(sprintf("created > '%s'", $notice->escape($threshold)));
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-03-07 17:43:50 +00:00
|
|
|
$cnt = $notice->count();
|
2009-03-07 22:04:30 +00:00
|
|
|
return ($cnt == 0);
|
2009-03-07 17:43:50 +00:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2008-12-10 17:47:22 +00:00
|
|
|
static function checkEditThrottle($profile_id) {
|
2013-08-18 12:04:58 +01:00
|
|
|
$profile = Profile::getKV($profile_id);
|
2013-10-28 21:18:00 +00:00
|
|
|
if (!$profile instanceof Profile) {
|
2008-12-10 17:47:22 +00:00
|
|
|
return false;
|
|
|
|
}
|
2011-03-22 15:54:23 +00:00
|
|
|
// Get the Nth notice
|
2008-12-10 17:47:22 +00:00
|
|
|
$notice = $profile->getNotices(common_config('throttle', 'count') - 1, 1);
|
|
|
|
if ($notice && $notice->fetch()) {
|
2011-03-22 15:54:23 +00:00
|
|
|
// If the Nth notice was posted less than timespan seconds ago
|
2008-12-10 17:47:22 +00:00
|
|
|
if (time() - strtotime($notice->created) <= common_config('throttle', 'timespan')) {
|
2011-03-22 15:54:23 +00:00
|
|
|
// Then we throttle
|
2008-12-10 17:47:22 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2011-03-22 15:54:23 +00:00
|
|
|
// Either not N notices in the stream, OR the Nth was not posted within timespan seconds
|
2008-12-10 17:47:22 +00:00
|
|
|
return true;
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2014-06-04 23:29:43 +01:00
|
|
|
protected $_attachments = array();
|
2011-08-03 04:12:21 +01:00
|
|
|
|
2009-06-25 19:08:32 +01:00
|
|
|
function attachments() {
|
2014-06-04 23:29:43 +01:00
|
|
|
if (isset($this->_attachments[$this->id])) {
|
|
|
|
return $this->_attachments[$this->id];
|
2009-06-25 19:08:32 +01:00
|
|
|
}
|
2011-08-03 04:12:21 +01:00
|
|
|
|
2013-08-18 20:02:33 +01:00
|
|
|
$f2ps = File_to_post::listGet('post_id', array($this->id));
|
2011-08-03 04:12:21 +01:00
|
|
|
|
|
|
|
$ids = array();
|
|
|
|
|
|
|
|
foreach ($f2ps[$this->id] as $f2p) {
|
|
|
|
$ids[] = $f2p->file_id;
|
2011-04-07 04:33:35 +01:00
|
|
|
}
|
2011-08-03 04:12:21 +01:00
|
|
|
|
2013-08-29 09:38:11 +01:00
|
|
|
$files = File::multiGet('id', $ids);
|
2011-04-07 04:33:35 +01:00
|
|
|
|
2014-06-04 23:29:43 +01:00
|
|
|
$this->_attachments[$this->id] = $files->fetchAll();
|
2011-08-03 04:12:21 +01:00
|
|
|
|
2014-06-04 23:29:43 +01:00
|
|
|
return $this->_attachments[$this->id];
|
2009-06-25 19:08:32 +01:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2011-08-03 04:12:21 +01:00
|
|
|
function _setAttachments($attachments)
|
|
|
|
{
|
2014-06-04 23:29:43 +01:00
|
|
|
$this->_attachments[$this->id] = $attachments;
|
2011-08-03 04:12:21 +01:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-03-02 19:54:02 +00:00
|
|
|
function publicStream($offset=0, $limit=20, $since_id=0, $max_id=0)
|
2008-12-23 19:33:23 +00:00
|
|
|
{
|
2011-03-24 22:04:19 +00:00
|
|
|
$stream = new PublicNoticeStream();
|
2011-03-23 15:29:55 +00:00
|
|
|
return $stream->getNotices($offset, $limit, $since_id, $max_id);
|
2009-04-29 17:05:31 +01:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
|
|
|
|
2010-03-02 19:54:02 +00:00
|
|
|
function conversationStream($id, $offset=0, $limit=20, $since_id=0, $max_id=0)
|
2009-06-25 17:43:30 +01:00
|
|
|
{
|
2011-03-24 22:04:19 +00:00
|
|
|
$stream = new ConversationNoticeStream($id);
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2011-03-23 15:29:55 +00:00
|
|
|
return $stream->getNotices($offset, $limit, $since_id, $max_id);
|
2008-12-23 19:19:07 +00:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-04-09 19:36:51 +01:00
|
|
|
/**
|
|
|
|
* Is this notice part of an active conversation?
|
2010-05-06 08:20:10 +01:00
|
|
|
*
|
2010-04-09 19:36:51 +01:00
|
|
|
* @return boolean true if other messages exist in the same
|
|
|
|
* conversation, false if this is the only one
|
|
|
|
*/
|
|
|
|
function hasConversation()
|
|
|
|
{
|
|
|
|
if (!empty($this->conversation)) {
|
|
|
|
$conversation = Notice::conversationStream(
|
|
|
|
$this->conversation,
|
|
|
|
1,
|
|
|
|
1
|
|
|
|
);
|
2010-09-28 22:21:09 +01:00
|
|
|
|
2010-04-09 19:36:51 +01:00
|
|
|
if ($conversation->N > 0) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-03-18 00:36:53 +00:00
|
|
|
/**
|
|
|
|
* Grab the earliest notice from this conversation.
|
|
|
|
*
|
|
|
|
* @return Notice or null
|
|
|
|
*/
|
2011-04-11 16:19:11 +01:00
|
|
|
function conversationRoot($profile=-1)
|
2011-03-18 00:36:53 +00:00
|
|
|
{
|
2011-04-11 16:19:11 +01:00
|
|
|
// XXX: can this happen?
|
2011-03-18 00:36:53 +00:00
|
|
|
|
2011-04-11 16:19:11 +01:00
|
|
|
if (empty($this->conversation)) {
|
|
|
|
return null;
|
|
|
|
}
|
2011-03-18 00:36:53 +00:00
|
|
|
|
2011-04-11 16:19:11 +01:00
|
|
|
// Get the current profile if not specified
|
2011-03-18 00:36:53 +00:00
|
|
|
|
2011-04-11 16:19:11 +01:00
|
|
|
if (is_int($profile) && $profile == -1) {
|
|
|
|
$profile = Profile::current();
|
2011-03-18 00:36:53 +00:00
|
|
|
}
|
2011-04-11 16:19:11 +01:00
|
|
|
|
|
|
|
// If this notice is out of scope, no root for you!
|
|
|
|
|
|
|
|
if (!$this->inScope($profile)) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this isn't a reply to anything, then it's its own
|
|
|
|
// root.
|
|
|
|
|
|
|
|
if (empty($this->reply_to)) {
|
|
|
|
return $this;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_null($profile)) {
|
|
|
|
$keypart = sprintf('notice:conversation_root:%d:null', $this->id);
|
|
|
|
} else {
|
|
|
|
$keypart = sprintf('notice:conversation_root:%d:%d',
|
|
|
|
$this->id,
|
|
|
|
$profile->id);
|
|
|
|
}
|
|
|
|
|
|
|
|
$root = self::cacheGet($keypart);
|
|
|
|
|
|
|
|
if ($root !== false && $root->inScope($profile)) {
|
|
|
|
return $root;
|
2013-10-05 11:30:14 +01:00
|
|
|
}
|
2011-04-11 16:19:11 +01:00
|
|
|
|
2013-10-05 11:30:14 +01:00
|
|
|
$last = $this;
|
|
|
|
while (true) {
|
|
|
|
try {
|
2013-10-02 14:01:11 +01:00
|
|
|
$parent = $last->getParent();
|
2013-10-05 11:30:14 +01:00
|
|
|
if ($parent->inScope($profile)) {
|
2011-04-11 16:19:11 +01:00
|
|
|
$last = $parent;
|
|
|
|
continue;
|
|
|
|
}
|
2013-10-05 11:30:14 +01:00
|
|
|
} catch (Exception $e) {
|
|
|
|
// Latest notice has no parent
|
|
|
|
}
|
|
|
|
// No parent, or parent out of scope
|
|
|
|
$root = $last;
|
|
|
|
break;
|
2011-04-11 16:19:11 +01:00
|
|
|
}
|
|
|
|
|
2013-10-05 11:30:14 +01:00
|
|
|
self::cacheSet($keypart, $root);
|
|
|
|
|
2011-04-11 16:19:11 +01:00
|
|
|
return $root;
|
2011-03-18 00:36:53 +00:00
|
|
|
}
|
2011-04-11 16:19:11 +01:00
|
|
|
|
2010-01-15 21:06:21 +00:00
|
|
|
/**
|
2010-09-20 23:57:46 +01:00
|
|
|
* Pull up a full list of local recipients who will be getting
|
|
|
|
* this notice in their inbox. Results will be cached, so don't
|
|
|
|
* change the input data wily-nilly!
|
|
|
|
*
|
|
|
|
* @param array $groups optional list of Group objects;
|
|
|
|
* if left empty, will be loaded from group_inbox records
|
|
|
|
* @param array $recipient optional list of reply profile ids
|
|
|
|
* if left empty, will be loaded from reply records
|
|
|
|
* @return array associating recipient user IDs with an inbox source constant
|
2010-01-15 21:06:21 +00:00
|
|
|
*/
|
2013-08-29 09:27:39 +01:00
|
|
|
function whoGets(array $groups=null, array $recipients=null)
|
2008-12-23 19:33:23 +00:00
|
|
|
{
|
2010-01-13 08:16:54 +00:00
|
|
|
$c = self::memcache();
|
|
|
|
|
|
|
|
if (!empty($c)) {
|
2010-09-06 15:07:43 +01:00
|
|
|
$ni = $c->get(Cache::key('notice:who_gets:'.$this->id));
|
2010-01-13 08:16:54 +00:00
|
|
|
if ($ni !== false) {
|
|
|
|
return $ni;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-13 20:37:01 +00:00
|
|
|
if (is_null($recipients)) {
|
|
|
|
$recipients = $this->getReplies();
|
|
|
|
}
|
|
|
|
|
2009-10-13 22:38:27 +01:00
|
|
|
$ni = array();
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2011-03-15 19:49:17 +00:00
|
|
|
// Give plugins a chance to add folks in at start...
|
|
|
|
if (Event::handle('StartNoticeWhoGets', array($this, &$ni))) {
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2014-03-07 01:49:42 +00:00
|
|
|
$users = $this->getSubscribedUsers();
|
2009-06-26 07:00:46 +01:00
|
|
|
foreach ($users as $id) {
|
2011-03-15 19:49:17 +00:00
|
|
|
$ni[$id] = NOTICE_INBOX_SOURCE_SUB;
|
|
|
|
}
|
|
|
|
|
2014-03-07 01:49:42 +00:00
|
|
|
if (is_null($groups)) {
|
|
|
|
$groups = $this->getGroups();
|
|
|
|
}
|
2011-03-15 19:49:17 +00:00
|
|
|
foreach ($groups as $group) {
|
|
|
|
$users = $group->getUserMembers();
|
|
|
|
foreach ($users as $id) {
|
|
|
|
if (!array_key_exists($id, $ni)) {
|
|
|
|
$ni[$id] = NOTICE_INBOX_SOURCE_GROUP;
|
|
|
|
}
|
2009-06-26 08:47:27 +01:00
|
|
|
}
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2014-03-07 01:49:42 +00:00
|
|
|
$ptAtts = $this->getAttentionsFromProfileTags();
|
|
|
|
foreach ($ptAtts as $key=>$val) {
|
|
|
|
if (!array_key_exists($key, $ni)) {
|
|
|
|
$ni[$key] = $val;
|
2011-03-06 17:58:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-22 03:00:16 +00:00
|
|
|
foreach ($recipients as $recipient) {
|
|
|
|
if (!array_key_exists($recipient, $ni)) {
|
|
|
|
$ni[$recipient] = NOTICE_INBOX_SOURCE_REPLY;
|
|
|
|
}
|
2012-03-23 16:55:39 +00:00
|
|
|
}
|
2010-09-20 23:57:46 +01:00
|
|
|
|
2012-03-23 16:55:39 +00:00
|
|
|
// Exclude any deleted, non-local, or blocking recipients.
|
|
|
|
$profile = $this->getProfile();
|
|
|
|
$originalProfile = null;
|
|
|
|
if ($this->repeat_of) {
|
|
|
|
// Check blocks against the original notice's poster as well.
|
2013-08-18 12:04:58 +01:00
|
|
|
$original = Notice::getKV('id', $this->repeat_of);
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($original instanceof Notice) {
|
2012-03-23 16:55:39 +00:00
|
|
|
$originalProfile = $original->getProfile();
|
2011-03-15 19:49:17 +00:00
|
|
|
}
|
2012-03-23 16:55:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
foreach ($ni as $id => $source) {
|
2012-11-25 15:39:49 +00:00
|
|
|
try {
|
2013-08-18 12:04:58 +01:00
|
|
|
$user = User::getKV('id', $id);
|
2013-10-28 21:18:00 +00:00
|
|
|
if (!$user instanceof User ||
|
2012-11-25 15:39:49 +00:00
|
|
|
$user->hasBlocked($profile) ||
|
|
|
|
($originalProfile && $user->hasBlocked($originalProfile))) {
|
|
|
|
unset($ni[$id]);
|
|
|
|
}
|
|
|
|
} catch (UserNoProfileException $e) {
|
|
|
|
// User doesn't have a profile; invalid; skip them.
|
2012-03-23 16:55:39 +00:00
|
|
|
unset($ni[$id]);
|
2011-03-15 19:49:17 +00:00
|
|
|
}
|
2009-10-28 19:33:10 +00:00
|
|
|
}
|
2011-03-15 19:49:17 +00:00
|
|
|
|
|
|
|
// Give plugins a chance to filter out...
|
|
|
|
Event::handle('EndNoticeWhoGets', array($this, &$ni));
|
2009-10-28 19:33:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-13 08:16:54 +00:00
|
|
|
if (!empty($c)) {
|
|
|
|
// XXX: pack this data better
|
2010-09-06 15:07:43 +01:00
|
|
|
$c->set(Cache::key('notice:who_gets:'.$this->id), $ni);
|
2010-01-13 08:16:54 +00:00
|
|
|
}
|
|
|
|
|
2010-01-09 21:55:54 +00:00
|
|
|
return $ni;
|
|
|
|
}
|
|
|
|
|
2009-06-26 07:00:46 +01:00
|
|
|
function getSubscribedUsers()
|
|
|
|
{
|
|
|
|
$user = new User();
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-07-29 16:45:32 +01:00
|
|
|
if(common_config('db','quote_identifiers'))
|
2009-10-04 01:34:40 +01:00
|
|
|
$user_table = '"user"';
|
2009-07-29 16:45:32 +01:00
|
|
|
else $user_table = 'user';
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-06-26 07:00:46 +01:00
|
|
|
$qry =
|
2009-10-04 01:34:40 +01:00
|
|
|
'SELECT id ' .
|
|
|
|
'FROM '. $user_table .' JOIN subscription '.
|
|
|
|
'ON '. $user_table .'.id = subscription.subscriber ' .
|
|
|
|
'WHERE subscription.subscribed = %d ';
|
|
|
|
|
2009-06-26 07:00:46 +01:00
|
|
|
$user->query(sprintf($qry, $this->profile_id));
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-06-26 07:00:46 +01:00
|
|
|
$ids = array();
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-06-26 07:00:46 +01:00
|
|
|
while ($user->fetch()) {
|
|
|
|
$ids[] = $user->id;
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-06-26 07:00:46 +01:00
|
|
|
$user->free();
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-06-26 07:00:46 +01:00
|
|
|
return $ids;
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2011-03-06 17:58:03 +00:00
|
|
|
function getProfileTags()
|
|
|
|
{
|
2011-04-12 20:56:56 +01:00
|
|
|
$profile = $this->getProfile();
|
|
|
|
$list = $profile->getOtherTags($profile);
|
|
|
|
$ptags = array();
|
2011-03-06 17:58:03 +00:00
|
|
|
|
2011-04-12 20:56:56 +01:00
|
|
|
while($list->fetch()) {
|
|
|
|
$ptags[] = clone($list);
|
2011-03-06 17:58:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return $ptags;
|
|
|
|
}
|
|
|
|
|
2014-03-07 01:49:42 +00:00
|
|
|
public function getAttentionsFromProfileTags()
|
|
|
|
{
|
|
|
|
$ni = array();
|
|
|
|
$ptags = $this->getProfileTags();
|
|
|
|
foreach ($ptags as $ptag) {
|
|
|
|
$users = $ptag->getUserSubscribers();
|
|
|
|
foreach ($users as $id) {
|
|
|
|
$ni[$id] = NOTICE_INBOX_SOURCE_PROFILE_TAG;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $ni;
|
|
|
|
}
|
|
|
|
|
2010-01-15 21:06:21 +00:00
|
|
|
/**
|
2010-02-23 00:44:45 +00:00
|
|
|
* Record this notice to the given group inboxes for delivery.
|
|
|
|
* Overrides the regular parsing of !group markup.
|
|
|
|
*
|
|
|
|
* @param string $group_ids
|
|
|
|
* @fixme might prefer URIs as identifiers, as for replies?
|
|
|
|
* best with generalizations on user_group to support
|
|
|
|
* remote groups better.
|
|
|
|
*/
|
|
|
|
function saveKnownGroups($group_ids)
|
|
|
|
{
|
|
|
|
if (!is_array($group_ids)) {
|
2010-07-29 10:34:58 +01:00
|
|
|
// TRANS: Server exception thrown when no array is provided to the method saveKnownGroups().
|
2010-11-04 17:33:39 +00:00
|
|
|
throw new ServerException(_('Bad type provided to saveKnownGroups.'));
|
2010-02-23 00:44:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
$groups = array();
|
2010-08-10 21:36:38 +01:00
|
|
|
foreach (array_unique($group_ids) as $id) {
|
2013-08-18 12:04:58 +01:00
|
|
|
$group = User_group::getKV('id', $id);
|
2013-10-29 10:27:26 +00:00
|
|
|
if ($group instanceof User_group) {
|
2010-02-23 00:44:45 +00:00
|
|
|
common_log(LOG_ERR, "Local delivery to group id $id, $group->nickname");
|
|
|
|
$result = $this->addToGroupInbox($group);
|
|
|
|
if (!$result) {
|
|
|
|
common_log_db_error($gi, 'INSERT', __FILE__);
|
|
|
|
}
|
|
|
|
|
2011-04-20 21:19:07 +01:00
|
|
|
if (common_config('group', 'addtag')) {
|
|
|
|
// we automatically add a tag for every group name, too
|
2011-04-04 22:33:42 +01:00
|
|
|
|
2011-04-20 21:19:07 +01:00
|
|
|
$tag = Notice_tag::pkeyGet(array('tag' => common_canonical_tag($group->nickname),
|
|
|
|
'notice_id' => $this->id));
|
2011-04-04 22:33:42 +01:00
|
|
|
|
2011-04-20 21:19:07 +01:00
|
|
|
if (is_null($tag)) {
|
|
|
|
$this->saveTag($group->nickname);
|
|
|
|
}
|
2011-04-04 22:33:42 +01:00
|
|
|
}
|
|
|
|
|
2010-02-23 00:44:45 +00:00
|
|
|
$groups[] = clone($group);
|
|
|
|
} else {
|
|
|
|
common_log(LOG_ERR, "Local delivery to group id $id skipped, doesn't exist");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $groups;
|
|
|
|
}
|
|
|
|
|
2013-10-29 10:27:26 +00:00
|
|
|
function addToGroupInbox(User_group $group)
|
2009-06-26 07:00:46 +01:00
|
|
|
{
|
|
|
|
$gi = Group_inbox::pkeyGet(array('group_id' => $group->id,
|
|
|
|
'notice_id' => $this->id));
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if (!$gi instanceof Group_inbox) {
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-06-26 07:00:46 +01:00
|
|
|
$gi = new Group_inbox();
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-06-26 07:00:46 +01:00
|
|
|
$gi->group_id = $group->id;
|
|
|
|
$gi->notice_id = $this->id;
|
|
|
|
$gi->created = $this->created;
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-01-25 23:08:21 +00:00
|
|
|
$result = $gi->insert();
|
|
|
|
|
2010-02-10 02:32:52 +00:00
|
|
|
if (!$result) {
|
2010-01-25 23:08:21 +00:00
|
|
|
common_log_db_error($gi, 'INSERT', __FILE__);
|
2010-07-29 10:34:58 +01:00
|
|
|
// TRANS: Server exception thrown when an update for a group inbox fails.
|
2010-01-25 23:08:21 +00:00
|
|
|
throw new ServerException(_('Problem saving group inbox.'));
|
|
|
|
}
|
|
|
|
|
|
|
|
self::blow('user_group:notice_ids:%d', $gi->group_id);
|
2009-06-26 07:00:46 +01:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-06-26 07:00:46 +01:00
|
|
|
return true;
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-02-23 00:44:45 +00:00
|
|
|
/**
|
|
|
|
* Save reply records indicating that this notice needs to be
|
|
|
|
* delivered to the local users with the given URIs.
|
|
|
|
*
|
|
|
|
* Since this is expected to be used when saving foreign-sourced
|
|
|
|
* messages, we won't deliver to any remote targets as that's the
|
|
|
|
* source service's responsibility.
|
|
|
|
*
|
2010-04-20 11:06:54 +01:00
|
|
|
* Mail notifications etc will be handled later.
|
2010-02-23 00:44:45 +00:00
|
|
|
*
|
2013-08-29 09:27:39 +01:00
|
|
|
* @param array $uris Array of unique identifier URIs for recipients
|
2010-02-23 00:44:45 +00:00
|
|
|
*/
|
2013-08-29 09:27:39 +01:00
|
|
|
function saveKnownReplies(array $uris)
|
2010-02-22 04:56:48 +00:00
|
|
|
{
|
2010-04-09 18:46:18 +01:00
|
|
|
if (empty($uris)) {
|
|
|
|
return;
|
|
|
|
}
|
2010-09-01 21:15:51 +01:00
|
|
|
|
2013-08-18 12:04:58 +01:00
|
|
|
$sender = Profile::getKV($this->profile_id);
|
2010-04-09 18:46:18 +01:00
|
|
|
|
2010-08-10 21:36:38 +01:00
|
|
|
foreach (array_unique($uris) as $uri) {
|
2014-05-26 14:05:14 +01:00
|
|
|
try {
|
|
|
|
$profile = Profile::fromUri($uri);
|
|
|
|
} catch (UnknownUriException $e) {
|
2010-09-01 21:15:51 +01:00
|
|
|
common_log(LOG_WARNING, "Unable to determine profile for URI '$uri'");
|
|
|
|
continue;
|
|
|
|
}
|
2010-02-22 04:56:48 +00:00
|
|
|
|
2010-09-01 21:15:51 +01:00
|
|
|
if ($profile->hasBlocked($sender)) {
|
|
|
|
common_log(LOG_INFO, "Not saving reply to profile {$profile->id} ($uri) from sender {$sender->id} because of a block.");
|
|
|
|
continue;
|
|
|
|
}
|
2010-02-22 04:56:48 +00:00
|
|
|
|
2011-04-20 17:05:24 +01:00
|
|
|
$this->saveReply($profile->id);
|
|
|
|
self::blow('reply:stream:%d', $profile->id);
|
2010-02-22 04:56:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-12-11 21:53:09 +00:00
|
|
|
/**
|
2010-02-23 00:44:45 +00:00
|
|
|
* Pull @-replies from this message's content in StatusNet markup format
|
|
|
|
* and save reply records indicating that this message needs to be
|
|
|
|
* delivered to those users.
|
|
|
|
*
|
2010-04-20 11:06:54 +01:00
|
|
|
* Mail notifications to local profiles will be sent later.
|
2010-02-23 00:44:45 +00:00
|
|
|
*
|
2009-12-11 21:53:09 +00:00
|
|
|
* @return array of integer profile IDs
|
|
|
|
*/
|
2010-02-21 21:20:30 +00:00
|
|
|
|
2009-01-22 06:53:27 +00:00
|
|
|
function saveReplies()
|
|
|
|
{
|
2010-01-13 09:13:06 +00:00
|
|
|
// Don't save reply data for repeats
|
|
|
|
|
|
|
|
if (!empty($this->repeat_of)) {
|
|
|
|
return array();
|
|
|
|
}
|
|
|
|
|
2014-06-04 23:07:04 +01:00
|
|
|
$sender = $this->getProfile();
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2011-04-20 17:05:24 +01:00
|
|
|
$replied = array();
|
|
|
|
|
|
|
|
// If it's a reply, save for the replied-to author
|
2013-10-05 11:30:14 +01:00
|
|
|
try {
|
2013-10-21 08:09:32 +01:00
|
|
|
$parent = $this->getParent();
|
2014-06-04 23:07:04 +01:00
|
|
|
$parentauthor = $parent->getProfile();
|
|
|
|
$this->saveReply($parentauthor->id);
|
|
|
|
$replied[$parentauthor->id] = 1;
|
|
|
|
self::blow('reply:stream:%d', $parentauthor->id);
|
2013-10-05 11:30:14 +01:00
|
|
|
} catch (Exception $e) {
|
|
|
|
// Not a reply, since it has no parent!
|
2011-04-20 17:05:24 +01:00
|
|
|
}
|
|
|
|
|
2010-02-27 21:30:38 +00:00
|
|
|
// @todo ideally this parser information would only
|
|
|
|
// be calculated once.
|
|
|
|
|
|
|
|
$mentions = common_find_mentions($this->content, $this);
|
2010-02-21 21:20:30 +00:00
|
|
|
|
2009-01-22 06:53:27 +00:00
|
|
|
// store replied only for first @ (what user/notice what the reply directed,
|
|
|
|
// we assume first @ is it)
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-02-21 21:20:30 +00:00
|
|
|
foreach ($mentions as $mention) {
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-02-21 21:20:30 +00:00
|
|
|
foreach ($mention['mentioned'] as $mentioned) {
|
|
|
|
|
|
|
|
// skip if they're already covered
|
|
|
|
|
|
|
|
if (!empty($replied[$mentioned->id])) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Don't save replies from blocked profile to local user
|
|
|
|
|
2013-08-18 12:04:58 +01:00
|
|
|
$mentioned_user = User::getKV('id', $mentioned->id);
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($mentioned_user instanceof User && $mentioned_user->hasBlocked($sender)) {
|
2010-02-21 21:20:30 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-04-20 17:05:24 +01:00
|
|
|
$this->saveReply($mentioned->id);
|
|
|
|
$replied[$mentioned->id] = 1;
|
|
|
|
self::blow('reply:stream:%d', $mentioned->id);
|
2009-01-22 06:53:27 +00:00
|
|
|
}
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-10-28 19:33:10 +00:00
|
|
|
$recipientIds = array_keys($replied);
|
|
|
|
|
|
|
|
return $recipientIds;
|
2009-01-22 06:53:27 +00:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2011-04-20 17:05:24 +01:00
|
|
|
function saveReply($profileId)
|
|
|
|
{
|
|
|
|
$reply = new Reply();
|
|
|
|
|
|
|
|
$reply->notice_id = $this->id;
|
|
|
|
$reply->profile_id = $profileId;
|
|
|
|
$reply->modified = $this->created;
|
|
|
|
|
|
|
|
$reply->insert();
|
|
|
|
|
|
|
|
return $reply;
|
|
|
|
}
|
|
|
|
|
2014-06-04 23:29:43 +01:00
|
|
|
protected $_replies = array();
|
2011-08-03 05:59:09 +01:00
|
|
|
|
2010-04-20 11:06:54 +01:00
|
|
|
/**
|
|
|
|
* Pull the complete list of @-reply targets for this notice.
|
|
|
|
*
|
|
|
|
* @return array of integer profile ids
|
|
|
|
*/
|
2010-01-13 20:37:01 +00:00
|
|
|
function getReplies()
|
|
|
|
{
|
2014-06-04 23:29:43 +01:00
|
|
|
if (isset($this->_replies[$this->id])) {
|
|
|
|
return $this->_replies[$this->id];
|
2011-08-03 05:59:09 +01:00
|
|
|
}
|
2010-01-13 20:37:01 +00:00
|
|
|
|
2013-08-18 20:02:33 +01:00
|
|
|
$replyMap = Reply::listGet('notice_id', array($this->id));
|
2010-01-13 20:37:01 +00:00
|
|
|
|
2011-08-03 05:59:09 +01:00
|
|
|
$ids = array();
|
2010-01-13 20:37:01 +00:00
|
|
|
|
2011-08-03 05:59:09 +01:00
|
|
|
foreach ($replyMap[$this->id] as $reply) {
|
|
|
|
$ids[] = $reply->profile_id;
|
2010-01-13 20:37:01 +00:00
|
|
|
}
|
|
|
|
|
2014-06-04 23:29:43 +01:00
|
|
|
$this->_replies[$this->id] = $ids;
|
2011-08-03 05:59:09 +01:00
|
|
|
|
2010-01-13 20:37:01 +00:00
|
|
|
return $ids;
|
|
|
|
}
|
|
|
|
|
2011-08-03 05:59:09 +01:00
|
|
|
function _setReplies($replies)
|
|
|
|
{
|
2014-06-04 23:29:43 +01:00
|
|
|
$this->_replies[$this->id] = $replies;
|
2011-08-03 05:59:09 +01:00
|
|
|
}
|
|
|
|
|
2011-04-16 20:17:03 +01:00
|
|
|
/**
|
|
|
|
* Pull the complete list of @-reply targets for this notice.
|
|
|
|
*
|
|
|
|
* @return array of Profiles
|
|
|
|
*/
|
|
|
|
function getReplyProfiles()
|
|
|
|
{
|
2011-08-02 16:09:30 +01:00
|
|
|
$ids = $this->getReplies();
|
2011-04-16 20:17:03 +01:00
|
|
|
|
2011-08-02 16:09:30 +01:00
|
|
|
$profiles = Profile::multiGet('id', $ids);
|
|
|
|
|
|
|
|
return $profiles->fetchAll();
|
2011-04-16 20:17:03 +01:00
|
|
|
}
|
|
|
|
|
2010-04-20 11:06:54 +01:00
|
|
|
/**
|
|
|
|
* Send e-mail notifications to local @-reply targets.
|
|
|
|
*
|
|
|
|
* Replies must already have been saved; this is expected to be run
|
|
|
|
* from the distrib queue handler.
|
|
|
|
*/
|
|
|
|
function sendReplyNotifications()
|
|
|
|
{
|
|
|
|
// Don't send reply notifications for repeats
|
|
|
|
|
|
|
|
if (!empty($this->repeat_of)) {
|
|
|
|
return array();
|
|
|
|
}
|
|
|
|
|
|
|
|
$recipientIds = $this->getReplies();
|
|
|
|
|
|
|
|
foreach ($recipientIds as $recipientId) {
|
2013-08-18 12:04:58 +01:00
|
|
|
$user = User::getKV('id', $recipientId);
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($user instanceof User) {
|
2010-04-20 11:06:54 +01:00
|
|
|
mail_notify_attn($user, $this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-15 21:06:21 +00:00
|
|
|
/**
|
2010-02-23 00:44:45 +00:00
|
|
|
* Pull list of groups this notice needs to be delivered to,
|
2013-10-29 10:27:26 +00:00
|
|
|
* as previously recorded by saveKnownGroups().
|
2010-02-23 00:44:45 +00:00
|
|
|
*
|
|
|
|
* @return array of Group objects
|
2010-01-15 21:06:21 +00:00
|
|
|
*/
|
2011-08-02 23:13:56 +01:00
|
|
|
|
2014-06-04 23:29:43 +01:00
|
|
|
protected $_groups = array();
|
2011-08-02 23:13:56 +01:00
|
|
|
|
2010-01-13 20:37:01 +00:00
|
|
|
function getGroups()
|
|
|
|
{
|
2010-01-15 21:06:21 +00:00
|
|
|
// Don't save groups for repeats
|
|
|
|
|
|
|
|
if (!empty($this->repeat_of)) {
|
|
|
|
return array();
|
|
|
|
}
|
2011-08-02 23:13:56 +01:00
|
|
|
|
2014-06-04 23:29:43 +01:00
|
|
|
if (isset($this->_groups[$this->id])) {
|
|
|
|
return $this->_groups[$this->id];
|
2010-01-13 20:37:01 +00:00
|
|
|
}
|
2011-08-02 23:13:56 +01:00
|
|
|
|
2013-08-18 20:02:33 +01:00
|
|
|
$gis = Group_inbox::listGet('notice_id', array($this->id));
|
2011-08-03 05:04:18 +01:00
|
|
|
|
|
|
|
$ids = array();
|
|
|
|
|
2011-08-02 23:13:56 +01:00
|
|
|
foreach ($gis[$this->id] as $gi)
|
|
|
|
{
|
|
|
|
$ids[] = $gi->group_id;
|
|
|
|
}
|
|
|
|
|
2011-08-01 21:59:43 +01:00
|
|
|
$groups = User_group::multiGet('id', $ids);
|
|
|
|
|
2014-06-04 23:29:43 +01:00
|
|
|
$this->_groups[$this->id] = $groups->fetchAll();
|
2011-08-02 23:13:56 +01:00
|
|
|
|
2014-06-04 23:29:43 +01:00
|
|
|
return $this->_groups[$this->id];
|
2011-08-02 23:13:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
function _setGroups($groups)
|
|
|
|
{
|
2014-06-04 23:29:43 +01:00
|
|
|
$this->_groups[$this->id] = $groups;
|
2010-01-13 20:37:01 +00:00
|
|
|
}
|
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
/**
|
|
|
|
* Convert a notice into an activity for export.
|
|
|
|
*
|
|
|
|
* @param User $cur Current user
|
2011-01-28 23:33:13 +00:00
|
|
|
*
|
2010-12-05 21:15:05 +00:00
|
|
|
* @return Activity activity object representing this Notice.
|
|
|
|
*/
|
2010-08-11 01:03:47 +01:00
|
|
|
|
2013-04-14 17:02:52 +01:00
|
|
|
function asActivity($cur=null)
|
2010-08-11 01:03:47 +01:00
|
|
|
{
|
2010-12-06 22:28:22 +00:00
|
|
|
$act = self::cacheGet(Cache::codeKey('notice:as-activity:'.$this->id));
|
2010-08-11 01:03:47 +01:00
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($act instanceof Activity) {
|
2010-12-06 21:38:02 +00:00
|
|
|
return $act;
|
|
|
|
}
|
2010-08-11 01:03:47 +01:00
|
|
|
$act = new Activity();
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
if (Event::handle('StartNoticeAsActivity', array($this, &$act))) {
|
2010-08-11 01:03:47 +01:00
|
|
|
|
2013-10-21 21:27:12 +01:00
|
|
|
$act->id = $this->uri;
|
2011-07-18 22:06:03 +01:00
|
|
|
$act->time = strtotime($this->created);
|
2014-05-10 12:06:18 +01:00
|
|
|
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.
|
|
|
|
}
|
2011-07-18 22:06:03 +01:00
|
|
|
$act->content = common_xml_safe_str($this->rendered);
|
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
$profile = $this->getProfile();
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2011-02-18 03:02:57 +00:00
|
|
|
$act->actor = ActivityObject::fromProfile($profile);
|
|
|
|
$act->actor->extra[] = $profile->profileInfo($cur);
|
2010-08-11 01:03:47 +01:00
|
|
|
|
2011-08-22 21:02:14 +01:00
|
|
|
$act->verb = $this->verb;
|
2010-08-11 01:03:47 +01:00
|
|
|
|
2011-08-22 21:02:14 +01:00
|
|
|
if ($this->repeat_of) {
|
2013-08-18 12:04:58 +01:00
|
|
|
$repeated = Notice::getKV('id', $this->repeat_of);
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($repeated instanceof Notice) {
|
2012-04-24 00:15:12 +01:00
|
|
|
$act->objects[] = $repeated->asActivity($cur);
|
|
|
|
}
|
2011-07-18 22:06:03 +01:00
|
|
|
} else {
|
2011-08-22 21:02:14 +01:00
|
|
|
$act->objects[] = ActivityObject::fromNotice($this);
|
2011-07-18 22:06:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// XXX: should this be handled by default processing for object entry?
|
2010-08-11 01:03:47 +01:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
// Categories
|
2010-08-11 01:03:47 +01:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
$tags = $this->getTags();
|
2010-08-11 01:03:47 +01:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
foreach ($tags as $tag) {
|
|
|
|
$cat = new AtomCategory();
|
|
|
|
$cat->term = $tag;
|
2010-08-11 01:03:47 +01:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
$act->categories[] = $cat;
|
2010-08-11 01:03:47 +01:00
|
|
|
}
|
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
// Enclosures
|
|
|
|
// XXX: use Atom Media and/or File activity objects instead
|
2010-08-11 01:03:47 +01:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
$attachments = $this->attachments();
|
2010-08-11 01:03:47 +01:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
foreach ($attachments as $attachment) {
|
2013-06-05 14:39:13 +01:00
|
|
|
// Save local attachments
|
|
|
|
if (!empty($attachment->filename)) {
|
|
|
|
$act->attachments[] = ActivityObject::fromFile($attachment);
|
2010-12-05 21:15:05 +00:00
|
|
|
}
|
2010-08-11 01:03:47 +01:00
|
|
|
}
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
$ctx = new ActivityContext();
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2013-10-28 16:24:13 +00:00
|
|
|
try {
|
|
|
|
$reply = $this->getParent();
|
2014-04-28 13:04:54 +01:00
|
|
|
$ctx->replyToID = $reply->getUri();
|
|
|
|
$ctx->replyToUrl = $reply->getUrl();
|
2013-10-28 16:24:13 +00:00
|
|
|
} catch (Exception $e) {
|
|
|
|
// This is not a reply to something
|
2010-12-05 21:15:05 +00:00
|
|
|
}
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
$ctx->location = $this->getLocation();
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
$conv = null;
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
if (!empty($this->conversation)) {
|
2013-08-18 12:04:58 +01:00
|
|
|
$conv = Conversation::getKV('id', $this->conversation);
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($conv instanceof Conversation) {
|
2010-12-05 21:15:05 +00:00
|
|
|
$ctx->conversation = $conv->uri;
|
|
|
|
}
|
|
|
|
}
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
$reply_ids = $this->getReplies();
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
foreach ($reply_ids as $id) {
|
2013-08-18 12:04:58 +01:00
|
|
|
$rprofile = Profile::getKV('id', $id);
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($rprofile instanceof Profile) {
|
2013-10-28 21:21:14 +00:00
|
|
|
$ctx->attention[$rprofile->getUri()] = ActivityObject::PERSON;
|
2010-12-05 21:15:05 +00:00
|
|
|
}
|
|
|
|
}
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
$groups = $this->getGroups();
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
foreach ($groups as $group) {
|
2013-10-28 21:21:14 +00:00
|
|
|
$ctx->attention[$group->getUri()] = ActivityObject::GROUP;
|
2013-06-07 08:11:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
switch ($this->scope) {
|
|
|
|
case Notice::PUBLIC_SCOPE:
|
2013-10-28 21:21:14 +00:00
|
|
|
$ctx->attention[ActivityContext::ATTN_PUBLIC] = ActivityObject::COLLECTION;
|
2013-06-07 08:11:23 +01:00
|
|
|
break;
|
|
|
|
case Notice::FOLLOWER_SCOPE:
|
|
|
|
$surl = common_local_url("subscribers", array('nickname' => $profile->nickname));
|
2013-10-28 21:21:14 +00:00
|
|
|
$ctx->attention[$surl] = ActivityObject::COLLECTION;
|
2013-06-07 08:11:23 +01:00
|
|
|
break;
|
2010-08-11 01:03:47 +01:00
|
|
|
}
|
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
$act->context = $ctx;
|
|
|
|
|
2013-06-07 16:34:54 +01:00
|
|
|
$source = $this->getSource();
|
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($source instanceof Notice_source) {
|
2013-06-07 16:34:54 +01:00
|
|
|
$act->generator = ActivityObject::fromNoticeSource($source);
|
|
|
|
}
|
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
// Source
|
2010-08-03 01:16:04 +01:00
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
$atom_feed = $profile->getAtomFeed();
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
if (!empty($atom_feed)) {
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
$act->source = new ActivitySource();
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
// XXX: we should store the actual feed ID
|
2010-08-03 23:50:21 +01:00
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
$act->source->id = $atom_feed;
|
2010-08-03 23:50:21 +01:00
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
// XXX: we should store the actual feed title
|
2010-08-03 23:50:21 +01:00
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
$act->source->title = $profile->getBestName();
|
2010-08-03 01:16:04 +01:00
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
$act->source->links['alternate'] = $profile->profileurl;
|
|
|
|
$act->source->links['self'] = $atom_feed;
|
2010-08-03 01:16:04 +01:00
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
$act->source->icon = $profile->avatarUrl(AVATAR_PROFILE_SIZE);
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
$notice = $profile->getCurrentNotice();
|
2010-08-03 23:50:21 +01:00
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($notice instanceof Notice) {
|
2010-12-08 12:25:55 +00:00
|
|
|
$act->source->updated = self::utcDate($notice->created);
|
|
|
|
}
|
2010-08-03 23:50:21 +01:00
|
|
|
|
2013-08-18 12:04:58 +01:00
|
|
|
$user = User::getKV('id', $profile->id);
|
2010-08-03 23:50:21 +01:00
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($user instanceof User) {
|
2010-12-08 12:25:55 +00:00
|
|
|
$act->source->links['license'] = common_config('license', 'url');
|
2010-08-03 23:50:21 +01:00
|
|
|
}
|
2009-03-22 20:58:38 +00:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
if ($this->isLocal()) {
|
|
|
|
$act->selfLink = common_local_url('ApiStatusesShow', array('id' => $this->id,
|
|
|
|
'format' => 'atom'));
|
|
|
|
$act->editLink = $act->selfLink;
|
2010-08-03 01:16:04 +01:00
|
|
|
}
|
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
Event::handle('EndNoticeAsActivity', array($this, &$act));
|
2010-08-03 01:16:04 +01:00
|
|
|
}
|
2011-01-28 23:33:13 +00:00
|
|
|
|
2010-12-06 22:28:22 +00:00
|
|
|
self::cacheSet(Cache::codeKey('notice:as-activity:'.$this->id), $act);
|
2010-08-03 01:16:04 +01:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
return $act;
|
|
|
|
}
|
2009-11-10 21:15:05 +00:00
|
|
|
|
2010-12-05 21:15:05 +00:00
|
|
|
// This has gotten way too long. Needs to be sliced up into functional bits
|
|
|
|
// or ideally exported to a utility class.
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
function asAtomEntry($namespace=false,
|
|
|
|
$source=false,
|
2011-01-28 23:33:13 +00:00
|
|
|
$author=true,
|
2010-12-08 12:25:55 +00:00
|
|
|
$cur=null)
|
2010-12-05 21:15:05 +00:00
|
|
|
{
|
2011-02-18 03:02:57 +00:00
|
|
|
$act = $this->asActivity($cur);
|
2010-12-08 12:25:55 +00:00
|
|
|
$act->extra[] = $this->noticeInfo($cur);
|
|
|
|
return $act->asString($namespace, $author, $source);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Extra notice info for atom entries
|
2011-01-28 23:33:13 +00:00
|
|
|
*
|
2010-12-08 12:25:55 +00:00
|
|
|
* Clients use some extra notice info in the atom stream.
|
|
|
|
* This gives it to them.
|
|
|
|
*
|
|
|
|
* @param User $cur Current user
|
|
|
|
*
|
|
|
|
* @return array representation of <statusnet:notice_info> element
|
|
|
|
*/
|
|
|
|
|
|
|
|
function noticeInfo($cur)
|
|
|
|
{
|
|
|
|
// local notice ID (useful to clients for ordering)
|
|
|
|
|
|
|
|
$noticeInfoAttr = array('local_id' => $this->id);
|
|
|
|
|
|
|
|
// notice source
|
|
|
|
|
|
|
|
$ns = $this->getSource();
|
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($ns instanceof Notice_source) {
|
2010-12-08 12:25:55 +00:00
|
|
|
$noticeInfoAttr['source'] = $ns->code;
|
|
|
|
if (!empty($ns->url)) {
|
|
|
|
$noticeInfoAttr['source_link'] = $ns->url;
|
|
|
|
if (!empty($ns->name)) {
|
|
|
|
$noticeInfoAttr['source'] = '<a href="'
|
|
|
|
. htmlspecialchars($ns->url)
|
|
|
|
. '" rel="nofollow">'
|
|
|
|
. htmlspecialchars($ns->name)
|
|
|
|
. '</a>';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// favorite and repeated
|
|
|
|
|
2014-06-27 12:58:35 +01:00
|
|
|
$scoped = null;
|
2010-12-08 12:25:55 +00:00
|
|
|
if (!empty($cur)) {
|
2014-06-27 12:58:35 +01:00
|
|
|
$scoped = $cur->getProfile();
|
|
|
|
$noticeInfoAttr['repeated'] = ($scoped->hasRepeated($this)) ? "true" : "false";
|
2010-12-08 12:25:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!empty($this->repeat_of)) {
|
|
|
|
$noticeInfoAttr['repeat_of'] = $this->repeat_of;
|
|
|
|
}
|
|
|
|
|
2014-06-27 12:58:35 +01:00
|
|
|
Event::handle('StatusNetApiNoticeInfo', array($this, &$noticeInfoAttr, $scoped));
|
|
|
|
|
2010-12-08 12:25:55 +00:00
|
|
|
return array('statusnet:notice_info', $noticeInfoAttr, null);
|
2009-03-22 20:58:38 +00:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2010-02-20 23:56:36 +00:00
|
|
|
/**
|
|
|
|
* Returns an XML string fragment with a reference to a notice as an
|
|
|
|
* Activity Streams noun object with the given element type.
|
|
|
|
*
|
|
|
|
* Assumes that 'activity' namespace has been previously defined.
|
|
|
|
*
|
|
|
|
* @param string $element one of 'subject', 'object', 'target'
|
|
|
|
* @return string
|
|
|
|
*/
|
2010-12-05 21:15:05 +00:00
|
|
|
|
2010-02-20 23:56:36 +00:00
|
|
|
function asActivityNoun($element)
|
|
|
|
{
|
2010-02-23 01:10:50 +00:00
|
|
|
$noun = ActivityObject::fromNotice($this);
|
|
|
|
return $noun->asString('activity:' . $element);
|
2010-02-20 23:56:36 +00:00
|
|
|
}
|
|
|
|
|
2009-07-29 16:45:32 +01:00
|
|
|
/**
|
2009-10-04 01:34:40 +01:00
|
|
|
* Determine which notice, if any, a new notice is in reply to.
|
|
|
|
*
|
|
|
|
* For conversation tracking, we try to see where this notice fits
|
2014-06-04 22:20:20 +01:00
|
|
|
* 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).
|
2009-10-04 01:34:40 +01:00
|
|
|
*
|
2014-06-04 22:20:20 +01:00
|
|
|
* @param Profile $sender Author profile
|
2009-10-04 01:34:40 +01:00
|
|
|
* @param string $content Final notice content
|
|
|
|
*
|
|
|
|
* @return integer ID of replied-to notice, or null for not a reply.
|
|
|
|
*/
|
|
|
|
|
2014-06-04 22:20:20 +01:00
|
|
|
static function getInlineReplyTo(Profile $sender, $content)
|
2009-07-29 16:45:32 +01:00
|
|
|
{
|
|
|
|
// Is there an initial @ or T?
|
2014-06-04 22:20:20 +01:00
|
|
|
if (preg_match('/^T ([A-Z0-9]{1,64}) /', $content, $match)
|
|
|
|
|| preg_match('/^@([a-z0-9]{1,64})\s+/', $content, $match)) {
|
2009-10-04 01:34:40 +01:00
|
|
|
$nickname = common_canonical_nickname($match[1]);
|
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2009-07-29 16:45:32 +01:00
|
|
|
// Figure out who that is.
|
|
|
|
$recipient = common_relative_profile($sender, $nickname, common_sql_now());
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2014-06-04 22:20:20 +01:00
|
|
|
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.
|
2009-07-29 16:45:32 +01:00
|
|
|
}
|
2011-04-04 23:13:28 +01:00
|
|
|
|
|
|
|
return null;
|
2009-07-29 16:45:32 +01:00
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-08-21 13:05:13 +01:00
|
|
|
static function maxContent()
|
|
|
|
{
|
|
|
|
$contentlimit = common_config('notice', 'contentlimit');
|
|
|
|
// null => use global limit (distinct from 0!)
|
|
|
|
if (is_null($contentlimit)) {
|
|
|
|
$contentlimit = common_config('site', 'textlimit');
|
|
|
|
}
|
|
|
|
return $contentlimit;
|
|
|
|
}
|
2009-10-04 01:34:40 +01:00
|
|
|
|
2009-08-21 13:05:13 +01:00
|
|
|
static function contentTooLong($content)
|
|
|
|
{
|
|
|
|
$contentlimit = self::maxContent();
|
|
|
|
return ($contentlimit > 0 && !empty($content) && (mb_strlen($content) > $contentlimit));
|
|
|
|
}
|
2009-10-29 18:43:18 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2009-12-11 16:51:09 +00:00
|
|
|
|
2011-03-30 00:20:12 +01:00
|
|
|
/**
|
|
|
|
* Convenience function for posting a repeat of an existing message.
|
|
|
|
*
|
2014-05-18 20:03:10 +01:00
|
|
|
* @param Profile $repeater Profile which is doing the repeat
|
2011-03-30 00:20:12 +01:00
|
|
|
* @param string $source: posting source key, eg 'web', 'api', etc
|
|
|
|
* @return Notice
|
|
|
|
*
|
|
|
|
* @throws Exception on failure or permission problems
|
|
|
|
*/
|
2014-05-18 20:03:10 +01:00
|
|
|
function repeat(Profile $repeater, $source)
|
2009-12-11 16:51:09 +00:00
|
|
|
{
|
2014-05-18 19:53:44 +01:00
|
|
|
$author = $this->getProfile();
|
2009-12-11 16:51:09 +00:00
|
|
|
|
2010-04-11 00:08:51 +01:00
|
|
|
// 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.
|
2009-12-11 16:51:09 +00:00
|
|
|
$content = sprintf(_('RT @%1$s %2$s'),
|
2014-05-18 20:03:10 +01:00
|
|
|
$author->getNickname(),
|
2009-12-11 16:51:09 +00:00
|
|
|
$this->content);
|
|
|
|
|
2011-03-29 17:12:08 +01:00
|
|
|
// Scope is same as this one's
|
2014-05-18 20:03:10 +01:00
|
|
|
return self::saveNew($repeater->id,
|
2011-03-29 17:12:08 +01:00
|
|
|
$content,
|
|
|
|
$source,
|
|
|
|
array('repeat_of' => $this->id,
|
|
|
|
'scope' => $this->scope));
|
2009-12-11 16:51:09 +00:00
|
|
|
}
|
2009-12-12 19:46:24 +00:00
|
|
|
|
|
|
|
// These are supposed to be in chron order!
|
|
|
|
|
|
|
|
function repeatStream($limit=100)
|
|
|
|
{
|
2010-09-06 14:56:45 +01:00
|
|
|
$cache = Cache::instance();
|
2009-12-12 19:46:24 +00:00
|
|
|
|
|
|
|
if (empty($cache)) {
|
|
|
|
$ids = $this->_repeatStreamDirect($limit);
|
|
|
|
} else {
|
2010-09-06 15:07:43 +01:00
|
|
|
$idstr = $cache->get(Cache::key('notice:repeats:'.$this->id));
|
2010-01-04 20:03:57 +00:00
|
|
|
if ($idstr !== false) {
|
2011-07-14 17:53:18 +01:00
|
|
|
if (empty($idstr)) {
|
|
|
|
$ids = array();
|
|
|
|
} else {
|
|
|
|
$ids = explode(',', $idstr);
|
|
|
|
}
|
2009-12-12 19:46:24 +00:00
|
|
|
} else {
|
|
|
|
$ids = $this->_repeatStreamDirect(100);
|
2010-09-06 15:07:43 +01:00
|
|
|
$cache->set(Cache::key('notice:repeats:'.$this->id), implode(',', $ids));
|
2009-12-12 19:46:24 +00:00
|
|
|
}
|
|
|
|
if ($limit < 100) {
|
|
|
|
// We do a max of 100, so slice down to limit
|
|
|
|
$ids = array_slice($ids, 0, $limit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-23 15:59:01 +00:00
|
|
|
return NoticeStream::getStreamByIds($ids);
|
2009-12-12 19:46:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function _repeatStreamDirect($limit)
|
|
|
|
{
|
|
|
|
$notice = new Notice();
|
|
|
|
|
|
|
|
$notice->selectAdd(); // clears it
|
|
|
|
$notice->selectAdd('id');
|
|
|
|
|
|
|
|
$notice->repeat_of = $this->id;
|
|
|
|
|
2010-12-17 23:13:09 +00:00
|
|
|
$notice->orderBy('created, id'); // NB: asc!
|
2009-12-12 19:46:24 +00:00
|
|
|
|
2010-12-17 23:04:10 +00:00
|
|
|
if (!is_null($limit)) {
|
|
|
|
$notice->limit(0, $limit);
|
2009-12-12 19:46:24 +00:00
|
|
|
}
|
|
|
|
|
2011-07-14 17:53:18 +01:00
|
|
|
return $notice->fetchAll('id');
|
2009-12-12 19:46:24 +00:00
|
|
|
}
|
2009-12-28 23:13:15 +00:00
|
|
|
|
|
|
|
function locationOptions($lat, $lon, $location_id, $location_ns, $profile = null)
|
|
|
|
{
|
|
|
|
$options = array();
|
|
|
|
|
|
|
|
if (!empty($location_id) && !empty($location_ns)) {
|
|
|
|
$options['location_id'] = $location_id;
|
|
|
|
$options['location_ns'] = $location_ns;
|
|
|
|
|
|
|
|
$location = Location::fromId($location_id, $location_ns);
|
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($location instanceof Location) {
|
2009-12-28 23:13:15 +00:00
|
|
|
$options['lat'] = $location->lat;
|
|
|
|
$options['lon'] = $location->lon;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (!empty($lat) && !empty($lon)) {
|
|
|
|
$options['lat'] = $lat;
|
|
|
|
$options['lon'] = $lon;
|
|
|
|
|
|
|
|
$location = Location::fromLatLon($lat, $lon);
|
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($location instanceof Location) {
|
2009-12-28 23:13:15 +00:00
|
|
|
$options['location_id'] = $location->location_id;
|
|
|
|
$options['location_ns'] = $location->location_ns;
|
|
|
|
}
|
|
|
|
} else if (!empty($profile)) {
|
|
|
|
if (isset($profile->lat) && isset($profile->lon)) {
|
|
|
|
$options['lat'] = $profile->lat;
|
|
|
|
$options['lon'] = $profile->lon;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isset($profile->location_id) && isset($profile->location_ns)) {
|
|
|
|
$options['location_id'] = $profile->location_id;
|
|
|
|
$options['location_ns'] = $profile->location_ns;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $options;
|
|
|
|
}
|
2010-01-25 23:08:21 +00:00
|
|
|
|
2014-03-06 13:43:36 +00:00
|
|
|
function clearAttentions()
|
|
|
|
{
|
|
|
|
$att = new Attention();
|
|
|
|
$att->notice_id = $this->getID();
|
|
|
|
|
|
|
|
if ($att->find()) {
|
|
|
|
while ($att->fetch()) {
|
|
|
|
// Can't do delete() on the object directly since it won't remove all of it
|
|
|
|
$other = clone($att);
|
|
|
|
$other->delete();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-25 23:08:21 +00:00
|
|
|
function clearReplies()
|
|
|
|
{
|
|
|
|
$replyNotice = new Notice();
|
|
|
|
$replyNotice->reply_to = $this->id;
|
|
|
|
|
|
|
|
//Null any notices that are replies to this notice
|
|
|
|
|
|
|
|
if ($replyNotice->find()) {
|
|
|
|
while ($replyNotice->fetch()) {
|
|
|
|
$orig = clone($replyNotice);
|
|
|
|
$replyNotice->reply_to = null;
|
|
|
|
$replyNotice->update($orig);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reply records
|
|
|
|
|
|
|
|
$reply = new Reply();
|
|
|
|
$reply->notice_id = $this->id;
|
|
|
|
|
|
|
|
if ($reply->find()) {
|
|
|
|
while($reply->fetch()) {
|
|
|
|
self::blow('reply:stream:%d', $reply->profile_id);
|
|
|
|
$reply->delete();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$reply->free();
|
|
|
|
}
|
|
|
|
|
2010-12-28 21:44:18 +00:00
|
|
|
function clearFiles()
|
|
|
|
{
|
|
|
|
$f2p = new File_to_post();
|
|
|
|
|
|
|
|
$f2p->post_id = $this->id;
|
|
|
|
|
|
|
|
if ($f2p->find()) {
|
|
|
|
while ($f2p->fetch()) {
|
|
|
|
$f2p->delete();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// FIXME: decide whether to delete File objects
|
|
|
|
// ...and related (actual) files
|
|
|
|
}
|
|
|
|
|
2010-01-25 23:08:21 +00:00
|
|
|
function clearRepeats()
|
|
|
|
{
|
|
|
|
$repeatNotice = new Notice();
|
|
|
|
$repeatNotice->repeat_of = $this->id;
|
|
|
|
|
|
|
|
//Null any notices that are repeats of this notice
|
|
|
|
|
|
|
|
if ($repeatNotice->find()) {
|
|
|
|
while ($repeatNotice->fetch()) {
|
|
|
|
$orig = clone($repeatNotice);
|
|
|
|
$repeatNotice->repeat_of = null;
|
|
|
|
$repeatNotice->update($orig);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function clearTags()
|
|
|
|
{
|
|
|
|
$tag = new Notice_tag();
|
|
|
|
$tag->notice_id = $this->id;
|
|
|
|
|
|
|
|
if ($tag->find()) {
|
|
|
|
while ($tag->fetch()) {
|
2010-09-06 15:03:51 +01:00
|
|
|
self::blow('profile:notice_ids_tagged:%d:%s', $this->profile_id, Cache::keyize($tag->tag));
|
|
|
|
self::blow('profile:notice_ids_tagged:%d:%s;last', $this->profile_id, Cache::keyize($tag->tag));
|
|
|
|
self::blow('notice_tag:notice_ids:%s', Cache::keyize($tag->tag));
|
|
|
|
self::blow('notice_tag:notice_ids:%s;last', Cache::keyize($tag->tag));
|
2010-01-25 23:08:21 +00:00
|
|
|
$tag->delete();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$tag->free();
|
|
|
|
}
|
|
|
|
|
|
|
|
function clearGroupInboxes()
|
|
|
|
{
|
|
|
|
$gi = new Group_inbox();
|
|
|
|
|
|
|
|
$gi->notice_id = $this->id;
|
|
|
|
|
|
|
|
if ($gi->find()) {
|
|
|
|
while ($gi->fetch()) {
|
|
|
|
self::blow('user_group:notice_ids:%d', $gi->group_id);
|
|
|
|
$gi->delete();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$gi->free();
|
|
|
|
}
|
2010-01-28 23:40:38 +00:00
|
|
|
|
|
|
|
function distribute()
|
|
|
|
{
|
2010-02-18 12:11:20 +00:00
|
|
|
// We always insert for the author so they don't
|
|
|
|
// have to wait
|
2010-10-01 00:25:15 +01:00
|
|
|
Event::handle('StartNoticeDistribute', array($this));
|
2010-02-18 12:11:20 +00:00
|
|
|
|
2014-03-06 00:50:54 +00:00
|
|
|
// If there's a failure, we want to _force_
|
|
|
|
// distribution at this point.
|
|
|
|
try {
|
|
|
|
$qm = QueueManager::get();
|
|
|
|
$qm->enqueue($this, 'distrib');
|
|
|
|
} catch (Exception $e) {
|
|
|
|
// If the exception isn't transient, this
|
|
|
|
// may throw more exceptions as DQH does
|
|
|
|
// its own enqueueing. So, we ignore them!
|
2010-01-28 23:40:38 +00:00
|
|
|
try {
|
2014-03-06 00:50:54 +00:00
|
|
|
$handler = new DistribQueueHandler();
|
|
|
|
$handler->handle($this);
|
2010-01-28 23:40:38 +00:00
|
|
|
} catch (Exception $e) {
|
2014-03-06 00:50:54 +00:00
|
|
|
common_log(LOG_ERR, "emergency redistribution resulted in " . $e->getMessage());
|
2010-01-28 23:40:38 +00:00
|
|
|
}
|
2014-03-06 00:50:54 +00:00
|
|
|
// Re-throw so somebody smarter can handle it.
|
|
|
|
throw $e;
|
2010-01-28 23:40:38 +00:00
|
|
|
}
|
|
|
|
}
|
2010-02-03 17:31:25 +00:00
|
|
|
|
|
|
|
function insert()
|
|
|
|
{
|
|
|
|
$result = parent::insert();
|
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if ($result !== false) {
|
2010-02-03 17:31:25 +00:00
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return $result;
|
|
|
|
}
|
2010-05-06 08:20:10 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the source of the notice
|
|
|
|
*
|
|
|
|
* @return Notice_source $ns A notice source object. 'code' is the only attribute
|
|
|
|
* guaranteed to be populated.
|
|
|
|
*/
|
|
|
|
function getSource()
|
|
|
|
{
|
|
|
|
$ns = new Notice_source();
|
|
|
|
if (!empty($this->source)) {
|
|
|
|
switch ($this->source) {
|
|
|
|
case 'web':
|
|
|
|
case 'xmpp':
|
|
|
|
case 'mail':
|
|
|
|
case 'omb':
|
|
|
|
case 'system':
|
|
|
|
case 'api':
|
|
|
|
$ns->code = $this->source;
|
|
|
|
break;
|
|
|
|
default:
|
2013-08-18 12:04:58 +01:00
|
|
|
$ns = Notice_source::getKV($this->source);
|
2010-05-06 08:20:10 +01:00
|
|
|
if (!$ns) {
|
|
|
|
$ns = new Notice_source();
|
|
|
|
$ns->code = $this->source;
|
2013-08-18 12:04:58 +01:00
|
|
|
$app = Oauth_application::getKV('name', $this->source);
|
2010-05-06 08:20:10 +01:00
|
|
|
if ($app) {
|
|
|
|
$ns->name = $app->name;
|
|
|
|
$ns->url = $app->source_url;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $ns;
|
|
|
|
}
|
|
|
|
|
2010-06-04 00:58:45 +01:00
|
|
|
/**
|
|
|
|
* Determine whether the notice was locally created
|
|
|
|
*
|
|
|
|
* @return boolean locality
|
|
|
|
*/
|
|
|
|
|
|
|
|
public function isLocal()
|
|
|
|
{
|
|
|
|
return ($this->is_local == Notice::LOCAL_PUBLIC ||
|
|
|
|
$this->is_local == Notice::LOCAL_NONPUBLIC);
|
|
|
|
}
|
|
|
|
|
2011-03-15 19:51:29 +00:00
|
|
|
/**
|
|
|
|
* Get the list of hash tags saved with this notice.
|
|
|
|
*
|
|
|
|
* @return array of strings
|
|
|
|
*/
|
2010-08-03 01:16:04 +01:00
|
|
|
public function getTags()
|
|
|
|
{
|
|
|
|
$tags = array();
|
2011-04-07 04:25:24 +01:00
|
|
|
|
|
|
|
$keypart = sprintf('notice:tags:%d', $this->id);
|
|
|
|
|
|
|
|
$tagstr = self::cacheGet($keypart);
|
|
|
|
|
|
|
|
if ($tagstr !== false) {
|
|
|
|
$tags = explode(',', $tagstr);
|
|
|
|
} else {
|
|
|
|
$tag = new Notice_tag();
|
|
|
|
$tag->notice_id = $this->id;
|
|
|
|
if ($tag->find()) {
|
|
|
|
while ($tag->fetch()) {
|
|
|
|
$tags[] = $tag->tag;
|
|
|
|
}
|
2010-08-03 01:16:04 +01:00
|
|
|
}
|
2011-04-07 04:25:24 +01:00
|
|
|
self::cacheSet($keypart, implode(',', $tags));
|
2010-08-03 01:16:04 +01:00
|
|
|
}
|
2011-04-07 04:25:24 +01:00
|
|
|
|
2010-08-03 01:16:04 +01:00
|
|
|
return $tags;
|
|
|
|
}
|
2010-08-03 23:55:40 +01:00
|
|
|
|
|
|
|
static private function utcDate($dt)
|
|
|
|
{
|
|
|
|
$dateStr = date('d F Y H:i:s', strtotime($dt));
|
|
|
|
$d = new DateTime($dateStr, new DateTimeZone('UTC'));
|
|
|
|
return $d->format(DATE_W3C);
|
|
|
|
}
|
2010-12-17 20:09:02 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Look up the creation timestamp for a given notice ID, even
|
|
|
|
* if it's been deleted.
|
|
|
|
*
|
|
|
|
* @param int $id
|
|
|
|
* @return mixed string recorded creation timestamp, or false if can't be found
|
|
|
|
*/
|
|
|
|
public static function getAsTimestamp($id)
|
|
|
|
{
|
2010-12-17 20:38:38 +00:00
|
|
|
if (!$id) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-08-18 12:04:58 +01:00
|
|
|
$notice = Notice::getKV('id', $id);
|
2010-12-17 20:09:02 +00:00
|
|
|
if ($notice) {
|
|
|
|
return $notice->created;
|
|
|
|
}
|
2010-12-17 20:38:38 +00:00
|
|
|
|
2013-08-18 12:04:58 +01:00
|
|
|
$deleted = Deleted_notice::getKV('id', $id);
|
2010-12-17 20:38:38 +00:00
|
|
|
if ($deleted) {
|
|
|
|
return $deleted->created;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
2010-12-17 20:09:02 +00:00
|
|
|
}
|
2010-12-17 21:03:18 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Build an SQL 'where' fragment for timestamp-based sorting from a since_id
|
|
|
|
* parameter, matching notices posted after the given one (exclusive).
|
|
|
|
*
|
|
|
|
* If the referenced notice can't be found, will return false.
|
|
|
|
*
|
|
|
|
* @param int $id
|
|
|
|
* @param string $idField
|
|
|
|
* @param string $createdField
|
|
|
|
* @return mixed string or false if no match
|
|
|
|
*/
|
|
|
|
public static function whereSinceId($id, $idField='id', $createdField='created')
|
|
|
|
{
|
|
|
|
$since = Notice::getAsTimestamp($id);
|
|
|
|
if ($since) {
|
|
|
|
return sprintf("($createdField = '%s' and $idField > %d) or ($createdField > '%s')", $since, $id, $since);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-12-17 21:20:38 +00:00
|
|
|
/**
|
|
|
|
* Build an SQL 'where' fragment for timestamp-based sorting from a since_id
|
|
|
|
* parameter, matching notices posted after the given one (exclusive), and
|
|
|
|
* if necessary add it to the data object's query.
|
|
|
|
*
|
|
|
|
* @param DB_DataObject $obj
|
|
|
|
* @param int $id
|
|
|
|
* @param string $idField
|
|
|
|
* @param string $createdField
|
|
|
|
* @return mixed string or false if no match
|
|
|
|
*/
|
|
|
|
public static function addWhereSinceId(DB_DataObject $obj, $id, $idField='id', $createdField='created')
|
|
|
|
{
|
2010-12-28 06:35:57 +00:00
|
|
|
$since = self::whereSinceId($id, $idField, $createdField);
|
2010-12-17 21:20:38 +00:00
|
|
|
if ($since) {
|
|
|
|
$obj->whereAdd($since);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-17 21:03:18 +00:00
|
|
|
/**
|
|
|
|
* Build an SQL 'where' fragment for timestamp-based sorting from a max_id
|
|
|
|
* parameter, matching notices posted before the given one (inclusive).
|
|
|
|
*
|
|
|
|
* If the referenced notice can't be found, will return false.
|
|
|
|
*
|
|
|
|
* @param int $id
|
|
|
|
* @param string $idField
|
|
|
|
* @param string $createdField
|
|
|
|
* @return mixed string or false if no match
|
|
|
|
*/
|
|
|
|
public static function whereMaxId($id, $idField='id', $createdField='created')
|
|
|
|
{
|
|
|
|
$max = Notice::getAsTimestamp($id);
|
|
|
|
if ($max) {
|
|
|
|
return sprintf("($createdField < '%s') or ($createdField = '%s' and $idField <= %d)", $max, $max, $id);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2010-12-17 21:20:38 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Build an SQL 'where' fragment for timestamp-based sorting from a max_id
|
|
|
|
* parameter, matching notices posted before the given one (inclusive), and
|
|
|
|
* if necessary add it to the data object's query.
|
|
|
|
*
|
|
|
|
* @param DB_DataObject $obj
|
|
|
|
* @param int $id
|
|
|
|
* @param string $idField
|
|
|
|
* @param string $createdField
|
|
|
|
* @return mixed string or false if no match
|
|
|
|
*/
|
|
|
|
public static function addWhereMaxId(DB_DataObject $obj, $id, $idField='id', $createdField='created')
|
|
|
|
{
|
2010-12-28 06:35:57 +00:00
|
|
|
$max = self::whereMaxId($id, $idField, $createdField);
|
2010-12-17 21:20:38 +00:00
|
|
|
if ($max) {
|
|
|
|
$obj->whereAdd($max);
|
|
|
|
}
|
|
|
|
}
|
2011-02-03 18:58:56 +00:00
|
|
|
|
|
|
|
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));
|
|
|
|
}
|
|
|
|
}
|
2011-03-22 15:36:48 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Check that the given profile is allowed to read, respond to, or otherwise
|
|
|
|
* act on this notice.
|
2011-04-10 18:59:55 +01:00
|
|
|
*
|
2011-03-22 15:36:48 +00:00
|
|
|
* The $scope member is a bitmask of scopes, representing a logical AND of the
|
|
|
|
* scope requirement. So, 0x03 (Notice::ADDRESSEE_SCOPE | Notice::SITE_SCOPE) means
|
|
|
|
* "only visible to people who are mentioned in the notice AND are users on this site."
|
|
|
|
* Users on the site who are not mentioned in the notice will not be able to see the
|
|
|
|
* notice.
|
|
|
|
*
|
2011-03-30 01:01:53 +01:00
|
|
|
* @param Profile $profile The profile to check; pass null to check for public/unauthenticated users.
|
2011-03-22 15:36:48 +00:00
|
|
|
*
|
|
|
|
* @return boolean whether the profile is in the notice's scope
|
|
|
|
*/
|
|
|
|
function inScope($profile)
|
2011-04-07 21:24:56 +01:00
|
|
|
{
|
2011-04-11 00:19:10 +01:00
|
|
|
if (is_null($profile)) {
|
|
|
|
$keypart = sprintf('notice:in-scope-for:%d:null', $this->id);
|
|
|
|
} else {
|
|
|
|
$keypart = sprintf('notice:in-scope-for:%d:%d', $this->id, $profile->id);
|
|
|
|
}
|
2011-04-07 21:24:56 +01:00
|
|
|
|
|
|
|
$result = self::cacheGet($keypart);
|
|
|
|
|
|
|
|
if ($result === false) {
|
2012-03-20 20:38:56 +00:00
|
|
|
$bResult = false;
|
2012-03-21 01:13:12 +00:00
|
|
|
if (Event::handle('StartNoticeInScope', array($this, $profile, &$bResult))) {
|
2012-03-20 20:38:56 +00:00
|
|
|
$bResult = $this->_inScope($profile);
|
2012-03-21 01:13:12 +00:00
|
|
|
Event::handle('EndNoticeInScope', array($this, $profile, &$bResult));
|
2012-03-20 20:38:56 +00:00
|
|
|
}
|
2011-04-07 21:24:56 +01:00
|
|
|
$result = ($bResult) ? 1 : 0;
|
|
|
|
self::cacheSet($keypart, $result, 0, 300);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ($result == 1) ? true : false;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected function _inScope($profile)
|
2011-03-22 15:36:48 +00:00
|
|
|
{
|
2011-09-08 18:05:17 +01:00
|
|
|
if (!is_null($this->scope)) {
|
2011-09-08 17:38:11 +01:00
|
|
|
$scope = $this->scope;
|
|
|
|
} else {
|
|
|
|
$scope = self::defaultScope();
|
|
|
|
}
|
|
|
|
|
2011-03-26 20:23:20 +00:00
|
|
|
// If there's no scope, anyone (even anon) is in scope.
|
2011-03-22 15:36:48 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
if ($scope == 0) { // Not private
|
2011-03-26 20:23:20 +00:00
|
|
|
|
2012-03-21 17:02:33 +00:00
|
|
|
return !$this->isHiddenSpam($profile);
|
2011-03-26 20:23:20 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
} else { // Private, somehow
|
2011-03-26 20:23:20 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
// If there's scope, anon cannot be in scope
|
2011-03-26 20:23:20 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
if (empty($profile)) {
|
|
|
|
return false;
|
|
|
|
}
|
2011-03-22 15:36:48 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
// Author is always in scope
|
2011-03-22 15:36:48 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
if ($this->profile_id == $profile->id) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Only for users on this site
|
|
|
|
|
2013-09-09 20:35:16 +01:00
|
|
|
if (($scope & Notice::SITE_SCOPE) && !$profile->isLocal()) {
|
|
|
|
return false;
|
2011-03-22 15:36:48 +00:00
|
|
|
}
|
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
// Only for users mentioned in the notice
|
2011-03-22 15:36:48 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
if ($scope & Notice::ADDRESSEE_SCOPE) {
|
2011-03-22 15:36:48 +00:00
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
$reply = Reply::pkeyGet(array('notice_id' => $this->id,
|
2012-03-21 14:17:11 +00:00
|
|
|
'profile_id' => $profile->id));
|
2011-08-02 16:09:30 +01:00
|
|
|
|
2013-10-28 21:18:00 +00:00
|
|
|
if (!$reply instanceof Reply) {
|
2012-03-21 14:17:11 +00:00
|
|
|
return false;
|
|
|
|
}
|
2011-03-22 15:36:48 +00:00
|
|
|
}
|
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
// Only for members of the given group
|
2011-03-22 15:36:48 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
if ($scope & Notice::GROUP_SCOPE) {
|
2011-03-22 15:36:48 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
// XXX: just query for the single membership
|
2011-03-22 15:36:48 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
$groups = $this->getGroups();
|
2011-03-22 15:36:48 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
$foundOne = false;
|
2011-03-22 15:36:48 +00:00
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
foreach ($groups as $group) {
|
|
|
|
if ($profile->isMember($group)) {
|
|
|
|
$foundOne = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!$foundOne) {
|
|
|
|
return false;
|
2011-03-22 15:36:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
// Only for followers of the author
|
|
|
|
|
|
|
|
$author = null;
|
|
|
|
|
|
|
|
if ($scope & Notice::FOLLOWER_SCOPE) {
|
|
|
|
|
2012-05-05 04:37:12 +01:00
|
|
|
try {
|
|
|
|
$author = $this->getProfile();
|
|
|
|
} catch (Exception $e) {
|
|
|
|
return false;
|
|
|
|
}
|
2012-03-21 14:17:11 +00:00
|
|
|
|
|
|
|
if (!Subscription::exists($profile, $author)) {
|
|
|
|
return false;
|
|
|
|
}
|
2011-03-22 15:36:48 +00:00
|
|
|
}
|
2012-03-21 14:17:11 +00:00
|
|
|
|
2012-03-21 17:02:33 +00:00
|
|
|
return !$this->isHiddenSpam($profile);
|
2011-03-22 15:36:48 +00:00
|
|
|
}
|
2012-03-21 14:17:11 +00:00
|
|
|
}
|
|
|
|
|
2012-03-21 17:02:33 +00:00
|
|
|
function isHiddenSpam($profile) {
|
2012-03-21 14:17:11 +00:00
|
|
|
|
|
|
|
// Hide posts by silenced users from everyone but moderators.
|
|
|
|
|
|
|
|
if (common_config('notice', 'hidespam')) {
|
2011-03-22 15:36:48 +00:00
|
|
|
|
2012-05-05 04:37:12 +01:00
|
|
|
try {
|
|
|
|
$author = $this->getProfile();
|
|
|
|
} catch(Exception $e) {
|
|
|
|
// If we can't get an author, keep it hidden.
|
|
|
|
// XXX: technically not spam, but, whatever.
|
|
|
|
return true;
|
|
|
|
}
|
2012-03-21 14:17:11 +00:00
|
|
|
|
|
|
|
if ($author->hasRole(Profile_role::SILENCED)) {
|
2013-10-28 21:18:00 +00:00
|
|
|
if (!$profile instanceof Profile || (($profile->id !== $author->id) && (!$profile->hasRight(Right::REVIEWSPAM)))) {
|
2012-03-21 14:17:11 +00:00
|
|
|
return true;
|
|
|
|
}
|
2011-03-22 15:36:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-21 14:17:11 +00:00
|
|
|
return false;
|
2011-03-22 15:36:48 +00:00
|
|
|
}
|
2011-04-04 22:33:42 +01:00
|
|
|
|
2013-10-02 14:01:11 +01:00
|
|
|
public function getParent()
|
2011-04-11 16:19:11 +01:00
|
|
|
{
|
2013-10-23 11:24:20 +01:00
|
|
|
$parent = Notice::getKV('id', $this->reply_to);
|
|
|
|
|
|
|
|
if (!$parent instanceof Notice) {
|
2013-10-22 14:37:01 +01:00
|
|
|
throw new ServerException('Notice has no parent');
|
2011-04-11 16:19:11 +01:00
|
|
|
}
|
2013-10-23 11:24:20 +01:00
|
|
|
|
|
|
|
return $parent;
|
2011-04-11 16:19:11 +01:00
|
|
|
}
|
2011-04-18 23:23:06 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Magic function called at serialize() time.
|
|
|
|
*
|
|
|
|
* We use this to drop a couple process-specific references
|
|
|
|
* from DB_DataObject which can cause trouble in future
|
|
|
|
* processes.
|
|
|
|
*
|
|
|
|
* @return array of variable names to include in serialization.
|
|
|
|
*/
|
|
|
|
|
|
|
|
function __sleep()
|
|
|
|
{
|
|
|
|
$vars = parent::__sleep();
|
2013-10-23 11:24:20 +01:00
|
|
|
$skip = array('_profile', '_groups', '_attachments', '_faves', '_replies', '_repeats');
|
2011-04-18 23:23:06 +01:00
|
|
|
return array_diff($vars, $skip);
|
|
|
|
}
|
2011-07-02 02:50:04 +01:00
|
|
|
|
|
|
|
static function defaultScope()
|
|
|
|
{
|
|
|
|
$scope = common_config('notice', 'defaultscope');
|
|
|
|
if (is_null($scope)) {
|
|
|
|
if (common_config('site', 'private')) {
|
|
|
|
$scope = 1;
|
|
|
|
} else {
|
|
|
|
$scope = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return $scope;
|
|
|
|
}
|
2011-04-18 23:23:06 +01:00
|
|
|
|
2011-08-01 19:51:59 +01:00
|
|
|
static function fillProfiles($notices)
|
|
|
|
{
|
2011-08-02 16:54:27 +01:00
|
|
|
$map = self::getProfiles($notices);
|
2011-08-01 19:51:59 +01:00
|
|
|
|
2014-03-05 00:27:27 +00:00
|
|
|
foreach ($notices as $entry=>$notice) {
|
|
|
|
try {
|
|
|
|
if (array_key_exists($notice->profile_id, $map)) {
|
|
|
|
$notice->_setProfile($map[$notice->profile_id]);
|
|
|
|
}
|
|
|
|
} catch (NoProfileException $e) {
|
2014-05-26 13:36:41 +01:00
|
|
|
common_log(LOG_WARNING, "Failed to fill profile in Notice with non-existing entry for profile_id: {$e->profile_id}");
|
2014-03-05 00:27:27 +00:00
|
|
|
unset($notices[$entry]);
|
|
|
|
}
|
2011-08-01 19:51:59 +01:00
|
|
|
}
|
|
|
|
|
2011-08-02 16:54:27 +01:00
|
|
|
return array_values($map);
|
|
|
|
}
|
|
|
|
|
|
|
|
static function getProfiles(&$notices)
|
|
|
|
{
|
|
|
|
$ids = array();
|
|
|
|
foreach ($notices as $notice) {
|
|
|
|
$ids[] = $notice->profile_id;
|
|
|
|
}
|
2011-08-01 19:51:59 +01:00
|
|
|
|
2011-08-02 16:54:27 +01:00
|
|
|
$ids = array_unique($ids);
|
2011-08-01 19:51:59 +01:00
|
|
|
|
2013-08-29 09:13:07 +01:00
|
|
|
return Profile::pivotGet('id', $ids);
|
2011-08-01 19:51:59 +01:00
|
|
|
}
|
2011-08-02 23:13:56 +01:00
|
|
|
|
|
|
|
static function fillGroups(&$notices)
|
|
|
|
{
|
2011-08-03 04:12:21 +01:00
|
|
|
$ids = self::_idsOf($notices);
|
2011-08-02 23:13:56 +01:00
|
|
|
|
2013-08-18 20:02:33 +01:00
|
|
|
$gis = Group_inbox::listGet('notice_id', $ids);
|
2011-08-02 23:13:56 +01:00
|
|
|
|
2011-08-03 05:04:18 +01:00
|
|
|
$gids = array();
|
|
|
|
|
2011-08-02 23:13:56 +01:00
|
|
|
foreach ($gis as $id => $gi)
|
|
|
|
{
|
|
|
|
foreach ($gi as $g)
|
|
|
|
{
|
|
|
|
$gids[] = $g->group_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$gids = array_unique($gids);
|
|
|
|
|
2013-08-29 09:13:07 +01:00
|
|
|
$group = User_group::pivotGet('id', $gids);
|
2011-08-02 23:13:56 +01:00
|
|
|
|
|
|
|
foreach ($notices as $notice)
|
|
|
|
{
|
|
|
|
$grps = array();
|
|
|
|
$gi = $gis[$notice->id];
|
|
|
|
foreach ($gi as $g) {
|
|
|
|
$grps[] = $group[$g->group_id];
|
|
|
|
}
|
|
|
|
$notice->_setGroups($grps);
|
|
|
|
}
|
|
|
|
}
|
2011-08-03 04:12:21 +01:00
|
|
|
|
2014-06-27 12:58:35 +01:00
|
|
|
static function _idsOf(array &$notices)
|
2011-08-03 04:12:21 +01:00
|
|
|
{
|
|
|
|
$ids = array();
|
|
|
|
foreach ($notices as $notice) {
|
2014-06-27 12:58:35 +01:00
|
|
|
$ids[$notice->id] = true;
|
2011-08-03 04:12:21 +01:00
|
|
|
}
|
2014-06-27 12:58:35 +01:00
|
|
|
return array_keys($ids);
|
2011-08-03 04:12:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static function fillAttachments(&$notices)
|
|
|
|
{
|
|
|
|
$ids = self::_idsOf($notices);
|
|
|
|
|
2013-08-18 20:02:33 +01:00
|
|
|
$f2pMap = File_to_post::listGet('post_id', $ids);
|
2011-08-03 04:12:21 +01:00
|
|
|
|
|
|
|
$fileIds = array();
|
|
|
|
|
|
|
|
foreach ($f2pMap as $noticeId => $f2ps) {
|
|
|
|
foreach ($f2ps as $f2p) {
|
|
|
|
$fileIds[] = $f2p->file_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$fileIds = array_unique($fileIds);
|
|
|
|
|
2013-08-29 09:13:07 +01:00
|
|
|
$fileMap = File::pivotGet('id', $fileIds);
|
2011-08-03 04:12:21 +01:00
|
|
|
|
|
|
|
foreach ($notices as $notice)
|
|
|
|
{
|
|
|
|
$files = array();
|
|
|
|
$f2ps = $f2pMap[$notice->id];
|
|
|
|
foreach ($f2ps as $f2p) {
|
|
|
|
$files[] = $fileMap[$f2p->file_id];
|
|
|
|
}
|
|
|
|
$notice->_setAttachments($files);
|
|
|
|
}
|
|
|
|
}
|
2011-08-03 05:04:18 +01:00
|
|
|
|
2011-08-03 05:59:09 +01:00
|
|
|
static function fillReplies(&$notices)
|
|
|
|
{
|
|
|
|
$ids = self::_idsOf($notices);
|
2013-08-18 20:02:33 +01:00
|
|
|
$replyMap = Reply::listGet('notice_id', $ids);
|
2011-08-03 05:59:09 +01:00
|
|
|
foreach ($notices as $notice) {
|
|
|
|
$replies = $replyMap[$notice->id];
|
|
|
|
$ids = array();
|
|
|
|
foreach ($replies as $reply) {
|
|
|
|
$ids[] = $reply->profile_id;
|
|
|
|
}
|
|
|
|
$notice->_setReplies($ids);
|
|
|
|
}
|
|
|
|
}
|
2011-08-22 17:39:37 +01:00
|
|
|
|
2014-06-04 23:29:43 +01:00
|
|
|
protected $_repeats = array();
|
2011-08-22 17:39:37 +01:00
|
|
|
|
|
|
|
function getRepeats()
|
|
|
|
{
|
2014-06-04 23:29:43 +01:00
|
|
|
if (isset($this->_repeats[$this->id])) {
|
|
|
|
return $this->_repeats[$this->id];
|
2011-08-22 17:39:37 +01:00
|
|
|
}
|
2013-08-18 20:02:33 +01:00
|
|
|
$repeatMap = Notice::listGet('repeat_of', array($this->id));
|
2014-06-04 23:29:43 +01:00
|
|
|
$this->_repeats[$this->id] = $repeatMap[$this->id];
|
|
|
|
return $this->_repeats[$this->id];
|
2011-08-22 17:39:37 +01:00
|
|
|
}
|
|
|
|
|
2011-08-23 17:39:05 +01:00
|
|
|
function _setRepeats($repeats)
|
2011-08-22 17:39:37 +01:00
|
|
|
{
|
2014-06-04 23:29:43 +01:00
|
|
|
$this->_repeats[$this->id] = $repeats;
|
2011-08-22 17:39:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static function fillRepeats(&$notices)
|
|
|
|
{
|
|
|
|
$ids = self::_idsOf($notices);
|
2013-08-18 20:02:33 +01:00
|
|
|
$repeatMap = Notice::listGet('repeat_of', $ids);
|
2011-08-22 17:39:37 +01:00
|
|
|
foreach ($notices as $notice) {
|
2011-08-23 05:40:54 +01:00
|
|
|
$repeats = $repeatMap[$notice->id];
|
2011-08-23 17:52:48 +01:00
|
|
|
$notice->_setRepeats($repeats);
|
2011-08-22 17:39:37 +01:00
|
|
|
}
|
|
|
|
}
|
2008-05-07 18:15:42 +01:00
|
|
|
}
|