forked from GNUsocial/gnu-social
63c087a255
We don't guess the current profile anymore if the value of the profile === -1 Also sets $this->scoped for all ScopingNoticeStream inheritors, which just like in an Action can be null if we're not scoped in any way (logged in).
922 lines
28 KiB
PHP
922 lines
28 KiB
PHP
<?php
|
|
/**
|
|
* StatusNet - the distributed open-source microblogging tool
|
|
*
|
|
* 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/>.
|
|
*
|
|
* @category Notices
|
|
* @package StatusNet
|
|
* @author Shashi Gowda <connect2shashi@gmail.com>
|
|
* @license GNU Affero General Public License http://www.gnu.org/licenses/
|
|
*/
|
|
|
|
if (!defined('GNUSOCIAL')) { exit(1); }
|
|
|
|
class Profile_list extends Managed_DataObject
|
|
{
|
|
public $__table = 'profile_list'; // table name
|
|
public $id; // int(4) primary_key not_null
|
|
public $tagger; // int(4)
|
|
public $tag; // varchar(64)
|
|
public $description; // text
|
|
public $private; // tinyint(1)
|
|
public $created; // datetime not_null default_0000-00-00%2000%3A00%3A00
|
|
public $modified; // timestamp not_null default_CURRENT_TIMESTAMP
|
|
public $uri; // varchar(191) unique_key not 255 because utf8mb4 takes more space
|
|
public $mainpage; // varchar(191) not 255 because utf8mb4 takes more space
|
|
public $tagged_count; // smallint
|
|
public $subscriber_count; // smallint
|
|
|
|
public static function schemaDef()
|
|
{
|
|
return array(
|
|
'fields' => array(
|
|
'id' => array('type' => 'serial', 'not null' => true, 'description' => 'unique identifier'),
|
|
'tagger' => array('type' => 'int', 'not null' => true, 'description' => 'user making the tag'),
|
|
'tag' => array('type' => 'varchar', 'length' => 64, 'not null' => true, 'description' => 'people tag'),
|
|
'description' => array('type' => 'text', 'description' => 'description of the people tag'),
|
|
'private' => array('type' => 'int', 'size' => 'tiny', 'default' => 0, 'description' => 'is this tag private'),
|
|
|
|
'created' => array('type' => 'timestamp', 'not null' => true, 'description' => 'date the tag was added'),
|
|
'modified' => array('type' => 'timestamp', 'not null' => true, 'description' => 'date the tag was modified'),
|
|
|
|
'uri' => array('type' => 'varchar', 'length' => 191, 'description' => 'universal identifier'),
|
|
'mainpage' => array('type' => 'varchar', 'length' => 191, 'description' => 'page to link to'),
|
|
'tagged_count' => array('type' => 'int', 'default' => 0, 'description' => 'number of people tagged with this tag by this user'),
|
|
'subscriber_count' => array('type' => 'int', 'default' => 0, 'description' => 'number of subscribers to this tag'),
|
|
),
|
|
'primary key' => array('tagger', 'tag'),
|
|
'unique keys' => array(
|
|
'profile_list_id_key' => array('id')
|
|
),
|
|
'foreign keys' => array(
|
|
'profile_list_tagger_fkey' => array('profile', array('tagger' => 'id')),
|
|
),
|
|
'indexes' => array(
|
|
'profile_list_modified_idx' => array('modified'),
|
|
'profile_list_tag_idx' => array('tag'),
|
|
'profile_list_tagger_tag_idx' => array('tagger', 'tag'),
|
|
'profile_list_tagged_count_idx' => array('tagged_count'),
|
|
'profile_list_subscriber_count_idx' => array('subscriber_count'),
|
|
),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* get the tagger of this profile_list object
|
|
*
|
|
* @return Profile the tagger
|
|
*/
|
|
|
|
function getTagger()
|
|
{
|
|
return Profile::getByID($this->tagger);
|
|
}
|
|
|
|
/**
|
|
* return a string to identify this
|
|
* profile_list in the user interface etc.
|
|
*
|
|
* @return String
|
|
*/
|
|
|
|
function getBestName()
|
|
{
|
|
return $this->tag;
|
|
}
|
|
|
|
/**
|
|
* return a uri string for this profile_list
|
|
*
|
|
* @return String uri
|
|
*/
|
|
|
|
function getUri()
|
|
{
|
|
$uri = null;
|
|
if (Event::handle('StartProfiletagGetUri', array($this, &$uri))) {
|
|
if (!empty($this->uri)) {
|
|
$uri = $this->uri;
|
|
} else {
|
|
$uri = common_local_url('profiletagbyid',
|
|
array('id' => $this->id, 'tagger_id' => $this->tagger));
|
|
}
|
|
}
|
|
Event::handle('EndProfiletagGetUri', array($this, &$uri));
|
|
return $uri;
|
|
}
|
|
|
|
/**
|
|
* return a url to the homepage of this item
|
|
*
|
|
* @return String home url
|
|
*/
|
|
|
|
function homeUrl()
|
|
{
|
|
$url = null;
|
|
if (Event::handle('StartUserPeopletagHomeUrl', array($this, &$url))) {
|
|
// normally stored in mainpage, but older ones may be null
|
|
if (!empty($this->mainpage)) {
|
|
$url = $this->mainpage;
|
|
} else {
|
|
$url = common_local_url('showprofiletag',
|
|
array('nickname' => $this->getTagger()->nickname,
|
|
'tag' => $this->tag));
|
|
}
|
|
}
|
|
Event::handle('EndUserPeopletagHomeUrl', array($this, &$url));
|
|
return $url;
|
|
}
|
|
|
|
/**
|
|
* return an immutable url for this object
|
|
*
|
|
* @return String permalink
|
|
*/
|
|
|
|
function permalink()
|
|
{
|
|
$url = null;
|
|
if (Event::handle('StartProfiletagPermalink', array($this, &$url))) {
|
|
$url = common_local_url('profiletagbyid',
|
|
array('id' => $this->id));
|
|
}
|
|
Event::handle('EndProfiletagPermalink', array($this, &$url));
|
|
return $url;
|
|
}
|
|
|
|
/**
|
|
* Query notices by users associated with this tag,
|
|
* but first check the cache before hitting the DB.
|
|
*
|
|
* @param integer $offset offset
|
|
* @param integer $limit maximum no of results
|
|
* @param integer $since_id=null since this id
|
|
* @param integer $max_id=null maximum id in result
|
|
*
|
|
* @return Notice the query
|
|
*/
|
|
|
|
function getNotices($offset, $limit, $since_id=null, $max_id=null)
|
|
{
|
|
// FIXME: Use something else than Profile::current() to avoid
|
|
// possible confusion between session user and queue processing.
|
|
$stream = new PeopletagNoticeStream($this, Profile::current());
|
|
|
|
return $stream->getNotices($offset, $limit, $since_id, $max_id);
|
|
}
|
|
|
|
/**
|
|
* Get subscribers (local and remote) to this people tag
|
|
* Order by reverse chronology
|
|
*
|
|
* @param integer $offset offset
|
|
* @param integer $limit maximum no of results
|
|
* @param integer $since_id=null since unix timestamp
|
|
* @param integer $upto=null maximum unix timestamp when subscription was made
|
|
*
|
|
* @return Profile results
|
|
*/
|
|
|
|
function getSubscribers($offset=0, $limit=null, $since=0, $upto=0)
|
|
{
|
|
$subs = new Profile();
|
|
|
|
$subs->joinAdd(
|
|
array('id', 'profile_tag_subscription:profile_id')
|
|
);
|
|
$subs->whereAdd('profile_tag_subscription.profile_tag_id = ' . $this->id);
|
|
|
|
$subs->selectAdd('unix_timestamp(profile_tag_subscription.' .
|
|
'created) as "cursor"');
|
|
|
|
if ($since != 0) {
|
|
$subs->whereAdd('cursor > ' . $since);
|
|
}
|
|
|
|
if ($upto != 0) {
|
|
$subs->whereAdd('cursor <= ' . $upto);
|
|
}
|
|
|
|
if ($limit != null) {
|
|
$subs->limit($offset, $limit);
|
|
}
|
|
|
|
$subs->orderBy('profile_tag_subscription.created DESC');
|
|
$subs->find();
|
|
|
|
return $subs;
|
|
}
|
|
|
|
/**
|
|
* Get all and only local subscribers to this people tag
|
|
* used for distributing notices to user inboxes.
|
|
*
|
|
* @return array ids of users
|
|
*/
|
|
|
|
function getUserSubscribers()
|
|
{
|
|
// XXX: cache this
|
|
|
|
$user = new User();
|
|
if(common_config('db','quote_identifiers'))
|
|
$user_table = '"user"';
|
|
else $user_table = 'user';
|
|
|
|
$qry =
|
|
'SELECT id ' .
|
|
'FROM '. $user_table .' JOIN profile_tag_subscription '.
|
|
'ON '. $user_table .'.id = profile_tag_subscription.profile_id ' .
|
|
'WHERE profile_tag_subscription.profile_tag_id = %d ';
|
|
|
|
$user->query(sprintf($qry, $this->id));
|
|
|
|
$ids = array();
|
|
|
|
while ($user->fetch()) {
|
|
$ids[] = $user->id;
|
|
}
|
|
|
|
$user->free();
|
|
|
|
return $ids;
|
|
}
|
|
|
|
/**
|
|
* Check to see if a given profile has
|
|
* subscribed to this people tag's timeline
|
|
*
|
|
* @param mixed $id User or Profile object or integer id
|
|
*
|
|
* @return boolean subscription status
|
|
*/
|
|
|
|
function hasSubscriber($id)
|
|
{
|
|
if (!is_numeric($id)) {
|
|
$id = $id->id;
|
|
}
|
|
|
|
$sub = Profile_tag_subscription::pkeyGet(array('profile_tag_id' => $this->id,
|
|
'profile_id' => $id));
|
|
return !empty($sub);
|
|
}
|
|
|
|
/**
|
|
* Get profiles tagged with this people tag,
|
|
* include modified timestamp as a "cursor" field
|
|
* order by descending order of modified time
|
|
*
|
|
* @param integer $offset offset
|
|
* @param integer $limit maximum no of results
|
|
* @param integer $since_id=null since unix timestamp
|
|
* @param integer $upto=null maximum unix timestamp when subscription was made
|
|
*
|
|
* @return Profile results
|
|
*/
|
|
|
|
function getTagged($offset=0, $limit=null, $since=0, $upto=0)
|
|
{
|
|
$tagged = new Profile();
|
|
$tagged->joinAdd(array('id', 'profile_tag:tagged'));
|
|
|
|
#@fixme: postgres
|
|
$tagged->selectAdd('unix_timestamp(profile_tag.modified) as "cursor"');
|
|
$tagged->whereAdd('profile_tag.tagger = '.$this->tagger);
|
|
$tagged->whereAdd("profile_tag.tag = '{$this->tag}'");
|
|
|
|
if ($since != 0) {
|
|
$tagged->whereAdd('cursor > ' . $since);
|
|
}
|
|
|
|
if ($upto != 0) {
|
|
$tagged->whereAdd('cursor <= ' . $upto);
|
|
}
|
|
|
|
if ($limit != null) {
|
|
$tagged->limit($offset, $limit);
|
|
}
|
|
|
|
$tagged->orderBy('profile_tag.modified DESC');
|
|
$tagged->find();
|
|
|
|
return $tagged;
|
|
}
|
|
|
|
/**
|
|
* Gracefully delete one or many people tags
|
|
* along with their members and subscriptions data
|
|
*
|
|
* @return boolean success
|
|
*/
|
|
|
|
function delete($useWhere=false)
|
|
{
|
|
// force delete one item at a time.
|
|
if (empty($this->id)) {
|
|
$this->find();
|
|
while ($this->fetch()) {
|
|
$this->delete();
|
|
}
|
|
}
|
|
|
|
Profile_tag::cleanup($this);
|
|
Profile_tag_subscription::cleanup($this);
|
|
|
|
self::blow('profile:lists:%d', $this->tagger);
|
|
|
|
return parent::delete($useWhere);
|
|
}
|
|
|
|
/**
|
|
* Update a people tag gracefully
|
|
* also change "tag" fields in profile_tag table
|
|
*
|
|
* @param Profile_list $dataObject Object's original form
|
|
*
|
|
* @return boolean success
|
|
*/
|
|
|
|
function update($dataObject=false)
|
|
{
|
|
if (!is_object($dataObject) && !$dataObject instanceof Profile_list) {
|
|
return parent::update($dataObject);
|
|
}
|
|
|
|
$result = true;
|
|
|
|
// if original tag was different
|
|
// check to see if the new tag already exists
|
|
// if not, rename the tag correctly
|
|
if($dataObject->tag != $this->tag || $dataObject->tagger != $this->tagger) {
|
|
$existing = Profile_list::getByTaggerAndTag($this->tagger, $this->tag);
|
|
if(!empty($existing)) {
|
|
// TRANS: Server exception.
|
|
throw new ServerException(_('The tag you are trying to rename ' .
|
|
'to already exists.'));
|
|
}
|
|
// move the tag
|
|
// XXX: allow OStatus plugin to send out profile tag
|
|
$result = Profile_tag::moveTag($dataObject, $this);
|
|
}
|
|
return parent::update($dataObject);
|
|
}
|
|
|
|
/**
|
|
* return an xml string representing this people tag
|
|
* as the author of an atom feed
|
|
*
|
|
* @return string atom author element
|
|
*/
|
|
|
|
function asAtomAuthor()
|
|
{
|
|
$xs = new XMLStringer(true);
|
|
|
|
$tagger = $this->getTagger();
|
|
$xs->elementStart('author');
|
|
$xs->element('name', null, '@' . $tagger->nickname . '/' . $this->tag);
|
|
$xs->element('uri', null, $this->permalink());
|
|
$xs->elementEnd('author');
|
|
|
|
return $xs->getString();
|
|
}
|
|
|
|
/**
|
|
* return an xml string to represent this people tag
|
|
* as a noun in an activitystreams feed.
|
|
*
|
|
* @param string $element the xml tag
|
|
*
|
|
* @return string activitystreams noun
|
|
*/
|
|
|
|
function asActivityNoun($element)
|
|
{
|
|
$noun = ActivityObject::fromPeopletag($this);
|
|
return $noun->asString('activity:' . $element);
|
|
}
|
|
|
|
/**
|
|
* get the cached number of profiles tagged with this
|
|
* people tag, re-count if the argument is true.
|
|
*
|
|
* @param boolean $recount whether to ignore cache
|
|
*
|
|
* @return integer count
|
|
*/
|
|
|
|
function taggedCount($recount=false)
|
|
{
|
|
$keypart = sprintf('profile_list:tagged_count:%d:%s',
|
|
$this->tagger,
|
|
$this->tag);
|
|
|
|
$count = self::cacheGet($keypart);
|
|
|
|
if ($count === false) {
|
|
$tags = new Profile_tag();
|
|
|
|
$tags->tag = $this->tag;
|
|
$tags->tagger = $this->tagger;
|
|
|
|
$count = $tags->count('distinct tagged');
|
|
|
|
self::cacheSet($keypart, $count);
|
|
}
|
|
|
|
return $count;
|
|
}
|
|
|
|
/**
|
|
* get the cached number of profiles subscribed to this
|
|
* people tag, re-count if the argument is true.
|
|
*
|
|
* @param boolean $recount whether to ignore cache
|
|
*
|
|
* @return integer count
|
|
*/
|
|
|
|
function subscriberCount($recount=false)
|
|
{
|
|
$keypart = sprintf('profile_list:subscriber_count:%d',
|
|
$this->id);
|
|
|
|
$count = self::cacheGet($keypart);
|
|
|
|
if ($count === false) {
|
|
|
|
$sub = new Profile_tag_subscription();
|
|
$sub->profile_tag_id = $this->id;
|
|
$count = (int) $sub->count('distinct profile_id');
|
|
|
|
self::cacheSet($keypart, $count);
|
|
}
|
|
|
|
return $count;
|
|
}
|
|
|
|
/**
|
|
* get the cached number of profiles subscribed to this
|
|
* people tag, re-count if the argument is true.
|
|
*
|
|
* @param boolean $recount whether to ignore cache
|
|
*
|
|
* @return integer count
|
|
*/
|
|
|
|
function blowNoticeStreamCache($all=false)
|
|
{
|
|
self::blow('profile_list:notice_ids:%d', $this->id);
|
|
if ($all) {
|
|
self::blow('profile_list:notice_ids:%d;last', $this->id);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get the Profile_list object by the
|
|
* given tagger and with given tag
|
|
*
|
|
* @param integer $tagger the id of the creator profile
|
|
* @param integer $tag the tag
|
|
*
|
|
* @return integer count
|
|
*/
|
|
|
|
static function getByTaggerAndTag($tagger, $tag)
|
|
{
|
|
$ptag = Profile_list::pkeyGet(array('tagger' => $tagger, 'tag' => $tag));
|
|
return $ptag;
|
|
}
|
|
|
|
/**
|
|
* create a profile_list record for a tag, tagger pair
|
|
* if it doesn't exist, return it.
|
|
*
|
|
* @param integer $tagger the tagger
|
|
* @param string $tag the tag
|
|
* @param string $description description
|
|
* @param boolean $private protected or not
|
|
*
|
|
* @return Profile_list the people tag object
|
|
*/
|
|
|
|
static function ensureTag($tagger, $tag, $description=null, $private=false)
|
|
{
|
|
$ptag = Profile_list::getByTaggerAndTag($tagger, $tag);
|
|
|
|
if(empty($ptag->id)) {
|
|
$args = array(
|
|
'tag' => $tag,
|
|
'tagger' => $tagger,
|
|
'description' => $description,
|
|
'private' => $private
|
|
);
|
|
|
|
$new_tag = Profile_list::saveNew($args);
|
|
|
|
return $new_tag;
|
|
}
|
|
return $ptag;
|
|
}
|
|
|
|
/**
|
|
* get the maximum number of characters
|
|
* that can be used in the description of
|
|
* a people tag.
|
|
*
|
|
* determined by $config['peopletag']['desclimit']
|
|
* if not set, falls back to $config['site']['textlimit']
|
|
*
|
|
* @return integer maximum number of characters
|
|
*/
|
|
|
|
static function maxDescription()
|
|
{
|
|
$desclimit = common_config('peopletag', 'desclimit');
|
|
// null => use global limit (distinct from 0!)
|
|
if (is_null($desclimit)) {
|
|
$desclimit = common_config('site', 'textlimit');
|
|
}
|
|
return $desclimit;
|
|
}
|
|
|
|
/**
|
|
* check if the length of given text exceeds
|
|
* character limit.
|
|
*
|
|
* @param string $desc the description
|
|
*
|
|
* @return boolean is the descripition too long?
|
|
*/
|
|
|
|
static function descriptionTooLong($desc)
|
|
{
|
|
$desclimit = self::maxDescription();
|
|
return ($desclimit > 0 && !empty($desc) && (mb_strlen($desc) > $desclimit));
|
|
}
|
|
|
|
/**
|
|
* save a new people tag, this should be always used
|
|
* since it makes uri, homeurl, created and modified
|
|
* timestamps and performs checks.
|
|
*
|
|
* @param array $fields an array with fields and their values
|
|
*
|
|
* @return mixed Profile_list on success, false on fail
|
|
*/
|
|
static function saveNew(array $fields) {
|
|
extract($fields);
|
|
|
|
$ptag = new Profile_list();
|
|
|
|
$ptag->query('BEGIN');
|
|
|
|
if (empty($tagger)) {
|
|
// TRANS: Server exception saving new tag without having a tagger specified.
|
|
throw new Exception(_('No tagger specified.'));
|
|
}
|
|
|
|
if (empty($tag)) {
|
|
// TRANS: Server exception saving new tag without having a tag specified.
|
|
throw new Exception(_('No tag specified.'));
|
|
}
|
|
|
|
if (empty($mainpage)) {
|
|
$mainpage = null;
|
|
}
|
|
|
|
if (empty($uri)) {
|
|
// fill in later...
|
|
$uri = null;
|
|
}
|
|
|
|
if (empty($mainpage)) {
|
|
$mainpage = null;
|
|
}
|
|
|
|
if (empty($description)) {
|
|
$description = null;
|
|
}
|
|
|
|
if (empty($private)) {
|
|
$private = false;
|
|
}
|
|
|
|
$ptag->tagger = $tagger;
|
|
$ptag->tag = $tag;
|
|
$ptag->description = $description;
|
|
$ptag->private = $private;
|
|
$ptag->uri = $uri;
|
|
$ptag->mainpage = $mainpage;
|
|
$ptag->created = common_sql_now();
|
|
$ptag->modified = common_sql_now();
|
|
|
|
$result = $ptag->insert();
|
|
|
|
if (!$result) {
|
|
common_log_db_error($ptag, 'INSERT', __FILE__);
|
|
// TRANS: Server exception saving new tag.
|
|
throw new ServerException(_('Could not create profile tag.'));
|
|
}
|
|
|
|
if (!isset($uri) || empty($uri)) {
|
|
$orig = clone($ptag);
|
|
$ptag->uri = common_local_url('profiletagbyid', array('id' => $ptag->id, 'tagger_id' => $ptag->tagger));
|
|
$result = $ptag->update($orig);
|
|
if (!$result) {
|
|
common_log_db_error($ptag, 'UPDATE', __FILE__);
|
|
// TRANS: Server exception saving new tag.
|
|
throw new ServerException(_('Could not set profile tag URI.'));
|
|
}
|
|
}
|
|
|
|
if (!isset($mainpage) || empty($mainpage)) {
|
|
$orig = clone($ptag);
|
|
$user = User::getKV('id', $ptag->tagger);
|
|
if(!empty($user)) {
|
|
$ptag->mainpage = common_local_url('showprofiletag', array('tag' => $ptag->tag, 'nickname' => $user->getNickname()));
|
|
} else {
|
|
$ptag->mainpage = $uri; // assume this is a remote peopletag and the uri works
|
|
}
|
|
|
|
$result = $ptag->update($orig);
|
|
if (!$result) {
|
|
common_log_db_error($ptag, 'UPDATE', __FILE__);
|
|
// TRANS: Server exception saving new tag.
|
|
throw new ServerException(_('Could not set profile tag mainpage.'));
|
|
}
|
|
}
|
|
return $ptag;
|
|
}
|
|
|
|
/**
|
|
* get all items at given cursor position for api
|
|
*
|
|
* @param callback $fn a function that takes the following arguments in order:
|
|
* $offset, $limit, $since_id, $max_id
|
|
* and returns a Profile_list object after making the DB query
|
|
* @param array $args arguments required for $fn
|
|
* @param integer $cursor the cursor
|
|
* @param integer $count max. number of results
|
|
*
|
|
* Algorithm:
|
|
* - if cursor is 0, return empty list
|
|
* - if cursor is -1, get first 21 items, next_cursor = 20th prev_cursor = 0
|
|
* - if cursor is +ve get 22 consecutive items before starting at cursor
|
|
* - return items[1..20] if items[0] == cursor else return items[0..21]
|
|
* - prev_cursor = items[1]
|
|
* - next_cursor = id of the last item being returned
|
|
*
|
|
* - if cursor is -ve get 22 consecutive items after cursor starting at cursor
|
|
* - return items[1..20]
|
|
*
|
|
* @returns array (array (mixed items), int next_cursor, int previous_cursor)
|
|
*/
|
|
|
|
// XXX: This should be in Memcached_DataObject... eventually.
|
|
|
|
static function getAtCursor($fn, array $args, $cursor, $count=20)
|
|
{
|
|
$items = array();
|
|
|
|
$since_id = 0;
|
|
$max_id = 0;
|
|
$next_cursor = 0;
|
|
$prev_cursor = 0;
|
|
|
|
if($cursor > 0) {
|
|
// if cursor is +ve fetch $count+2 items before cursor starting at cursor
|
|
$max_id = $cursor;
|
|
$fn_args = array_merge($args, array(0, $count+2, 0, $max_id));
|
|
$list = call_user_func_array($fn, $fn_args);
|
|
while($list->fetch()) {
|
|
$items[] = clone($list);
|
|
}
|
|
|
|
if ((isset($items[0]->cursor) && $items[0]->cursor == $cursor) ||
|
|
$items[0]->id == $cursor) {
|
|
array_shift($items);
|
|
$prev_cursor = isset($items[0]->cursor) ?
|
|
-$items[0]->cursor : -$items[0]->id;
|
|
} else {
|
|
if (count($items) > $count+1) {
|
|
array_shift($items);
|
|
}
|
|
// this means the cursor item has been deleted, check to see if there are more
|
|
$fn_args = array_merge($args, array(0, 1, $cursor));
|
|
$more = call_user_func($fn, $fn_args);
|
|
if (!$more->fetch() || empty($more)) {
|
|
// no more items.
|
|
$prev_cursor = 0;
|
|
} else {
|
|
$prev_cursor = isset($items[0]->cursor) ?
|
|
-$items[0]->cursor : -$items[0]->id;
|
|
}
|
|
}
|
|
|
|
if (count($items)==$count+1) {
|
|
// this means there is a next page.
|
|
$next = array_pop($items);
|
|
$next_cursor = isset($next->cursor) ?
|
|
$items[$count-1]->cursor : $items[$count-1]->id;
|
|
}
|
|
|
|
} else if($cursor < -1) {
|
|
// if cursor is -ve fetch $count+2 items created after -$cursor-1
|
|
$cursor = abs($cursor);
|
|
$since_id = $cursor-1;
|
|
|
|
$fn_args = array_merge($args, array(0, $count+2, $since_id));
|
|
$list = call_user_func_array($fn, $fn_args);
|
|
while($list->fetch()) {
|
|
$items[] = clone($list);
|
|
}
|
|
|
|
$end = count($items)-1;
|
|
if ((isset($items[$end]->cursor) && $items[$end]->cursor == $cursor) ||
|
|
$items[$end]->id == $cursor) {
|
|
array_pop($items);
|
|
$next_cursor = isset($items[$end-1]->cursor) ?
|
|
$items[$end-1]->cursor : $items[$end-1]->id;
|
|
} else {
|
|
$next_cursor = isset($items[$end]->cursor) ?
|
|
$items[$end]->cursor : $items[$end]->id;
|
|
if ($end > $count) array_pop($items); // excess item.
|
|
|
|
// check if there are more items for next page
|
|
$fn_args = array_merge($args, array(0, 1, 0, $cursor));
|
|
$more = call_user_func_array($fn, $fn_args);
|
|
if (!$more->fetch() || empty($more)) {
|
|
$next_cursor = 0;
|
|
}
|
|
}
|
|
|
|
if (count($items) == $count+1) {
|
|
// this means there is a previous page.
|
|
$prev = array_shift($items);
|
|
$prev_cursor = isset($prev->cursor) ?
|
|
-$items[0]->cursor : -$items[0]->id;
|
|
}
|
|
} else if($cursor == -1) {
|
|
$fn_args = array_merge($args, array(0, $count+1));
|
|
$list = call_user_func_array($fn, $fn_args);
|
|
|
|
while($list->fetch()) {
|
|
$items[] = clone($list);
|
|
}
|
|
|
|
if (count($items)==$count+1) {
|
|
$next = array_pop($items);
|
|
if(isset($next->cursor)) {
|
|
$next_cursor = $items[$count-1]->cursor;
|
|
} else {
|
|
$next_cursor = $items[$count-1]->id;
|
|
}
|
|
}
|
|
|
|
}
|
|
return array($items, $next_cursor, $prev_cursor);
|
|
}
|
|
|
|
/**
|
|
* save a collection of people tags into the cache
|
|
*
|
|
* @param string $ckey cache key
|
|
* @param Profile_list &$tag the results to store
|
|
* @param integer $offset offset for slicing results
|
|
* @param integer $limit maximum number of results
|
|
*
|
|
* @return boolean success
|
|
*/
|
|
|
|
static function setCache($ckey, &$tag, $offset=0, $limit=null) {
|
|
$cache = Cache::instance();
|
|
if (empty($cache)) {
|
|
return false;
|
|
}
|
|
$str = '';
|
|
$tags = array();
|
|
while ($tag->fetch()) {
|
|
$str .= $tag->tagger . ':' . $tag->tag . ';';
|
|
$tags[] = clone($tag);
|
|
}
|
|
$str = substr($str, 0, -1);
|
|
if ($offset>=0 && !is_null($limit)) {
|
|
$tags = array_slice($tags, $offset, $limit);
|
|
}
|
|
|
|
$tag = new ArrayWrapper($tags);
|
|
|
|
return self::cacheSet($ckey, $str);
|
|
}
|
|
|
|
/**
|
|
* get people tags from the cache
|
|
*
|
|
* @param string $ckey cache key
|
|
* @param integer $offset offset for slicing
|
|
* @param integer $limit limit
|
|
*
|
|
* @return Profile_list results
|
|
*/
|
|
|
|
static function getCached($ckey, $offset=0, $limit=null) {
|
|
|
|
$keys_str = self::cacheGet($ckey);
|
|
if ($keys_str === false) {
|
|
return false;
|
|
}
|
|
|
|
$pairs = explode(';', $keys_str);
|
|
$keys = array();
|
|
foreach ($pairs as $pair) {
|
|
$keys[] = explode(':', $pair);
|
|
}
|
|
|
|
if ($offset>=0 && !is_null($limit)) {
|
|
$keys = array_slice($keys, $offset, $limit);
|
|
}
|
|
return self::getByKeys($keys);
|
|
}
|
|
|
|
/**
|
|
* get Profile_list objects from the database
|
|
* given their (tag, tagger) key pairs.
|
|
*
|
|
* @param array $keys array of array(tagger, tag)
|
|
*
|
|
* @return Profile_list results
|
|
*/
|
|
|
|
static function getByKeys(array $keys) {
|
|
$cache = Cache::instance();
|
|
|
|
if (!empty($cache)) {
|
|
$tags = array();
|
|
|
|
foreach ($keys as $key) {
|
|
$t = Profile_list::getByTaggerAndTag($key[0], $key[1]);
|
|
if (!empty($t)) {
|
|
$tags[] = $t;
|
|
}
|
|
}
|
|
return new ArrayWrapper($tags);
|
|
} else {
|
|
$tag = new Profile_list();
|
|
if (empty($keys)) {
|
|
//if no IDs requested, just return the tag object
|
|
return $tag;
|
|
}
|
|
|
|
$pairs = array();
|
|
foreach ($keys as $key) {
|
|
$pairs[] = '(' . $key[0] . ', "' . $key[1] . '")';
|
|
}
|
|
|
|
$tag->whereAdd('(tagger, tag) in (' . implode(', ', $pairs) . ')');
|
|
|
|
$tag->find();
|
|
|
|
$temp = array();
|
|
|
|
while ($tag->fetch()) {
|
|
$temp[$tag->tagger.'-'.$tag->tag] = clone($tag);
|
|
}
|
|
|
|
$wrapped = array();
|
|
|
|
foreach ($keys as $key) {
|
|
$id = $key[0].'-'.$key[1];
|
|
if (array_key_exists($id, $temp)) {
|
|
$wrapped[] = $temp[$id];
|
|
}
|
|
}
|
|
|
|
return new ArrayWrapper($wrapped);
|
|
}
|
|
}
|
|
|
|
function insert()
|
|
{
|
|
$result = parent::insert();
|
|
if ($result) {
|
|
self::blow('profile:lists:%d', $this->tagger);
|
|
}
|
|
return $result;
|
|
}
|
|
}
|