gnu-social/classes/Notice.php

1404 lines
46 KiB
PHP
Raw Normal View History

<?php
2009-10-03 23:14:26 +01:00
/**
2009-08-25 23:14:12 +01:00
* StatusNet - the distributed open-source microblogging tool
* Copyright (C) 2008, 2009, StatusNet, Inc.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* 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>
* @license GNU Affero General Public License http://www.gnu.org/licenses/
*/
2009-10-04 01:34:40 +01:00
if (!defined('STATUSNET') && !defined('LACONICA')) {
exit(1);
2009-10-03 23:14:26 +01:00
}
/**
2009-10-04 01:34:40 +01:00
* Table Definition for notice
*/
require_once INSTALLDIR.'/classes/Memcached_DataObject.php';
/* We keep the first three 20-notice pages, plus one for pagination check,
* in the memcached cache. */
define('NOTICE_CACHE_WINDOW', 61);
2009-06-26 08:47:27 +01:00
define('MAX_BOXCARS', 128);
class Notice extends Memcached_DataObject
{
###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
public $uri; // varchar(255) unique_key
2009-12-11 15:22:56 +00:00
public $content; // text
public $rendered; // text
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)
public $is_local; // tinyint(1)
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)
2009-10-04 01:34:40 +01:00
/* Static get */
2009-12-11 15:22:56 +00:00
function staticGet($k,$v=NULL)
{
2009-09-15 23:28:44 +01:00
return Memcached_DataObject::staticGet('Notice',$k,$v);
}
2009-10-04 01:34:40 +01:00
/* the code above is auto generated do not remove the tag below */
###END_AUTOCODE
2009-10-04 01:34:40 +01:00
/* Notice types */
const LOCAL_PUBLIC = 1;
const REMOTE_OMB = 0;
const LOCAL_NONPUBLIC = -1;
const GATEWAY = -2;
2009-10-04 01:34:40 +01:00
function getProfile()
{
return Profile::staticGet('id', $this->profile_id);
}
2009-10-04 01:34:40 +01:00
function delete()
{
$this->blowCaches(true);
$this->blowFavesCache(true);
$this->blowSubsCache(true);
2009-10-04 01:34:40 +01: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
2009-07-16 05:52:23 +01:00
$deleted = new Deleted_notice();
2009-10-04 01:34:40 +01:00
2009-07-16 05:52:23 +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
$this->query('BEGIN');
2009-10-04 01:34:40 +01:00
2009-07-16 05:52:23 +01:00
$deleted->insert();
2009-10-04 01:34:40 +01:00
//Null any notices that are replies to this notice
$this->query(sprintf("UPDATE notice set reply_to = null WHERE reply_to = %d", $this->id));
//Null any notices that are repeats of this notice
//XXX: probably need to uncache these, too
$this->query(sprintf("UPDATE notice set repeat_of = null WHERE repeat_of = %d", $this->id));
$related = array('Reply',
'Fave',
'Notice_tag',
'Group_inbox',
2009-10-13 22:38:27 +01:00
'Queue_item',
'Notice_inbox');
foreach ($related as $cls) {
$inst = new $cls();
$inst->notice_id = $this->id;
$inst->delete();
}
$result = parent::delete();
$this->query('COMMIT');
}
2009-10-04 01:34:40 +01:00
function saveTags()
{
/* extract all #hastags */
2009-07-20 03:01:51 +01:00
$count = preg_match_all('/(?:^|\s)#([\pL\pN_\-\.]{1,64})/', strtolower($this->content), $match);
if (!$count) {
return true;
}
2009-10-04 01:34:40 +01:00
//turn each into their canonical tag
//this is needed to remove dupes before saving e.g. #hash.tag = #hashtag
$hashtags = array();
for($i=0; $i<count($match[1]); $i++) {
$hashtags[] = common_canonical_tag($match[1][$i]);
}
2009-10-04 01:34:40 +01:00
/* Add them to the database */
foreach(array_unique($hashtags) as $hashtag) {
/* elide characters we don't want in the tag */
$this->saveTag($hashtag);
}
return true;
}
2009-10-04 01:34:40 +01: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
if (!$id) {
throw new ServerException(sprintf(_('DB error inserting hashtag: %s'),
$last_error->message));
return;
}
}
2009-10-04 01:34:40 +01:00
static function saveNew($profile_id, $content, $source, $options=null) {
$defaults = array('uri' => null,
'reply_to' => null,
'repeat_of' => null);
if (!empty($options)) {
$options = $options + $defaults;
extract($options);
}
if (empty($is_local)) {
$is_local = Notice::LOCAL_PUBLIC;
}
2009-10-04 01:34:40 +01:00
$profile = Profile::staticGet($profile_id);
$final = common_shorten_links($content);
if (Notice::contentTooLong($final)) {
throw new ClientException(_('Problem saving notice. Too long.'));
}
if (empty($profile)) {
2009-10-04 01:34:40 +01:00
throw new ClientException(_('Problem saving notice. Unknown user.'));
}
if (common_config('throttle', 'enabled') && !Notice::checkEditThrottle($profile_id)) {
common_log(LOG_WARNING, 'Excessive posting by profile #' . $profile_id . '; throttled.');
throw new ClientException(_('Too many notices too fast; take a breather '.
'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.');
throw new ClientException(_('Too many duplicate messages too quickly;'.
' take a breather and post again in a few minutes.'));
2009-10-04 01:34:40 +01:00
}
if (!$profile->hasRight(Right::NEWNOTICE)) {
common_log(LOG_WARNING, "Attempted post from user disallowed to post: " . $profile->nickname);
2009-10-04 01:34:40 +01:00
throw new ClientException(_('You are banned from posting notices on this site.'));
}
$notice = new Notice();
$notice->profile_id = $profile_id;
$autosource = common_config('public', 'autosource');
# Sandboxed are non-false, but not 1, either
2009-10-04 01:34:40 +01: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();
}
$notice->content = $final;
$notice->rendered = common_render_content($final, $notice);
$notice->source = $source;
$notice->uri = $uri;
2009-12-11 16:51:09 +00:00
// Handle repeat case
if (isset($repeat_of)) {
$notice->repeat_of = $repeat_of;
$notice->reply_to = $repeat_of;
} else {
$notice->reply_to = self::getReplyTo($reply_to, $profile_id, $source, $final);
}
2009-10-04 01:34:40 +01:00
if (!empty($notice->reply_to)) {
$reply = Notice::staticGet('id', $notice->reply_to);
$notice->conversation = $reply->conversation;
}
if (!empty($lat) && !empty($lon)) {
$notice->lat = $lat;
$notice->lon = $lon;
$notice->location_id = $location_id;
$notice->location_ns = $location_ns;
} else if (!empty($location_ns) && !empty($location_id)) {
$location = Location::fromId($location_id, $location_ns);
if (!empty($location)) {
$notice->lat = $location->lat;
$notice->lon = $location->lon;
$notice->location_id = $location_id;
$notice->location_ns = $location_ns;
}
} else {
$notice->lat = $profile->lat;
$notice->lon = $profile->lon;
$notice->location_id = $profile->location_id;
$notice->location_ns = $profile->location_ns;
}
2009-10-04 01:34:40 +01:00
if (Event::handle('StartNoticeSave', array(&$notice))) {
// XXX: some of these functions write to the DB
2009-10-04 01:34:40 +01:00
$notice->query('BEGIN');
$id = $notice->insert();
if (!$id) {
common_log_db_error($notice, 'INSERT', __FILE__);
throw new ServerException(_('Problem saving notice.'));
}
// Update ID-dependent columns: URI, conversation
2009-10-04 01:34:40 +01:00
$orig = clone($notice);
$changed = false;
if (empty($uri)) {
$notice->uri = common_notice_uri($notice);
$changed = true;
}
// 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)) {
$notice->conversation = $notice->id;
$changed = true;
}
if ($changed) {
if (!$notice->update($orig)) {
common_log_db_error($notice, 'UPDATE', __FILE__);
throw new ServerException(_('Problem saving notice.'));
}
}
// XXX: do we need to change this for remote users?
2009-10-04 01:34:40 +01:00
$notice->saveTags();
$notice->addToInboxes();
$notice->saveUrls();
$notice->query('COMMIT');
Event::handle('EndNoticeSave', array($notice));
}
# Clear the cache for subscribed users, so they'll update at next request
# XXX: someone clever could prepend instead of clearing the cache
2009-10-04 01:34:40 +01:00
$notice->blowCaches();
return $notice;
}
/** 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() {
common_replace_urls_callback($this->content, array($this, 'saveUrl'), $this->id);
}
function saveUrl($data) {
list($url, $notice_id) = $data;
File::processNew($url, $notice_id);
}
2009-10-04 01:34:40 +01:00
static function checkDupes($profile_id, $content) {
$profile = Profile::staticGet($profile_id);
if (empty($profile)) {
return false;
}
$notice = $profile->getNotices(0, NOTICE_CACHE_WINDOW);
if (!empty($notice)) {
$last = 0;
while ($notice->fetch()) {
if (time() - strtotime($notice->created) >= common_config('site', 'dupelimit')) {
return true;
} else if ($notice->content == $content) {
return false;
}
}
}
# If we get here, oldest item in cache window is not
# old enough for dupe limit; do direct check against DB
$notice = new Notice();
$notice->profile_id = $profile_id;
$notice->content = $content;
if (common_config('db','type') == 'pgsql')
2009-10-04 01:34:40 +01:00
$notice->whereAdd('extract(epoch from now() - created) < ' . common_config('site', 'dupelimit'));
else
2009-10-04 01:34:40 +01:00
$notice->whereAdd('now() - created < ' . common_config('site', 'dupelimit'));
$cnt = $notice->count();
return ($cnt == 0);
}
2009-10-04 01:34:40 +01:00
static function checkEditThrottle($profile_id) {
$profile = Profile::staticGet($profile_id);
if (empty($profile)) {
return false;
}
# Get the Nth notice
$notice = $profile->getNotices(common_config('throttle', 'count') - 1, 1);
if ($notice && $notice->fetch()) {
# If the Nth notice was posted less than timespan seconds ago
if (time() - strtotime($notice->created) <= common_config('throttle', 'timespan')) {
# Then we throttle
return false;
}
}
# Either not N notices in the stream, OR the Nth was not posted within timespan seconds
return true;
}
2009-10-04 01:34:40 +01:00
function getUploadedAttachment() {
$post = clone $this;
$query = 'select file.url as up, file.id as i from file join file_to_post on file.id = file_id where post_id=' . $post->escape($post->id) . ' and url like "%/notice/%/file"';
$post->query($query);
$post->fetch();
if (empty($post->up) || empty($post->i)) {
$ret = false;
} else {
$ret = array($post->up, $post->i);
}
$post->free();
return $ret;
}
2009-10-04 01:34:40 +01:00
function hasAttachments() {
$post = clone $this;
$query = "select count(file_id) as n_attachments from file join file_to_post on (file_id = file.id) join notice on (post_id = notice.id) where post_id = " . $post->escape($post->id);
$post->query($query);
$post->fetch();
$n_attachments = intval($post->n_attachments);
$post->free();
return $n_attachments;
}
2009-10-04 01:34:40 +01:00
2009-06-25 19:08:32 +01:00
function attachments() {
// XXX: cache this
$att = array();
$f2p = new File_to_post;
$f2p->post_id = $this->id;
if ($f2p->find()) {
while ($f2p->fetch()) {
$f = File::staticGet($f2p->file_id);
$att[] = clone($f);
}
}
return $att;
}
2009-10-04 01:34:40 +01:00
function blowCaches($blowLast=false)
{
$this->blowSubsCache($blowLast);
$this->blowNoticeCache($blowLast);
$this->blowRepliesCache($blowLast);
$this->blowPublicCache($blowLast);
$this->blowTagCache($blowLast);
$this->blowGroupCache($blowLast);
$this->blowConversationCache($blowLast);
2009-12-12 19:46:24 +00:00
$this->blowRepeatCache();
$profile = Profile::staticGet($this->profile_id);
$profile->blowNoticeCount();
}
2009-10-04 01:34:40 +01:00
2009-12-12 19:46:24 +00:00
function blowRepeatCache()
{
if (!empty($this->repeat_of)) {
$cache = common_memcache();
if (!empty($cache)) {
// XXX: only blow if <100 in cache
$ck = common_cache_key('notice:repeats:'.$this->repeat_of);
$result = $cache->delete($ck);
$user = User::staticGet('id', $this->profile_id);
if (!empty($user)) {
$uk = common_cache_key('user:repeated_by_me:'.$user->id);
$cache->delete($uk);
$user->free();
unset($user);
}
2009-12-12 21:00:27 +00:00
$original = Notice::staticGet('id', $this->repeat_of);
if (!empty($original)) {
$originalUser = User::staticGet('id', $original->profile_id);
if (!empty($originalUser)) {
$ouk = common_cache_key('user:repeats_of_me:'.$originalUser->id);
$cache->delete($ouk);
$originalUser->free();
unset($originalUser);
}
$original->free();
unset($original);
}
2009-12-12 21:15:23 +00:00
$ni = new Notice_inbox();
$ni->notice_id = $this->id;
if ($ni->find()) {
while ($ni->fetch()) {
$tmk = common_cache_key('user:repeated_to_me:'.$ni->user_id);
$cache->delete($tmk);
}
}
$ni->free();
unset($ni);
2009-12-12 19:46:24 +00:00
}
}
}
function blowConversationCache($blowLast=false)
{
$cache = common_memcache();
if ($cache) {
2009-06-25 19:23:47 +01:00
$ck = common_cache_key('notice:conversation_ids:'.$this->conversation);
$cache->delete($ck);
if ($blowLast) {
$cache->delete($ck.';last');
}
}
}
2009-10-04 01:34:40 +01:00
function blowGroupCache($blowLast=false)
{
$cache = common_memcache();
if ($cache) {
$group_inbox = new Group_inbox();
$group_inbox->notice_id = $this->id;
if ($group_inbox->find()) {
while ($group_inbox->fetch()) {
2009-05-01 19:38:50 +01:00
$cache->delete(common_cache_key('user_group:notice_ids:' . $group_inbox->group_id));
if ($blowLast) {
2009-05-01 19:38:50 +01:00
$cache->delete(common_cache_key('user_group:notice_ids:' . $group_inbox->group_id.';last'));
}
$member = new Group_member();
$member->group_id = $group_inbox->group_id;
if ($member->find()) {
while ($member->fetch()) {
$cache->delete(common_cache_key('notice_inbox:by_user:' . $member->profile_id));
$cache->delete(common_cache_key('notice_inbox:by_user_own:' . $member->profile_id));
if (empty($this->repeat_of)) {
$cache->delete(common_cache_key('user:friends_timeline:' . $member->profile_id));
$cache->delete(common_cache_key('user:friends_timeline_own:' . $member->profile_id));
}
if ($blowLast) {
$cache->delete(common_cache_key('notice_inbox:by_user:' . $member->profile_id . ';last'));
$cache->delete(common_cache_key('notice_inbox:by_user_own:' . $member->profile_id . ';last'));
if (empty($this->repeat_of)) {
$cache->delete(common_cache_key('user:friends_timeline:' . $member->profile_id . ';last'));
$cache->delete(common_cache_key('user:friends_timeline_own:' . $member->profile_id . ';last'));
}
}
}
}
}
}
$group_inbox->free();
unset($group_inbox);
}
}
2009-10-04 01:34:40 +01:00
function blowTagCache($blowLast=false)
{
$cache = common_memcache();
if ($cache) {
$tag = new Notice_tag();
$tag->notice_id = $this->id;
if ($tag->find()) {
while ($tag->fetch()) {
2009-04-29 21:09:03 +01:00
$tag->blowCache($blowLast);
$ck = 'profile:notice_ids_tagged:' . $this->profile_id . ':' . $tag->tag;
2009-10-04 01:34:40 +01:00
$cache->delete($ck);
if ($blowLast) {
$cache->delete($ck . ';last');
}
}
}
$tag->free();
unset($tag);
}
}
2009-10-04 01:34:40 +01:00
function blowSubsCache($blowLast=false)
{
$cache = common_memcache();
if ($cache) {
$user = new User();
2009-10-04 01:34:40 +01:00
$UT = common_config('db','type')=='pgsql'?'"user"':'user';
$user->query('SELECT id ' .
2009-10-04 01:34:40 +01:00
"FROM $UT JOIN subscription ON $UT.id = subscription.subscriber " .
'WHERE subscription.subscribed = ' . $this->profile_id);
2009-10-04 01:34:40 +01:00
while ($user->fetch()) {
$cache->delete(common_cache_key('notice_inbox:by_user:'.$user->id));
$cache->delete(common_cache_key('notice_inbox:by_user_own:'.$user->id));
if (empty($this->repeat_of)) {
$cache->delete(common_cache_key('user:friends_timeline:'.$user->id));
$cache->delete(common_cache_key('user:friends_timeline_own:'.$user->id));
}
if ($blowLast) {
$cache->delete(common_cache_key('notice_inbox:by_user:'.$user->id.';last'));
$cache->delete(common_cache_key('notice_inbox:by_user_own:'.$user->id.';last'));
if (empty($this->repeat_of)) {
$cache->delete(common_cache_key('user:friends_timeline:'.$user->id.';last'));
$cache->delete(common_cache_key('user:friends_timeline_own:'.$user->id.';last'));
}
}
}
$user->free();
unset($user);
}
}
2009-10-04 01:34:40 +01:00
function blowNoticeCache($blowLast=false)
{
if ($this->is_local) {
$cache = common_memcache();
2009-05-01 19:27:57 +01:00
if (!empty($cache)) {
$cache->delete(common_cache_key('profile:notice_ids:'.$this->profile_id));
if ($blowLast) {
2009-05-01 19:27:57 +01:00
$cache->delete(common_cache_key('profile:notice_ids:'.$this->profile_id.';last'));
}
}
}
}
2009-10-04 01:34:40 +01:00
function blowRepliesCache($blowLast=false)
{
$cache = common_memcache();
if ($cache) {
$reply = new Reply();
$reply->notice_id = $this->id;
if ($reply->find()) {
while ($reply->fetch()) {
2009-04-30 01:45:33 +01:00
$cache->delete(common_cache_key('reply:stream:'.$reply->profile_id));
if ($blowLast) {
2009-04-30 01:45:33 +01:00
$cache->delete(common_cache_key('reply:stream:'.$reply->profile_id.';last'));
}
}
}
$reply->free();
unset($reply);
}
}
2009-10-04 01:34:40 +01:00
function blowPublicCache($blowLast=false)
{
if ($this->is_local == Notice::LOCAL_PUBLIC) {
$cache = common_memcache();
if ($cache) {
$cache->delete(common_cache_key('public'));
if ($blowLast) {
$cache->delete(common_cache_key('public').';last');
}
}
}
}
2009-10-04 01:34:40 +01:00
function blowFavesCache($blowLast=false)
{
$cache = common_memcache();
if ($cache) {
$fave = new Fave();
$fave->notice_id = $this->id;
if ($fave->find()) {
while ($fave->fetch()) {
2009-05-01 20:01:28 +01:00
$cache->delete(common_cache_key('fave:ids_by_user:'.$fave->user_id));
$cache->delete(common_cache_key('fave:by_user_own:'.$fave->user_id));
if ($blowLast) {
2009-05-01 20:01:28 +01:00
$cache->delete(common_cache_key('fave:ids_by_user:'.$fave->user_id.';last'));
$cache->delete(common_cache_key('fave:by_user_own:'.$fave->user_id.';last'));
}
}
}
$fave->free();
unset($fave);
}
}
2009-10-04 01:34:40 +01:00
function getStreamByIds($ids)
{
$cache = common_memcache();
2009-10-04 01:34:40 +01:00
if (!empty($cache)) {
$notices = array();
foreach ($ids as $id) {
$n = Notice::staticGet('id', $id);
if (!empty($n)) {
$notices[] = $n;
}
}
return new ArrayWrapper($notices);
} else {
$notice = new Notice();
if (empty($ids)) {
//if no IDs requested, just return the notice object
return $notice;
}
$notice->whereAdd('id in (' . implode(', ', $ids) . ')');
2009-10-04 01:34:40 +01:00
$notice->find();
$temp = array();
while ($notice->fetch()) {
$temp[$notice->id] = clone($notice);
}
$wrapped = array();
foreach ($ids as $id) {
if (array_key_exists($id, $temp)) {
$wrapped[] = $temp[$id];
}
}
return new ArrayWrapper($wrapped);
}
}
2009-10-04 01:34:40 +01:00
function publicStream($offset=0, $limit=20, $since_id=0, $max_id=0, $since=null)
{
$ids = Notice::stream(array('Notice', '_publicStreamDirect'),
array(),
'public',
$offset, $limit, $since_id, $max_id, $since);
2009-10-04 01:34:40 +01:00
return Notice::getStreamByIds($ids);
}
2009-10-04 01:34:40 +01:00
function _publicStreamDirect($offset=0, $limit=20, $since_id=0, $max_id=0, $since=null)
{
$notice = new Notice();
2009-10-04 01:34:40 +01:00
$notice->selectAdd(); // clears it
$notice->selectAdd('id');
2009-10-04 01:34:40 +01:00
$notice->orderBy('id DESC');
2009-10-04 01:34:40 +01:00
if (!is_null($offset)) {
$notice->limit($offset, $limit);
}
2009-10-04 01:34:40 +01:00
if (common_config('public', 'localonly')) {
$notice->whereAdd('is_local = ' . Notice::LOCAL_PUBLIC);
} else {
# -1 == blacklisted, -2 == gateway (i.e. Twitter)
$notice->whereAdd('is_local !='. Notice::LOCAL_NONPUBLIC);
$notice->whereAdd('is_local !='. Notice::GATEWAY);
}
2009-10-04 01:34:40 +01:00
if ($since_id != 0) {
$notice->whereAdd('id > ' . $since_id);
}
2009-10-04 01:34:40 +01:00
if ($max_id != 0) {
$notice->whereAdd('id <= ' . $max_id);
}
2009-10-04 01:34:40 +01:00
if (!is_null($since)) {
$notice->whereAdd('created > \'' . date('Y-m-d H:i:s', $since) . '\'');
}
2009-10-04 01:34:40 +01:00
$ids = array();
2009-10-04 01:34:40 +01:00
if ($notice->find()) {
while ($notice->fetch()) {
$ids[] = $notice->id;
}
}
2009-10-04 01:34:40 +01:00
$notice->free();
$notice = NULL;
2009-10-04 01:34:40 +01:00
return $ids;
}
2009-10-04 01:34:40 +01:00
function conversationStream($id, $offset=0, $limit=20, $since_id=0, $max_id=0, $since=null)
{
$ids = Notice::stream(array('Notice', '_conversationStreamDirect'),
array($id),
'notice:conversation_ids:'.$id,
$offset, $limit, $since_id, $max_id, $since);
2009-10-04 01:34:40 +01:00
return Notice::getStreamByIds($ids);
}
2009-10-04 01:34:40 +01:00
function _conversationStreamDirect($id, $offset=0, $limit=20, $since_id=0, $max_id=0, $since=null)
{
$notice = new Notice();
2009-10-04 01:34:40 +01:00
$notice->selectAdd(); // clears it
$notice->selectAdd('id');
2009-10-04 01:34:40 +01:00
2009-06-30 16:50:16 +01:00
$notice->conversation = $id;
2009-10-04 01:34:40 +01:00
$notice->orderBy('id DESC');
2009-10-04 01:34:40 +01:00
if (!is_null($offset)) {
$notice->limit($offset, $limit);
}
2009-10-04 01:34:40 +01:00
if ($since_id != 0) {
$notice->whereAdd('id > ' . $since_id);
}
2009-10-04 01:34:40 +01:00
if ($max_id != 0) {
$notice->whereAdd('id <= ' . $max_id);
}
2009-10-04 01:34:40 +01:00
if (!is_null($since)) {
$notice->whereAdd('created > \'' . date('Y-m-d H:i:s', $since) . '\'');
}
2009-10-04 01:34:40 +01:00
$ids = array();
2009-10-04 01:34:40 +01:00
if ($notice->find()) {
while ($notice->fetch()) {
$ids[] = $notice->id;
}
}
2009-10-04 01:34:40 +01:00
$notice->free();
$notice = NULL;
2009-10-04 01:34:40 +01:00
return $ids;
}
2009-10-04 01:34:40 +01:00
function addToInboxes()
{
2009-10-13 22:38:27 +01:00
// XXX: loads constants
2009-10-04 01:34:40 +01:00
2009-10-13 22:38:27 +01:00
$inbox = new Notice_inbox();
2009-10-04 01:34:40 +01:00
2009-10-13 22:38:27 +01:00
$users = $this->getSubscribedUsers();
2009-10-04 01:34:40 +01:00
2009-10-13 22:38:27 +01:00
// FIXME: kind of ignoring 'transitional'...
// we'll probably stop supporting inboxless mode
// in 0.9.x
2009-10-04 01:34:40 +01:00
2009-10-13 22:38:27 +01:00
$ni = array();
2009-10-04 01:34:40 +01:00
2009-10-13 22:38:27 +01:00
foreach ($users as $id) {
$ni[$id] = NOTICE_INBOX_SOURCE_SUB;
}
2009-10-04 01:34:40 +01:00
2009-10-13 22:38:27 +01:00
$groups = $this->saveGroups();
$profile = $this->getProfile();
2009-10-04 01:34:40 +01:00
2009-10-13 22:38:27 +01:00
foreach ($groups as $group) {
$users = $group->getUserMembers();
foreach ($users as $id) {
2009-10-13 22:38:27 +01:00
if (!array_key_exists($id, $ni)) {
$user = User::staticGet('id', $id);
if (!$user->hasBlocked($profile)) {
$ni[$id] = NOTICE_INBOX_SOURCE_GROUP;
}
2009-06-26 08:47:27 +01:00
}
}
2009-10-13 22:38:27 +01:00
}
2009-10-04 01:34:40 +01:00
2009-10-28 19:33:10 +00:00
$recipients = $this->saveReplies();
foreach ($recipients as $recipient) {
if (!array_key_exists($recipient, $ni)) {
$recipientUser = User::staticGet('id', $recipient);
if (!empty($recipientUser)) {
$ni[$recipient] = NOTICE_INBOX_SOURCE_REPLY;
}
}
}
Notice_inbox::bulkInsert($this->id, $this->created, $ni);
2009-10-13 22:38:27 +01:00
return;
}
2009-10-04 01:34:40 +01:00
function getSubscribedUsers()
{
$user = new User();
2009-10-04 01:34:40 +01:00
if(common_config('db','quote_identifiers'))
2009-10-04 01:34:40 +01:00
$user_table = '"user"';
else $user_table = 'user';
2009-10-04 01:34:40 +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 ';
$user->query(sprintf($qry, $this->profile_id));
2009-10-04 01:34:40 +01:00
$ids = array();
2009-10-04 01:34:40 +01:00
while ($user->fetch()) {
$ids[] = $user->id;
}
2009-10-04 01:34:40 +01:00
$user->free();
2009-10-04 01:34:40 +01:00
return $ids;
}
2009-10-04 01:34:40 +01:00
function saveGroups()
{
2009-06-26 08:47:27 +01:00
$groups = array();
2009-10-04 01:34:40 +01:00
/* extract all !group */
$count = preg_match_all('/(?:^|\s)!([A-Za-z0-9]{1,64})/',
strtolower($this->content),
$match);
if (!$count) {
2009-06-26 08:47:27 +01:00
return $groups;
}
2009-10-04 01:34:40 +01:00
$profile = $this->getProfile();
2009-10-04 01:34:40 +01:00
/* Add them to the database */
2009-10-04 01:34:40 +01:00
foreach (array_unique($match[1]) as $nickname) {
/* XXX: remote groups. */
$group = User_group::getForNickname($nickname);
2009-10-04 01:34:40 +01:00
if (empty($group)) {
continue;
}
2009-10-04 01:34:40 +01:00
// we automatically add a tag for every group name, too
2009-10-04 01:34:40 +01:00
$tag = Notice_tag::pkeyGet(array('tag' => common_canonical_tag($nickname),
'notice_id' => $this->id));
2009-10-04 01:34:40 +01:00
if (is_null($tag)) {
$this->saveTag($nickname);
}
2009-10-04 01:34:40 +01:00
if ($profile->isMember($group)) {
2009-10-04 01:34:40 +01:00
$result = $this->addToGroupInbox($group);
2009-10-04 01:34:40 +01:00
if (!$result) {
common_log_db_error($gi, 'INSERT', __FILE__);
}
2009-10-04 01:34:40 +01:00
2009-06-26 08:47:27 +01:00
$groups[] = clone($group);
}
}
2009-10-04 01:34:40 +01:00
2009-06-26 08:47:27 +01:00
return $groups;
}
2009-10-04 01:34:40 +01:00
function addToGroupInbox($group)
{
$gi = Group_inbox::pkeyGet(array('group_id' => $group->id,
'notice_id' => $this->id));
2009-10-04 01:34:40 +01:00
if (empty($gi)) {
2009-10-04 01:34:40 +01:00
$gi = new Group_inbox();
2009-10-04 01:34:40 +01:00
$gi->group_id = $group->id;
$gi->notice_id = $this->id;
$gi->created = $this->created;
2009-10-04 01:34:40 +01:00
return $gi->insert();
}
2009-10-04 01:34:40 +01:00
return true;
}
2009-10-04 01:34:40 +01:00
/**
* @return array of integer profile IDs
*/
function saveReplies()
{
// Alternative reply format
$tname = false;
if (preg_match('/^T ([A-Z0-9]{1,64}) /', $this->content, $match)) {
$tname = $match[1];
}
// extract all @messages
$cnt = preg_match_all('/(?:^|\s)@([a-z0-9]{1,64})/', $this->content, $match);
2009-10-04 01:34:40 +01:00
$names = array();
2009-10-04 01:34:40 +01:00
if ($cnt || $tname) {
// XXX: is there another way to make an array copy?
$names = ($tname) ? array_unique(array_merge(array(strtolower($tname)), $match[1])) : array_unique($match[1]);
}
2009-10-04 01:34:40 +01:00
$sender = Profile::staticGet($this->profile_id);
2009-10-04 01:34:40 +01:00
$replied = array();
2009-10-04 01:34:40 +01: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
for ($i=0; $i<count($names); $i++) {
$nickname = $names[$i];
$recipient = common_relative_profile($sender, $nickname, $this->created);
if (empty($recipient)) {
continue;
}
// Don't save replies from blocked profile to local user
$recipient_user = User::staticGet('id', $recipient->id);
if (!empty($recipient_user) && $recipient_user->hasBlocked($sender)) {
continue;
}
$reply = new Reply();
$reply->notice_id = $this->id;
$reply->profile_id = $recipient->id;
$id = $reply->insert();
if (!$id) {
$last_error = &PEAR::getStaticProperty('DB_DataObject','lastError');
common_log(LOG_ERR, 'DB error inserting reply: ' . $last_error->message);
common_server_error(sprintf(_('DB error inserting reply: %s'), $last_error->message));
2009-10-28 19:33:10 +00:00
return array();
} else {
$replied[$recipient->id] = 1;
}
}
2009-10-04 01:34:40 +01:00
// Hash format replies, too
$cnt = preg_match_all('/(?:^|\s)@#([a-z0-9]{1,64})/', $this->content, $match);
if ($cnt) {
foreach ($match[1] as $tag) {
$tagged = Profile_tag::getTagged($sender->id, $tag);
foreach ($tagged as $t) {
if (!$replied[$t->id]) {
// Don't save replies from blocked profile to local user
$t_user = User::staticGet('id', $t->id);
if ($t_user && $t_user->hasBlocked($sender)) {
continue;
}
$reply = new Reply();
$reply->notice_id = $this->id;
$reply->profile_id = $t->id;
$id = $reply->insert();
if (!$id) {
common_log_db_error($reply, 'INSERT', __FILE__);
2009-10-28 19:33:10 +00:00
return array();
2009-02-16 23:26:15 +00:00
} else {
$replied[$recipient->id] = 1;
}
}
}
}
}
2009-10-04 01:34:40 +01:00
2009-10-28 19:33:10 +00:00
$recipientIds = array_keys($replied);
foreach ($recipientIds as $recipientId) {
$user = User::staticGet('id', $recipientId);
2009-02-16 23:26:15 +00:00
if ($user) {
2009-02-16 23:45:59 +00:00
mail_notify_attn($user, $this);
2009-02-16 23:26:15 +00:00
}
}
2009-10-28 19:33:10 +00:00
return $recipientIds;
}
2009-10-04 01:34:40 +01:00
function asAtomEntry($namespace=false, $source=false)
{
$profile = $this->getProfile();
2009-10-04 01:34:40 +01:00
$xs = new XMLStringer(true);
2009-10-04 01:34:40 +01:00
if ($namespace) {
$attrs = array('xmlns' => 'http://www.w3.org/2005/Atom',
'xmlns:thr' => 'http://purl.org/syndication/thread/1.0');
} else {
$attrs = array();
}
2009-10-04 01:34:40 +01:00
$xs->elementStart('entry', $attrs);
2009-10-04 01:34:40 +01:00
if ($source) {
$xs->elementStart('source');
$xs->element('title', null, $profile->nickname . " - " . common_config('site', 'name'));
$xs->element('link', array('href' => $profile->profileurl));
$user = User::staticGet('id', $profile->id);
if (!empty($user)) {
$atom_feed = common_local_url('ApiTimelineUser',
array('format' => 'atom',
'id' => $profile->nickname));
$xs->element('link', array('rel' => 'self',
'type' => 'application/atom+xml',
'href' => $profile->profileurl));
$xs->element('link', array('rel' => 'license',
'href' => common_config('license', 'url')));
}
2009-10-04 01:34:40 +01:00
$xs->element('icon', null, $profile->avatarUrl(AVATAR_PROFILE_SIZE));
}
2009-10-04 01:34:40 +01:00
$xs->elementStart('author');
$xs->element('name', null, $profile->nickname);
$xs->element('uri', null, $profile->profileurl);
$xs->elementEnd('author');
2009-10-04 01:34:40 +01:00
if ($source) {
$xs->elementEnd('source');
}
2009-10-04 01:34:40 +01:00
$xs->element('title', null, $this->content);
$xs->element('summary', null, $this->content);
2009-10-04 01:34:40 +01:00
$xs->element('link', array('rel' => 'alternate',
'href' => $this->bestUrl()));
2009-10-04 01:34:40 +01:00
$xs->element('id', null, $this->uri);
2009-10-04 01:34:40 +01:00
$xs->element('published', null, common_date_w3dtf($this->created));
$xs->element('updated', null, common_date_w3dtf($this->modified));
2009-10-04 01:34:40 +01:00
if ($this->reply_to) {
$reply_notice = Notice::staticGet('id', $this->reply_to);
if (!empty($reply_notice)) {
$xs->element('link', array('rel' => 'related',
'href' => $reply_notice->bestUrl()));
$xs->element('thr:in-reply-to',
array('ref' => $reply_notice->uri,
'href' => $reply_notice->bestUrl()));
}
}
2009-10-04 01:34:40 +01:00
$xs->element('content', array('type' => 'html'), $this->rendered);
2009-10-04 01:34:40 +01:00
$tag = new Notice_tag();
$tag->notice_id = $this->id;
if ($tag->find()) {
while ($tag->fetch()) {
$xs->element('category', array('term' => $tag->tag));
}
}
$tag->free();
2009-10-04 01:34:40 +01:00
# Enclosures
$attachments = $this->attachments();
if($attachments){
foreach($attachments as $attachment){
$enclosure=$attachment->getEnclosure();
if ($enclosure) {
$attributes = array('rel'=>'enclosure','href'=>$enclosure->url,'type'=>$enclosure->mimetype,'length'=>$enclosure->size);
if($enclosure->title){
$attributes['title']=$enclosure->title;
}
$xs->element('link', $attributes, null);
}
}
}
2009-10-04 01:34:40 +01:00
if (!empty($this->lat) && !empty($this->lon)) {
$xs->elementStart('geo', array('xmlns:georss' => 'http://www.georss.org/georss'));
$xs->element('georss:point', null, $this->lat . ' ' . $this->lon);
$xs->elementEnd('geo');
}
$xs->elementEnd('entry');
2009-10-04 01:34:40 +01:00
return $xs->getString();
}
2009-10-04 01:34:40 +01:00
function bestUrl()
{
if (!empty($this->url)) {
return $this->url;
} else if (!empty($this->uri) && preg_match('/^https?:/', $this->uri)) {
return $this->uri;
} else {
return common_local_url('shownotice',
array('notice' => $this->id));
}
}
2009-10-04 01:34:40 +01:00
function stream($fn, $args, $cachekey, $offset=0, $limit=20, $since_id=0, $max_id=0, $since=null)
{
$cache = common_memcache();
2009-10-04 01:34:40 +01:00
if (empty($cache) ||
2009-05-30 05:49:14 +01:00
$since_id != 0 || $max_id != 0 || (!is_null($since) && $since > 0) ||
2009-07-03 15:40:23 +01:00
is_null($limit) ||
($offset + $limit) > NOTICE_CACHE_WINDOW) {
2009-10-04 01:34:40 +01:00
return call_user_func_array($fn, array_merge($args, array($offset, $limit, $since_id,
$max_id, $since)));
}
$idkey = common_cache_key($cachekey);
2009-10-04 01:34:40 +01:00
$idstr = $cache->get($idkey);
2009-10-04 01:34:40 +01:00
if (!empty($idstr)) {
// Cache hit! Woohoo!
$window = explode(',', $idstr);
$ids = array_slice($window, $offset, $limit);
return $ids;
}
2009-10-04 01:34:40 +01:00
$laststr = $cache->get($idkey.';last');
2009-10-04 01:34:40 +01:00
if (!empty($laststr)) {
$window = explode(',', $laststr);
$last_id = $window[0];
$new_ids = call_user_func_array($fn, array_merge($args, array(0, NOTICE_CACHE_WINDOW,
2009-10-04 01:34:40 +01:00
$last_id, 0, null)));
$new_window = array_merge($new_ids, $window);
2009-10-04 01:34:40 +01:00
$new_windowstr = implode(',', $new_window);
2009-10-04 01:34:40 +01:00
$result = $cache->set($idkey, $new_windowstr);
$result = $cache->set($idkey . ';last', $new_windowstr);
2009-10-04 01:34:40 +01:00
$ids = array_slice($new_window, $offset, $limit);
2009-10-04 01:34:40 +01:00
return $ids;
}
2009-10-04 01:34:40 +01:00
$window = call_user_func_array($fn, array_merge($args, array(0, NOTICE_CACHE_WINDOW,
2009-10-04 01:34:40 +01:00
0, 0, null)));
$windowstr = implode(',', $window);
2009-10-04 01:34:40 +01:00
$result = $cache->set($idkey, $windowstr);
$result = $cache->set($idkey . ';last', $windowstr);
2009-10-04 01:34:40 +01:00
$ids = array_slice($window, $offset, $limit);
2009-10-04 01:34:40 +01:00
return $ids;
}
2009-10-04 01:34:40 +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
* in the tree. Rough algorithm is:
*
* if (reply_to is set and valid) {
* return reply_to;
* } else if ((source not API or Web) and (content starts with "T NAME" or "@name ")) {
* return ID of last notice by initial @name in content;
* }
*
* Note that all @nickname instances will still be used to save "reply" records,
* so the notice shows up in the mentioned users' "replies" tab.
*
* @param integer $reply_to ID passed in by Web or API
* @param integer $profile_id ID of author
* @param string $source Source tag, like 'web' or 'gwibber'
* @param string $content Final notice content
*
* @return integer ID of replied-to notice, or null for not a reply.
*/
static function getReplyTo($reply_to, $profile_id, $source, $content)
{
static $lb = array('xmpp', 'mail', 'sms', 'omb');
2009-10-04 01:34:40 +01:00
// If $reply_to is specified, we check that it exists, and then
// return it if it does
2009-10-04 01:34:40 +01:00
if (!empty($reply_to)) {
$reply_notice = Notice::staticGet('id', $reply_to);
if (!empty($reply_notice)) {
return $reply_to;
}
}
2009-10-04 01:34:40 +01:00
// If it's not a "low bandwidth" source (one where you can't set
// a reply_to argument), we return. This is mostly web and API
// clients.
2009-10-04 01:34:40 +01:00
if (!in_array($source, $lb)) {
return null;
}
2009-10-04 01:34:40 +01:00
// Is there an initial @ or T?
2009-10-04 01:34:40 +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;
}
// Figure out who that is.
2009-10-04 01:34:40 +01:00
$sender = Profile::staticGet('id', $profile_id);
$recipient = common_relative_profile($sender, $nickname, common_sql_now());
2009-10-04 01:34:40 +01:00
if (empty($recipient)) {
return null;
}
2009-10-04 01:34:40 +01:00
// Get their last notice
2009-10-04 01:34:40 +01:00
$last = $recipient->getCurrentNotice();
2009-10-04 01:34:40 +01:00
if (!empty($last)) {
return $last->id;
}
}
2009-10-04 01:34:40 +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
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
function repeat($repeater_id, $source)
{
$author = Profile::staticGet('id', $this->profile_id);
// FIXME: truncate on long repeats...?
$content = sprintf(_('RT @%1$s %2$s'),
$author->nickname,
$this->content);
return self::saveNew($repeater_id, $content, $source,
array('repeat_of' => $this->id));
}
2009-12-12 19:46:24 +00:00
// These are supposed to be in chron order!
function repeatStream($limit=100)
{
$cache = common_memcache();
if (empty($cache)) {
$ids = $this->_repeatStreamDirect($limit);
} else {
$idstr = $cache->get(common_cache_key('notice:repeats:'.$this->id));
if (!empty($idstr)) {
$ids = explode(',', $idstr);
} else {
$ids = $this->_repeatStreamDirect(100);
$cache->set(common_cache_key('notice:repeats:'.$this->id), implode(',', $ids));
}
if ($limit < 100) {
// We do a max of 100, so slice down to limit
$ids = array_slice($ids, 0, $limit);
}
}
return Notice::getStreamByIds($ids);
}
function _repeatStreamDirect($limit)
{
$notice = new Notice();
$notice->selectAdd(); // clears it
$notice->selectAdd('id');
$notice->repeat_of = $this->id;
$notice->orderBy('created'); // NB: asc!
if (!is_null($offset)) {
$notice->limit($offset, $limit);
}
$ids = array();
if ($notice->find()) {
while ($notice->fetch()) {
$ids[] = $notice->id;
}
}
$notice->free();
$notice = NULL;
return $ids;
}
}