2008-05-07 18:15:42 +01:00
< ? php
2008-05-20 20:14:12 +01:00
/*
2008-05-14 20:26:48 +01:00
* Laconica - a distributed open - source microblogging tool
* Copyright ( C ) 2008 , Controlez - Vous , 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 />.
2008-05-14 20:26:48 +01:00
*/
2008-05-14 20:00:09 +01:00
2008-05-17 16:47:01 +01:00
if ( ! defined ( 'LACONICA' )) { exit ( 1 ); }
2008-05-14 20:00:09 +01:00
2008-05-07 18:15:42 +01:00
/**
* Table Definition for notice
*/
2008-09-26 17:18:24 +01:00
require_once INSTALLDIR . '/classes/Memcached_DataObject.php' ;
2008-05-07 18:15:42 +01:00
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
/* We keep the first three 20 - notice pages , plus one for pagination check ,
* in the memcached cache . */
define ( 'NOTICE_CACHE_WINDOW' , 61 );
2009-06-17 05:37:04 +01:00
define ( 'NOTICE_LOCAL_PUBLIC' , 1 );
define ( 'NOTICE_REMOTE_OMB' , 0 );
define ( 'NOTICE_LOCAL_NONPUBLIC' , - 1 );
define ( 'NOTICE_GATEWAY' , - 2 );
2008-11-04 05:33:59 +00:00
class Notice extends Memcached_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-02-16 23:26:15 +00:00
public $__table = 'notice' ; // table name
public $id ; // int(4) primary_key not_null
public $profile_id ; // int(4) not_null
2008-12-23 19:19:07 +00:00
public $uri ; // varchar(255) unique_key
public $content ; // varchar(140)
2009-02-16 23:26:15 +00:00
public $rendered ; // text()
2008-12-23 19:19:07 +00:00
public $url ; // varchar(255)
2009-02-16 23:26:15 +00:00
public $created ; // datetime() not_null
public $modified ; // timestamp() not_null default_CURRENT_TIMESTAMP
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)
2008-12-23 19:19:07 +00:00
/* Static get */
2009-02-16 23:26:15 +00:00
function staticGet ( $k , $v = NULL ) {
return Memcached_DataObject :: staticGet ( 'Notice' , $k , $v );
}
2008-12-23 19:19:07 +00:00
/* the code above is auto generated do not remove the tag below */
###END_AUTOCODE
2008-12-23 19:33:23 +00:00
function getProfile ()
{
2008-12-23 19:19:07 +00:00
return Profile :: staticGet ( 'id' , $this -> profile_id );
}
2008-12-23 19:33:23 +00:00
function delete ()
{
2008-12-23 19:19:07 +00:00
$this -> blowCaches ( true );
$this -> blowFavesCache ( true );
2009-01-24 18:38:40 +00:00
$this -> blowSubsCache ( true );
$this -> query ( 'BEGIN' );
2009-03-12 02:20:50 +00: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 ));
2009-01-24 18:38:40 +00:00
$related = array ( 'Reply' ,
'Fave' ,
'Notice_tag' ,
'Group_inbox' ,
'Queue_item' );
if ( common_config ( 'inboxes' , 'enabled' )) {
$related [] = 'Notice_inbox' ;
}
foreach ( $related as $cls ) {
$inst = new $cls ();
$inst -> notice_id = $this -> id ;
$inst -> delete ();
}
$result = parent :: delete ();
$this -> query ( 'COMMIT' );
2008-12-23 19:19:07 +00:00
}
2008-12-23 19:33:23 +00:00
function saveTags ()
{
2008-12-23 19:19:07 +00:00
/* extract all #hastags */
$count = preg_match_all ( '/(?:^|\s)#([A-Za-z0-9_\-\.]{1,64})/' , strtolower ( $this -> content ), $match );
if ( ! $count ) {
return true ;
}
/* Add them to the database */
foreach ( array_unique ( $match [ 1 ]) as $hashtag ) {
2009-01-26 14:03:38 +00:00
/* elide characters we don't want in the tag */
2009-02-16 23:02:31 +00:00
$this -> saveTag ( $hashtag );
2008-12-23 19:19:07 +00:00
}
return true ;
}
2009-02-16 23:02:31 +00:00
function saveTag ( $hashtag )
{
$hashtag = common_canonical_tag ( $hashtag );
$tag = new Notice_tag ();
$tag -> notice_id = $this -> id ;
$tag -> tag = $hashtag ;
$tag -> created = $this -> created ;
$id = $tag -> insert ();
if ( ! $id ) {
throw new ServerException ( sprintf ( _ ( 'DB error inserting hashtag: %s' ),
$last_error -> message ));
return ;
}
}
2009-06-10 21:52:15 +01:00
static function saveNew ( $profile_id , $content , $source = null ,
$is_local = 1 , $reply_to = null , $uri = null , $created = null ) {
2008-12-23 19:19:07 +00:00
$profile = Profile :: staticGet ( $profile_id );
2008-12-10 19:13:37 +00:00
2009-06-12 17:47:57 +01:00
$final = common_shorten_links ( $content );
if ( mb_strlen ( $final ) > 140 ) {
common_log ( LOG_INFO , 'Rejecting notice that is too long.' );
return _ ( 'Problem saving notice. Too long.' );
}
2009-03-07 17:43:50 +00:00
2008-12-10 19:13:37 +00:00
if ( ! $profile ) {
2008-12-10 18:11:23 +00:00
common_log ( LOG_ERR , 'Problem saving notice. Unknown user.' );
return _ ( 'Problem saving notice. Unknown user.' );
}
2008-11-04 05:33:59 +00:00
2008-12-10 19:43:35 +00:00
if ( common_config ( 'throttle' , 'enabled' ) && ! Notice :: checkEditThrottle ( $profile_id )) {
2008-12-10 17:47:22 +00:00
common_log ( LOG_WARNING , 'Excessive posting by profile #' . $profile_id . '; throttled.' );
2008-12-23 19:19:07 +00:00
return _ ( 'Too many notices too fast; take a breather and post again in a few minutes.' );
2008-12-10 17:47:22 +00:00
}
2009-03-07 17:43:50 +00:00
if ( common_config ( 'site' , 'dupelimit' ) > 0 && ! Notice :: checkDupes ( $profile_id , $final )) {
common_log ( LOG_WARNING , 'Dupe posting by profile #' . $profile_id . '; throttled.' );
return _ ( 'Too many duplicate messages too quickly; take a breather and post again in a few minutes.' );
}
$banned = common_config ( 'profile' , 'banned' );
2008-12-10 19:13:37 +00:00
2008-12-23 19:19:07 +00:00
if ( in_array ( $profile_id , $banned ) || in_array ( $profile -> nickname , $banned )) {
common_log ( LOG_WARNING , " Attempted post from banned user: $profile->nickname (user id = $profile_id ). " );
2008-12-10 19:13:37 +00:00
return _ ( 'You are banned from posting notices on this site.' );
2008-12-23 19:19:07 +00:00
}
2008-12-10 19:13:37 +00:00
2008-12-23 19:19:07 +00:00
$notice = new Notice ();
$notice -> profile_id = $profile_id ;
2008-12-02 18:42:58 +00:00
2008-12-23 19:19:07 +00:00
$blacklist = common_config ( 'public' , 'blacklist' );
2009-02-15 02:55:25 +00:00
$autosource = common_config ( 'public' , 'autosource' );
2008-12-02 18:42:58 +00:00
2008-12-23 19:19:07 +00:00
# Blacklisted are non-false, but not 1, either
2008-12-02 18:42:58 +00:00
2009-02-15 02:55:25 +00:00
if (( $blacklist && in_array ( $profile_id , $blacklist )) ||
( $source && $autosource && in_array ( $source , $autosource ))) {
2008-12-23 19:19:07 +00:00
$notice -> is_local = - 1 ;
} else {
$notice -> is_local = $is_local ;
}
2008-12-02 18:42:58 +00:00
2009-01-20 13:19:32 +00:00
$notice -> query ( 'BEGIN' );
2008-11-04 05:33:59 +00:00
2009-03-07 17:43:50 +00:00
$notice -> reply_to = $reply_to ;
2009-06-10 21:52:15 +01:00
if ( ! empty ( $created )) {
$notice -> created = $created ;
} else {
$notice -> created = common_sql_now ();
}
2009-03-07 17:43:50 +00:00
$notice -> content = $final ;
$notice -> rendered = common_render_content ( $final , $notice );
$notice -> source = $source ;
$notice -> uri = $uri ;
2008-07-30 03:28:56 +01:00
2009-02-26 21:45:43 +00:00
if ( ! empty ( $reply_to )) {
$reply_notice = Notice :: staticGet ( 'id' , $reply_to );
if ( ! empty ( $reply_notice )) {
$notice -> reply_to = $reply_to ;
$notice -> conversation = $reply_notice -> conversation ;
}
}
2009-02-13 15:52:26 +00:00
if ( Event :: handle ( 'StartNoticeSave' , array ( & $notice ))) {
2008-07-30 03:28:56 +01:00
2009-02-13 15:52:26 +00:00
$id = $notice -> insert ();
2008-07-30 03:28:56 +01:00
2009-02-13 15:52:26 +00:00
if ( ! $id ) {
common_log_db_error ( $notice , 'INSERT' , __FILE__ );
2008-12-23 19:19:07 +00:00
return _ ( 'Problem saving notice.' );
}
2008-11-04 05:33:59 +00:00
2009-02-13 15:52:26 +00:00
# Update the URI after the notice is in the database
if ( ! $uri ) {
$orig = clone ( $notice );
$notice -> uri = common_notice_uri ( $notice );
2008-09-15 07:56:16 +01:00
2009-02-13 15:52:26 +00:00
if ( ! $notice -> update ( $orig )) {
common_log_db_error ( $notice , 'UPDATE' , __FILE__ );
return _ ( 'Problem saving notice.' );
}
}
2009-01-20 13:19:32 +00:00
2009-02-13 15:52:26 +00:00
# XXX: do we need to change this for remote users?
$notice -> saveReplies ();
$notice -> saveTags ();
2009-05-30 09:40:47 +01:00
$notice -> addToInboxes ();
$notice -> saveGroups ();
2009-06-17 04:10:17 +01:00
$notice -> saveUrls ();
2009-04-23 10:08:48 +01:00
2009-02-13 15:52:26 +00:00
$notice -> query ( 'COMMIT' );
Event :: handle ( 'EndNoticeSave' , array ( $notice ));
}
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +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
2008-11-04 05:33:59 +00:00
2009-05-30 09:40:47 +01:00
$notice -> blowCaches ();
2008-10-22 21:56:21 +01:00
2008-12-23 19:19:07 +00:00
return $notice ;
}
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-17 04:10:17 +01:00
/** save all urls in the notice to the db
*
* follow redirects and save all available file information
* ( mimetype , date , size , oembed , etc . )
*
* @ param class $ notice Notice to pull URLs from
*
* @ 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-03-07 17:43:50 +00:00
static function checkDupes ( $profile_id , $content ) {
$profile = Profile :: staticGet ( $profile_id );
if ( ! $profile ) {
return false ;
}
$notice = $profile -> getNotices ( 0 , NOTICE_CACHE_WINDOW );
if ( $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 ;
2009-03-11 23:41:30 +00:00
if ( common_config ( 'db' , 'type' ) == 'pgsql' )
$notice -> whereAdd ( 'extract(epoch from now() - created) < ' . common_config ( 'site' , 'dupelimit' ));
else
$notice -> whereAdd ( 'now() - created < ' . common_config ( 'site' , 'dupelimit' ));
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
}
2008-12-10 17:47:22 +00:00
static function checkEditThrottle ( $profile_id ) {
$profile = Profile :: staticGet ( $profile_id );
if ( ! $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-06-09 20:18:12 +01:00
function getUploadedAttachment () {
$post = clone $this ;
2009-06-10 19:17:46 +01:00
$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"' ;
2009-06-09 20:18:12 +01:00
$post -> query ( $query );
$post -> fetch ();
2009-06-10 20:24:25 +01:00
if ( empty ( $post -> up ) || empty ( $post -> i )) {
$ret = false ;
} else {
$ret = array ( $post -> up , $post -> i );
}
2009-06-09 20:18:12 +01:00
$post -> free ();
return $ret ;
}
2009-05-15 20:04:58 +01:00
function hasAttachments () {
2009-05-18 03:06:08 +01:00
$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 );
2009-05-15 20:04:58 +01:00
$post -> query ( $query );
$post -> fetch ();
$n_attachments = intval ( $post -> n_attachments );
$post -> free ();
return $n_attachments ;
}
2008-12-23 19:33:23 +00:00
function blowCaches ( $blowLast = false )
{
2008-12-23 19:19:07 +00:00
$this -> blowSubsCache ( $blowLast );
$this -> blowNoticeCache ( $blowLast );
$this -> blowRepliesCache ( $blowLast );
$this -> blowPublicCache ( $blowLast );
$this -> blowTagCache ( $blowLast );
2009-01-22 02:53:02 +00:00
$this -> blowGroupCache ( $blowLast );
}
2008-11-04 05:33:59 +00:00
2009-01-22 02:53:02 +00: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 ));
2009-01-22 02:53:02 +00:00
if ( $blowLast ) {
2009-05-01 19:38:50 +01:00
$cache -> delete ( common_cache_key ( 'user_group:notice_ids:' . $group_inbox -> group_id . ';last' ));
2009-01-22 02:53:02 +00:00
}
2009-01-22 06:53:27 +00:00
$member = new Group_member ();
$member -> group_id = $group_inbox -> group_id ;
if ( $member -> find ()) {
while ( $member -> fetch ()) {
2009-04-28 18:07:05 +01:00
$cache -> delete ( common_cache_key ( 'notice_inbox:by_user:' . $member -> profile_id ));
2009-01-22 06:53:27 +00:00
if ( $blowLast ) {
2009-04-28 18:07:05 +01:00
$cache -> delete ( common_cache_key ( 'notice_inbox:by_user:' . $member -> profile_id . ';last' ));
2009-01-22 06:53:27 +00:00
}
}
}
2009-01-22 02:53:02 +00:00
}
}
$group_inbox -> free ();
unset ( $group_inbox );
}
2008-12-23 19:19:07 +00:00
}
2008-12-09 05:53:45 +00:00
2008-12-23 19:33:23 +00:00
function blowTagCache ( $blowLast = false )
{
2008-12-23 19:19:07 +00:00
$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 );
2009-06-17 23:04:57 +01:00
$ck = 'profile:notice_ids_tagged:' . $this -> profile_id . ':' . $tag -> tag ;
$cache -> delete ( $ck );
if ( $blowLast ) {
$cache -> delete ( $ck . ';last' );
}
2008-12-23 19:19:07 +00:00
}
}
$tag -> free ();
unset ( $tag );
}
}
2008-12-09 05:53:45 +00:00
2008-12-23 19:33:23 +00:00
function blowSubsCache ( $blowLast = false )
{
2008-12-23 19:19:07 +00:00
$cache = common_memcache ();
if ( $cache ) {
$user = new User ();
2009-01-26 21:10:32 +00:00
$UT = common_config ( 'db' , 'type' ) == 'pgsql' ? '"user"' : 'user' ;
2008-12-23 19:19:07 +00:00
$user -> query ( 'SELECT id ' .
2009-01-26 21:10:32 +00:00
" FROM $UT JOIN subscription ON $UT .id = subscription.subscriber " .
2008-12-23 19:19:07 +00:00
'WHERE subscription.subscribed = ' . $this -> profile_id );
while ( $user -> fetch ()) {
2009-04-28 18:31:56 +01:00
$cache -> delete ( common_cache_key ( 'notice_inbox:by_user:' . $user -> id ));
2008-12-23 19:19:07 +00:00
if ( $blowLast ) {
2009-04-28 18:31:56 +01:00
$cache -> delete ( common_cache_key ( 'notice_inbox:by_user:' . $user -> id . ';last' ));
2008-12-23 19:19:07 +00:00
}
}
$user -> free ();
unset ( $user );
}
}
2008-11-22 12:42:35 +00:00
2008-12-23 19:33:23 +00:00
function blowNoticeCache ( $blowLast = false )
{
2008-12-23 19:19:07 +00:00
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 ));
2008-12-23 19:19:07 +00:00
if ( $blowLast ) {
2009-05-01 19:27:57 +01:00
$cache -> delete ( common_cache_key ( 'profile:notice_ids:' . $this -> profile_id . ';last' ));
2008-12-23 19:19:07 +00:00
}
}
}
}
2008-12-23 19:33:23 +00:00
function blowRepliesCache ( $blowLast = false )
{
2008-12-23 19:19:07 +00:00
$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 ));
2008-12-23 19:19:07 +00:00
if ( $blowLast ) {
2009-04-30 01:45:33 +01:00
$cache -> delete ( common_cache_key ( 'reply:stream:' . $reply -> profile_id . ';last' ));
2008-12-23 19:19:07 +00:00
}
}
}
$reply -> free ();
unset ( $reply );
}
}
2008-12-23 19:33:23 +00:00
function blowPublicCache ( $blowLast = false )
{
2008-12-23 19:19:07 +00:00
if ( $this -> is_local == 1 ) {
$cache = common_memcache ();
if ( $cache ) {
$cache -> delete ( common_cache_key ( 'public' ));
if ( $blowLast ) {
$cache -> delete ( common_cache_key ( 'public' ) . ';last' );
}
}
}
}
2008-11-04 05:33:59 +00:00
2008-12-23 19:33:23 +00:00
function blowFavesCache ( $blowLast = false )
{
2008-12-23 19:19:07 +00:00
$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 ));
2008-12-23 19:19:07 +00:00
if ( $blowLast ) {
2009-05-01 20:01:28 +01:00
$cache -> delete ( common_cache_key ( 'fave:ids_by_user:' . $fave -> user_id . ';last' ));
2008-12-23 19:19:07 +00:00
}
}
}
$fave -> free ();
unset ( $fave );
}
}
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
2008-12-23 19:19:07 +00:00
# XXX: too many args; we need to move to named params or even a separate
# class for notice streams
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-05-30 00:54:24 +01:00
static function getStream ( $qry , $cachekey , $offset = 0 , $limit = 20 , $since_id = 0 , $max_id = 0 , $order = null , $since = null ) {
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
if ( common_config ( 'memcached' , 'enabled' )) {
2008-11-04 05:33:59 +00:00
2009-05-30 00:54:24 +01:00
# Skip the cache if this is a since, since_id or max_id qry
if ( $since_id > 0 || $max_id > 0 || $since ) {
return Notice :: getStreamDirect ( $qry , $offset , $limit , $since_id , $max_id , $order , $since );
2008-12-23 19:19:07 +00:00
} else {
return Notice :: getCachedStream ( $qry , $cachekey , $offset , $limit , $order );
}
}
2008-11-22 12:42:35 +00:00
2009-05-30 00:54:24 +01:00
return Notice :: getStreamDirect ( $qry , $offset , $limit , $since_id , $max_id , $order , $since );
2008-12-23 19:19:07 +00:00
}
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-05-30 00:54:24 +01:00
static function getStreamDirect ( $qry , $offset , $limit , $since_id , $max_id , $order , $since ) {
2008-11-04 05:33:59 +00:00
2008-12-23 19:44:28 +00:00
$needAnd = false ;
$needWhere = true ;
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
2008-12-23 19:19:07 +00:00
if ( preg_match ( '/\bWHERE\b/i' , $qry )) {
2008-12-23 19:44:28 +00:00
$needWhere = false ;
$needAnd = true ;
2008-12-23 19:19:07 +00:00
}
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
if ( $since_id > 0 ) {
2008-09-28 18:14:07 +01:00
2008-12-23 19:19:07 +00:00
if ( $needWhere ) {
$qry .= ' WHERE ' ;
2008-12-23 19:44:28 +00:00
$needWhere = false ;
2008-12-23 19:19:07 +00:00
} else {
$qry .= ' AND ' ;
}
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
2008-12-23 19:19:07 +00:00
$qry .= ' notice.id > ' . $since_id ;
}
2008-11-04 05:33:59 +00:00
2009-05-30 00:54:24 +01:00
if ( $max_id > 0 ) {
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
if ( $needWhere ) {
$qry .= ' WHERE ' ;
2008-12-23 19:44:28 +00:00
$needWhere = false ;
2008-12-23 19:19:07 +00:00
} else {
$qry .= ' AND ' ;
}
2008-11-04 05:33:59 +00:00
2009-05-30 00:54:24 +01:00
$qry .= ' notice.id <= ' . $max_id ;
2008-12-23 19:19:07 +00:00
}
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
2008-12-23 19:19:07 +00:00
if ( $since ) {
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
if ( $needWhere ) {
$qry .= ' WHERE ' ;
2008-12-23 19:44:28 +00:00
$needWhere = false ;
2008-12-23 19:19:07 +00:00
} else {
$qry .= ' AND ' ;
}
2008-11-22 12:41:51 +00:00
2008-12-23 19:19:07 +00:00
$qry .= ' notice.created > \'' . date ( 'Y-m-d H:i:s' , $since ) . '\'' ;
}
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
# Allow ORDER override
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
if ( $order ) {
$qry .= $order ;
} else {
$qry .= ' ORDER BY notice.created DESC, notice.id DESC ' ;
}
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
if ( common_config ( 'db' , 'type' ) == 'pgsql' ) {
$qry .= ' LIMIT ' . $limit . ' OFFSET ' . $offset ;
} else {
$qry .= ' LIMIT ' . $offset . ', ' . $limit ;
}
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
$notice = new Notice ();
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
$notice -> query ( $qry );
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
return $notice ;
}
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
# XXX: this is pretty long and should probably be broken up into
# some helper functions
2008-11-22 12:41:51 +00:00
2008-12-23 19:19:07 +00:00
static function getCachedStream ( $qry , $cachekey , $offset , $limit , $order ) {
2008-11-22 12:41:51 +00:00
2008-12-23 19:19:07 +00:00
# If outside our cache window, just go to the DB
2008-11-22 12:41:51 +00:00
2008-12-23 19:19:07 +00:00
if ( $offset + $limit > NOTICE_CACHE_WINDOW ) {
2008-12-23 19:21:29 +00:00
return Notice :: getStreamDirect ( $qry , $offset , $limit , null , null , $order , null );
2008-12-23 19:19:07 +00:00
}
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
# Get the cache; if we can't, just go to the DB
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
2008-12-23 19:19:07 +00:00
$cache = common_memcache ();
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
if ( ! $cache ) {
2008-12-23 19:21:29 +00:00
return Notice :: getStreamDirect ( $qry , $offset , $limit , null , null , $order , null );
2008-12-23 19:19:07 +00:00
}
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
# Get the notices out of the cache
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
2008-12-23 19:19:07 +00:00
$notices = $cache -> get ( common_cache_key ( $cachekey ));
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
# On a cache hit, return a DB-object-like wrapper
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
2008-12-23 19:44:28 +00:00
if ( $notices !== false ) {
2009-01-22 17:48:52 +00:00
$wrapper = new ArrayWrapper ( array_slice ( $notices , $offset , $limit ));
2008-12-23 19:19:07 +00:00
return $wrapper ;
}
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
2008-12-23 19:19:07 +00:00
# If the cache was invalidated because of new data being
# added, we can try and just get the new stuff. We keep an additional
# copy of the data at the key + ';last'
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
# No cache hit. Try to get the *last* cached version
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
$last_notices = $cache -> get ( common_cache_key ( $cachekey ) . ';last' );
2008-09-28 18:14:07 +01:00
2008-12-23 19:19:07 +00:00
if ( $last_notices ) {
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
# Reverse-chron order, so last ID is last.
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
$last_id = $last_notices [ 0 ] -> id ;
2008-10-22 21:56:21 +01:00
2008-12-23 19:19:07 +00:00
# XXX: this assumes monotonically increasing IDs; a fair
# bet with our DB.
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
$new_notice = Notice :: getStreamDirect ( $qry , 0 , NOTICE_CACHE_WINDOW ,
2008-12-23 19:21:29 +00:00
$last_id , null , $order , null );
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
if ( $new_notice ) {
$new_notices = array ();
while ( $new_notice -> fetch ()) {
$new_notices [] = clone ( $new_notice );
}
$new_notice -> free ();
$notices = array_slice ( array_merge ( $new_notices , $last_notices ),
0 , NOTICE_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
2008-12-23 19:19:07 +00:00
# Store the array in the cache for next time
2008-10-01 01:12:33 +01:00
2008-12-23 19:19:07 +00:00
$result = $cache -> set ( common_cache_key ( $cachekey ), $notices );
$result = $cache -> set ( common_cache_key ( $cachekey ) . ';last' , $notices );
2008-11-22 12:42:35 +00:00
2008-12-23 19:19:07 +00:00
# return a wrapper of the array for use now
2008-11-04 05:33:59 +00:00
2009-01-22 17:48:52 +00:00
return new ArrayWrapper ( array_slice ( $notices , $offset , $limit ));
2008-12-23 19:19:07 +00:00
}
}
2008-11-14 07:42:11 +00:00
2008-12-23 19:19:07 +00:00
# Otherwise, get the full cache window out of the DB
2008-10-23 21:35:05 +01:00
2008-12-23 19:21:29 +00:00
$notice = Notice :: getStreamDirect ( $qry , 0 , NOTICE_CACHE_WINDOW , null , null , $order , null );
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
# If there are no hits, just return the value
2008-10-23 21:35:05 +01:00
2008-12-23 19:19:07 +00:00
if ( ! $notice ) {
return $notice ;
}
2008-11-14 07:42:11 +00:00
2008-12-23 19:19:07 +00:00
# Pack results into an array
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
$notices = array ();
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
while ( $notice -> fetch ()) {
$notices [] = clone ( $notice );
}
2008-10-23 21:35:05 +01:00
2008-12-23 19:19:07 +00:00
$notice -> free ();
2008-11-04 05:33:59 +00:00
2008-12-23 19:19:07 +00:00
# Store the array in the cache for next time
2008-10-23 21:35:05 +01:00
2008-12-23 19:19:07 +00:00
$result = $cache -> set ( common_cache_key ( $cachekey ), $notices );
$result = $cache -> set ( common_cache_key ( $cachekey ) . ';last' , $notices );
2008-11-14 07:42:11 +00:00
2008-12-23 19:19:07 +00:00
# return a wrapper of the array for use now
2008-11-04 05:33:59 +00:00
2009-01-22 17:48:52 +00:00
$wrapper = new ArrayWrapper ( array_slice ( $notices , $offset , $limit ));
2008-12-23 19:19:07 +00:00
return $wrapper ;
}
2009-04-28 18:07:05 +01:00
function getStreamByIds ( $ids )
{
$cache = common_memcache ();
if ( ! empty ( $cache )) {
$notices = array ();
foreach ( $ids as $id ) {
$notices [] = Notice :: staticGet ( 'id' , $id );
}
return new ArrayWrapper ( $notices );
} else {
$notice = new Notice ();
$notice -> whereAdd ( 'id in (' . implode ( ', ' , $ids ) . ')' );
$notice -> orderBy ( 'id DESC' );
$notice -> find ();
return $notice ;
}
}
2009-05-30 00:54:24 +01:00
function publicStream ( $offset = 0 , $limit = 20 , $since_id = 0 , $max_id = 0 , $since = null )
2008-12-23 19:33:23 +00:00
{
2009-04-29 17:05:31 +01:00
$ids = Notice :: stream ( array ( 'Notice' , '_publicStreamDirect' ),
array (),
'public' ,
2009-05-30 00:54:24 +01:00
$offset , $limit , $since_id , $max_id , $since );
2008-12-23 19:19:07 +00:00
2009-04-29 17:05:31 +01:00
return Notice :: getStreamByIds ( $ids );
}
2008-12-23 19:19:07 +00:00
2009-05-30 00:54:24 +01:00
function _publicStreamDirect ( $offset = 0 , $limit = 20 , $since_id = 0 , $max_id = 0 , $since = null )
2009-04-29 17:05:31 +01:00
{
$notice = new Notice ();
$notice -> selectAdd (); // clears it
$notice -> selectAdd ( 'id' );
2008-12-23 19:19:07 +00:00
2009-04-29 17:05:31 +01:00
$notice -> orderBy ( 'id DESC' );
if ( ! is_null ( $offset )) {
$notice -> limit ( $offset , $limit );
}
2008-12-23 19:19:07 +00:00
if ( common_config ( 'public' , 'localonly' )) {
2009-04-29 17:05:31 +01:00
$notice -> whereAdd ( 'is_local = 1' );
2008-12-23 19:19:07 +00:00
} else {
# -1 == blacklisted
2009-04-29 17:05:31 +01:00
$notice -> whereAdd ( 'is_local != -1' );
2008-12-23 19:19:07 +00:00
}
2009-04-29 17:05:31 +01:00
if ( $since_id != 0 ) {
$notice -> whereAdd ( 'id > ' . $since_id );
2008-12-23 19:19:07 +00:00
}
2009-05-30 00:54:24 +01:00
if ( $max_id != 0 ) {
$notice -> whereAdd ( 'id <= ' . $max_id );
2009-04-29 17:05:31 +01:00
}
if ( ! is_null ( $since )) {
$notice -> whereAdd ( 'created > \'' . date ( 'Y-m-d H:i:s' , $since ) . '\'' );
2008-12-23 19:19:07 +00:00
}
2009-04-29 17:05:31 +01:00
$ids = array ();
if ( $notice -> find ()) {
while ( $notice -> fetch ()) {
$ids [] = $notice -> id ;
}
2008-12-23 19:19:07 +00:00
}
2009-04-29 17:05:31 +01:00
$notice -> free ();
$notice = NULL ;
return $ids ;
2008-12-23 19:19:07 +00:00
}
2008-12-23 19:33:23 +00:00
function addToInboxes ()
{
2008-12-23 19:19:07 +00:00
$enabled = common_config ( 'inboxes' , 'enabled' );
if ( $enabled === true || $enabled === 'transitional' ) {
$inbox = new Notice_inbox ();
2009-01-26 21:10:32 +00:00
$UT = common_config ( 'db' , 'type' ) == 'pgsql' ? '"user"' : 'user' ;
2008-12-23 19:19:07 +00:00
$qry = 'INSERT INTO notice_inbox (user_id, notice_id, created) ' .
2009-03-03 21:32:47 +00:00
" SELECT $UT .id, " . $this -> id . " , ' " . $this -> created . " ' " .
2009-01-26 21:10:32 +00:00
" FROM $UT JOIN subscription ON $UT .id = subscription.subscriber " .
2008-12-23 19:19:07 +00:00
'WHERE subscription.subscribed = ' . $this -> profile_id . ' ' .
'AND NOT EXISTS (SELECT user_id, notice_id ' .
'FROM notice_inbox ' .
2009-01-26 21:10:32 +00:00
" WHERE user_id = $UT .id " .
2008-12-23 19:19:07 +00:00
'AND notice_id = ' . $this -> id . ' )' ;
if ( $enabled === 'transitional' ) {
2009-01-26 21:10:32 +00:00
$qry .= " AND $UT .inboxed = 1 " ;
2008-12-23 19:19:07 +00:00
}
$inbox -> query ( $qry );
}
return ;
}
2009-01-22 02:53:02 +00:00
function saveGroups ()
{
$enabled = common_config ( 'inboxes' , 'enabled' );
if ( $enabled !== true && $enabled !== 'transitional' ) {
return ;
}
/* extract all !group */
$count = preg_match_all ( '/(?:^|\s)!([A-Za-z0-9]{1,64})/' ,
strtolower ( $this -> content ),
$match );
if ( ! $count ) {
return true ;
}
$profile = $this -> getProfile ();
2008-10-22 21:56:21 +01:00
2009-01-22 02:53:02 +00:00
/* Add them to the database */
foreach ( array_unique ( $match [ 1 ]) as $nickname ) {
/* XXX: remote groups. */
2009-06-15 07:43:47 +01:00
$group = User_group :: getForNickname ( $nickname );
2009-01-22 02:53:02 +00:00
2009-06-15 07:43:47 +01:00
if ( empty ( $group )) {
2009-01-22 03:40:42 +00:00
continue ;
}
2009-02-16 23:02:31 +00:00
// we automatically add a tag for every group name, too
$tag = Notice_tag :: pkeyGet ( array ( 'tag' => common_canonical_tag ( $nickname ),
2009-06-15 07:43:47 +01:00
'notice_id' => $this -> id ));
2009-02-16 23:02:31 +00:00
if ( is_null ( $tag )) {
$this -> saveTag ( $nickname );
}
2009-01-22 02:53:02 +00:00
if ( $profile -> isMember ( $group )) {
2009-01-22 03:40:42 +00:00
2009-01-22 02:53:02 +00:00
$gi = new Group_inbox ();
$gi -> group_id = $group -> id ;
$gi -> notice_id = $this -> id ;
$gi -> created = common_sql_now ();
$result = $gi -> insert ();
if ( ! $result ) {
common_log_db_error ( $gi , 'INSERT' , __FILE__ );
}
// FIXME: do this in an offline daemon
2009-04-23 11:38:51 +01:00
$this -> addToGroupInboxes ( $group );
2009-01-22 02:53:02 +00:00
}
}
}
2009-01-22 06:53:27 +00:00
2009-04-23 11:38:51 +01:00
function addToGroupInboxes ( $group )
{
$inbox = new Notice_inbox ();
$UT = common_config ( 'db' , 'type' ) == 'pgsql' ? '"user"' : 'user' ;
$qry = 'INSERT INTO notice_inbox (user_id, notice_id, created, source) ' .
2009-06-17 05:37:04 +01:00
" SELECT $UT .id, " . $this -> id . " , ' " . $this -> created . " ', " . NOTICE_INBOX_SOURCE_GROUP . " " .
2009-04-23 11:38:51 +01:00
" FROM $UT JOIN group_member ON $UT .id = group_member.profile_id " .
'WHERE group_member.group_id = ' . $group -> id . ' ' .
'AND NOT EXISTS (SELECT user_id, notice_id ' .
'FROM notice_inbox ' .
" WHERE user_id = $UT .id " .
'AND notice_id = ' . $this -> id . ' )' ;
if ( $enabled === 'transitional' ) {
$qry .= " AND $UT .inboxed = 1 " ;
}
$result = $inbox -> query ( $qry );
}
2009-01-22 06:53:27 +00:00
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 );
$names = array ();
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 ]);
}
$sender = Profile :: staticGet ( $this -> profile_id );
$replied = array ();
// store replied only for first @ (what user/notice what the reply directed,
// we assume first @ is it)
for ( $i = 0 ; $i < count ( $names ); $i ++ ) {
$nickname = $names [ $i ];
$recipient = common_relative_profile ( $sender , $nickname , $this -> created );
if ( ! $recipient ) {
continue ;
}
if ( $i == 0 && ( $recipient -> id != $sender -> id ) && ! $this -> reply_to ) { // Don't save reply to self
$reply_for = $recipient ;
$recipient_notice = $reply_for -> getCurrentNotice ();
if ( $recipient_notice ) {
$orig = clone ( $this );
$this -> reply_to = $recipient_notice -> id ;
2009-02-26 21:45:43 +00:00
$this -> conversation = $recipient_notice -> conversation ;
2009-01-22 06:53:27 +00:00
$this -> update ( $orig );
}
}
// Don't save replies from blocked profile to local user
$recipient_user = User :: staticGet ( 'id' , $recipient -> id );
if ( $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 ));
return ;
} else {
$replied [ $recipient -> id ] = 1 ;
}
}
// 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__ );
return ;
2009-02-16 23:26:15 +00:00
} else {
$replied [ $recipient -> id ] = 1 ;
2009-01-22 06:53:27 +00:00
}
}
}
}
}
2009-02-16 23:26:15 +00:00
2009-02-26 21:45:43 +00:00
// If it's not a reply, make it the root of a new conversation
if ( empty ( $this -> conversation )) {
$orig = clone ( $this );
$this -> conversation = $this -> id ;
$this -> update ( $orig );
}
2009-02-16 23:26:15 +00:00
foreach ( array_keys ( $replied ) as $recipient ) {
$user = User :: staticGet ( 'id' , $recipient );
if ( $user ) {
2009-02-16 23:45:59 +00:00
mail_notify_attn ( $user , $this );
2009-02-16 23:26:15 +00:00
}
}
2009-01-22 06:53:27 +00:00
}
2009-03-22 20:58:38 +00:00
function asAtomEntry ( $namespace = false , $source = false )
{
$profile = $this -> getProfile ();
$xs = new XMLStringer ( true );
if ( $namespace ) {
$attrs = array ( 'xmlns' => 'http://www.w3.org/2005/Atom' ,
'xmlns:thr' => 'http://purl.org/syndication/thread/1.0' );
} else {
$attrs = array ();
}
$xs -> elementStart ( 'entry' , $attrs );
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 ( 'api' ,
array ( 'apiaction' => 'statuses' ,
'method' => 'user_timeline' ,
'argument' => $profile -> nickname . '.atom' ));
$xs -> element ( 'link' , array ( 'rel' => 'self' ,
'type' => 'application/atom+xml' ,
'href' => $profile -> profileurl ));
$xs -> element ( 'link' , array ( 'rel' => 'license' ,
'href' => common_config ( 'license' , 'url' )));
}
$xs -> element ( 'icon' , null , $profile -> avatarUrl ( AVATAR_PROFILE_SIZE ));
}
$xs -> elementStart ( 'author' );
$xs -> element ( 'name' , null , $profile -> nickname );
$xs -> element ( 'uri' , null , $profile -> profileurl );
$xs -> elementEnd ( 'author' );
if ( $source ) {
$xs -> elementEnd ( 'source' );
}
$xs -> element ( 'title' , null , $this -> content );
$xs -> element ( 'summary' , null , $this -> content );
$xs -> element ( 'link' , array ( 'rel' => 'alternate' ,
'href' => $this -> bestUrl ()));
$xs -> element ( 'id' , null , $this -> uri );
$xs -> element ( 'published' , null , common_date_w3dtf ( $this -> created ));
$xs -> element ( 'updated' , null , common_date_w3dtf ( $this -> modified ));
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 ()));
}
}
$xs -> element ( 'content' , array ( 'type' => 'html' ), $this -> rendered );
$tag = new Notice_tag ();
$tag -> notice_id = $this -> id ;
if ( $tag -> find ()) {
while ( $tag -> fetch ()) {
$xs -> element ( 'category' , array ( 'term' => $tag -> tag ));
}
}
$tag -> free ();
$xs -> elementEnd ( 'entry' );
return $xs -> getString ();
}
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-04-29 16:27:45 +01:00
2009-05-30 00:54:24 +01:00
function stream ( $fn , $args , $cachekey , $offset = 0 , $limit = 20 , $since_id = 0 , $max_id = 0 , $since = null )
2009-04-29 16:27:45 +01:00
{
$cache = common_memcache ();
if ( empty ( $cache ) ||
2009-05-30 05:49:14 +01:00
$since_id != 0 || $max_id != 0 || ( ! is_null ( $since ) && $since > 0 ) ||
2009-04-29 16:27:45 +01:00
( $offset + $limit ) > NOTICE_CACHE_WINDOW ) {
return call_user_func_array ( $fn , array_merge ( $args , array ( $offset , $limit , $since_id ,
2009-05-30 00:54:24 +01:00
$max_id , $since )));
2009-04-29 16:27:45 +01:00
}
$idkey = common_cache_key ( $cachekey );
$idstr = $cache -> get ( $idkey );
if ( ! empty ( $idstr )) {
// Cache hit! Woohoo!
$window = explode ( ',' , $idstr );
$ids = array_slice ( $window , $offset , $limit );
return $ids ;
}
2009-04-29 17:05:31 +01:00
$laststr = $cache -> get ( $idkey . ';last' );
2009-04-29 16:27:45 +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-05-18 22:18:57 +01:00
$last_id , 0 , null , $tag )));
2009-04-29 16:27:45 +01:00
$new_window = array_merge ( $new_ids , $window );
$new_windowstr = implode ( ',' , $new_window );
$result = $cache -> set ( $idkey , $new_windowstr );
$result = $cache -> set ( $idkey . ';last' , $new_windowstr );
$ids = array_slice ( $new_window , $offset , $limit );
return $ids ;
}
$window = call_user_func_array ( $fn , array_merge ( $args , array ( 0 , NOTICE_CACHE_WINDOW ,
2009-05-18 22:18:57 +01:00
0 , 0 , null , $tag )));
2009-04-29 16:27:45 +01:00
2009-04-29 17:05:31 +01:00
$windowstr = implode ( ',' , $window );
2009-04-29 16:27:45 +01:00
$result = $cache -> set ( $idkey , $windowstr );
$result = $cache -> set ( $idkey . ';last' , $windowstr );
$ids = array_slice ( $window , $offset , $limit );
return $ids ;
}
2008-05-07 18:15:42 +01:00
}