9a515b9234
Avoid the use of deprecated MariaDB "zero dates" globally. If they're present as attribute defaults somewhere, they will be replaced with NULL implicitly. The existing "zero dates" in MariaDB storage will be left intact and this should not present any issues. The "timestamp" type in table definitions now corresponds to DATETIME in MariaDB with "DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP", which should be close enough to the original behaviour for compatibility purposes. It is now the recommended type for "modified" attributes, because of the update trigger on MariaDB. But there is no such trigger implemented on PostgreSQL as of this moment.
951 lines
30 KiB
PHP
951 lines
30 KiB
PHP
<?php
|
|
// This file is part of GNU social - https://www.gnu.org/software/social
|
|
//
|
|
// GNU social 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.
|
|
//
|
|
// GNU social 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 GNU social. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* @category Notices
|
|
* @package GNUsocial
|
|
* @author Shashi Gowda <connect2shashi@gmail.com>
|
|
* @copyright 2019 Free Software Foundation, Inc http://www.fsf.org
|
|
* @license https://www.gnu.org/licenses/agpl.html GNU AGPL v3 or later
|
|
*/
|
|
|
|
defined('GNUSOCIAL') || die();
|
|
|
|
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; // bool default_false
|
|
public $created; // datetime()
|
|
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' => 'bool', 'default' => false, 'description' => 'is this tag private'),
|
|
|
|
'created' => array('type' => 'datetime', '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
|
|
*/
|
|
|
|
public function getTagger()
|
|
{
|
|
return Profile::getByID($this->tagger);
|
|
}
|
|
|
|
/**
|
|
* return a string to identify this
|
|
* profile_list in the user interface etc.
|
|
*
|
|
* @return String
|
|
*/
|
|
|
|
public function getBestName()
|
|
{
|
|
return $this->tag;
|
|
}
|
|
|
|
/**
|
|
* return a uri string for this profile_list
|
|
*
|
|
* @return String uri
|
|
*/
|
|
|
|
public function getUri()
|
|
{
|
|
$uri = null;
|
|
if (Event::handle('StartProfiletagGetUri', array($this, &$uri))) {
|
|
if (!empty($this->uri)) {
|
|
$uri = $this->uri;
|
|
} else {
|
|
$uri = common_local_url(
|
|
'profiletagbyid',
|
|
['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
|
|
*/
|
|
|
|
public 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',
|
|
[
|
|
'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
|
|
*/
|
|
|
|
public function permalink()
|
|
{
|
|
$url = null;
|
|
if (Event::handle('StartProfiletagPermalink', array($this, &$url))) {
|
|
$url = common_local_url(
|
|
'profiletagbyid',
|
|
['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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public function getSubscribers(int $offset = 0, ?int $limit = null, int $since = 0, int $upto = 0)
|
|
{
|
|
$subs = new Profile();
|
|
|
|
$subs->joinAdd(
|
|
array('id', 'profile_tag_subscription:profile_id')
|
|
);
|
|
$subs->whereAdd('profile_tag_subscription.profile_tag_id = ' . $this->id);
|
|
|
|
if (common_config('db', 'type') !== 'mysql') {
|
|
$subs->selectAdd(sprintf(
|
|
'((EXTRACT(DAY %1$s) * 24 + EXTRACT(HOUR %1$s)) * 60 + ' .
|
|
'EXTRACT(MINUTE %1$s)) * 60 + FLOOR(EXTRACT(SECOND %1$s)) AS "cursor"',
|
|
"FROM (profile_tag_subscription.created - TIMESTAMP '1970-01-01 00:00:00')"
|
|
));
|
|
} else {
|
|
$subs->selectAdd("timestampdiff(SECOND, '1970-01-01', 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
|
|
*/
|
|
|
|
public function getUserSubscribers()
|
|
{
|
|
// XXX: cache this
|
|
|
|
$user = new User();
|
|
|
|
$user->query(sprintf(
|
|
'SELECT id ' .
|
|
'FROM %1$s INNER JOIN profile_tag_subscription ' .
|
|
'ON %1$s.id = profile_tag_subscription.profile_id ' .
|
|
'WHERE profile_tag_subscription.profile_tag_id = %2$d ',
|
|
$user->escapedTableName(),
|
|
$this->id
|
|
));
|
|
|
|
$ids = [];
|
|
|
|
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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public function getTagged(int $offset = 0, ?int $limit = null, int $since = 0, int $upto = 0)
|
|
{
|
|
$tagged = new Profile();
|
|
$tagged->joinAdd(['id', 'profile_tag:tagged']);
|
|
|
|
if (common_config('db', 'type') !== 'mysql') {
|
|
$tagged->selectAdd(sprintf(
|
|
'((EXTRACT(DAY %1$s) * 24 + EXTRACT(HOUR %1$s)) * 60 + ' .
|
|
'EXTRACT(MINUTE %1$s)) * 60 + FLOOR(EXTRACT(SECOND %1$s)) AS "cursor"',
|
|
"FROM (profile_tag.modified - TIMESTAMP '1970-01-01 00:00:00')"
|
|
));
|
|
} else {
|
|
$tagged->selectAdd("timestampdiff(SECOND, '1970-01-01', 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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public 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?
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
public static function saveNew(array $fields)
|
|
{
|
|
extract($fields);
|
|
|
|
$ptag = new Profile_list();
|
|
|
|
$ptag->query('START TRANSACTION');
|
|
|
|
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
|
|
|
|
public 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;
|
|
}
|
|
} elseif ($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) {
|
|
// excess item
|
|
array_pop($items);
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
} elseif ($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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public 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
|
|
*/
|
|
|
|
public 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);
|
|
}
|
|
}
|
|
|
|
public function insert()
|
|
{
|
|
$result = parent::insert();
|
|
if ($result) {
|
|
self::blow('profile:lists:%d', $this->tagger);
|
|
}
|
|
return $result;
|
|
}
|
|
}
|