public $object_type; // varchar(255)
public $scope; // int(4)
- /* Static get */
- function staticGet($k,$v=NULL)
- {
- return Memcached_DataObject::staticGet('Notice',$k,$v);
- }
-
/* the code above is auto generated do not remove the tag below */
###END_AUTOCODE
'notice_repeat_of_fkey' => array('notice', array('repeat_of' => 'id')), # @fixme: what about repeats of deleted notices?
),
'indexes' => array(
+ 'notice_created_id_is_local_idx' => array('created', 'id', 'is_local'),
'notice_profile_id_idx' => array('profile_id', 'created', 'id'),
- 'notice_conversation_idx' => array('conversation'),
- 'notice_created_idx' => array('created'),
- 'notice_replyto_idx' => array('reply_to'),
- 'notice_repeatof_idx' => array('repeat_of'),
+ 'notice_repeat_of_created_id_idx' => array('repeat_of', 'created', 'id'),
+ 'notice_conversation_created_id_idx' => array('conversation', 'created', 'id'),
+ 'notice_replyto_idx' => array('reply_to')
)
);
return $def;
}
-
- function multiGet($kc, $kvs, $skipNulls=true)
- {
- return Memcached_DataObject::multiGet('Notice', $kc, $kvs, $skipNulls);
- }
/* Notice types */
const LOCAL_PUBLIC = 1;
protected $_profile = -1;
- function getProfile()
+ public function getProfile()
{
- if (is_int($this->_profile) && $this->_profile == -1) {
- $this->_setProfile(Profile::staticGet('id', $this->profile_id));
-
- if (empty($this->_profile)) {
- // TRANS: Server exception thrown when a user profile for a notice cannot be found.
- // TRANS: %1$d is a profile ID (number), %2$d is a notice ID (number).
- throw new ServerException(sprintf(_('No such profile (%1$d) for notice (%2$d).'), $this->profile_id, $this->id));
- }
+ if ($this->_profile === -1) {
+ $this->_setProfile(Profile::getKV('id', $this->profile_id));
+ }
+ if (!$this->_profile instanceof Profile) {
+ throw new NoProfileException($this->profile_id);
}
-
return $this->_profile;
}
- function _setProfile($profile)
+ function _setProfile(Profile $profile)
{
$this->_profile = $profile;
}
// @fixme we have some cases where things get re-run and so the
// insert fails.
- $deleted = Deleted_notice::staticGet('id', $this->id);
+ $deleted = Deleted_notice::getKV('id', $this->id);
if (!$deleted) {
- $deleted = Deleted_notice::staticGet('uri', $this->uri);
+ $deleted = Deleted_notice::getKV('uri', $this->uri);
}
if (!$deleted) {
return $result;
}
+ public function getUri()
+ {
+ return $this->uri;
+ }
+
+ public function getUrl()
+ {
+ // The risk is we start having empty urls and non-http uris...
+ return $this->url ?: $this->uri;
+ }
+
/**
* Extract #hashtags from this notice's content and save them to the database.
*/
* @return Notice
* @throws ClientException
*/
- static function saveNew($profile_id, $content, $source, $options=null) {
+ static function saveNew($profile_id, $content, $source, array $options=null) {
$defaults = array('uri' => null,
'url' => null,
'reply_to' => null,
$is_local = Notice::LOCAL_PUBLIC;
}
- $profile = Profile::staticGet('id', $profile_id);
- $user = User::staticGet('id', $profile_id);
+ $profile = Profile::getKV('id', $profile_id);
+ $user = User::getKV('id', $profile_id);
if ($user) {
// Use the local user's shortening preferences, if applicable.
$final = $user->shortenLinks($content);
// Check for a private one
- $repeat = Notice::staticGet('id', $repeat_of);
+ $repeat = Notice::getKV('id', $repeat_of);
- if (empty($repeat)) {
+ if (!($repeat instanceof Notice)) {
// TRANS: Client exception thrown in notice when trying to repeat a missing or deleted notice.
throw new ClientException(_('Cannot repeat; original notice is missing or deleted.'));
}
throw new ClientException(_('Cannot repeat a notice you cannot read.'), 403);
}
- if ($profile->hasRepeated($repeat->id)) {
+ if ($profile->hasRepeated($repeat)) {
// TRANS: Client error displayed when trying to repeat an already repeated notice.
throw new ClientException(_('You already repeated that notice.'));
}
// If the original is private to a group, and notice has no group specified,
// make it to the same group(s)
- if (empty($groups) && ($reply->scope | Notice::GROUP_SCOPE)) {
+ if (empty($groups) && ($reply->scope & Notice::GROUP_SCOPE)) {
$groups = array();
$replyGroups = $reply->getGroups();
foreach ($replyGroups as $group) {
// For private streams
- $user = $profile->getUser();
+ try {
+ $user = $profile->getUser();
- if (!empty($user)) {
if ($user->private_stream &&
($notice->scope == Notice::PUBLIC_SCOPE ||
$notice->scope == Notice::SITE_SCOPE)) {
$notice->scope |= Notice::FOLLOWER_SCOPE;
}
+ } catch (NoSuchUserException $e) {
+ // Cannot handle private streams for remote profiles
}
// Force the scope for private groups
foreach ($groups as $groupId) {
- $group = User_group::staticGet('id', $groupId);
+ $group = User_group::getKV('id', $groupId);
if (!empty($group)) {
if ($group->force_scope) {
$notice->scope |= Notice::GROUP_SCOPE;
}
self::blow('notice:list-ids:conversation:%s', $this->conversation);
- self::blow('conversation::notice_count:%d', $this->conversation);
+ self::blow('conversation:notice_count:%d', $this->conversation);
if (!empty($this->repeat_of)) {
// XXX: we should probably only use one of these
self::blow('notice:list-ids:repeat_of:%d', $this->repeat_of);
}
- $original = Notice::staticGet('id', $this->repeat_of);
+ $original = Notice::getKV('id', $this->repeat_of);
if (!empty($original)) {
- $originalUser = User::staticGet('id', $original->profile_id);
+ $originalUser = User::getKV('id', $original->profile_id);
if (!empty($originalUser)) {
$this->blowStream('user:repeats_of_me:%d', $originalUser->id);
}
}
- $profile = Profile::staticGet($this->profile_id);
+ $profile = Profile::getKV($this->profile_id);
if (!empty($profile)) {
$profile->blowNoticeCount();
if ($lastStr !== false) {
$window = explode(',', $lastStr);
$lastID = $window[0];
- $lastNotice = Notice::staticGet('id', $lastID);
+ $lastNotice = Notice::getKV('id', $lastID);
if (empty($lastNotice) // just weird
|| strtotime($lastNotice->created) >= strtotime($this->created)) {
$c->delete($lastKey);
}
static function checkDupes($profile_id, $content) {
- $profile = Profile::staticGet($profile_id);
+ $profile = Profile::getKV($profile_id);
if (empty($profile)) {
return false;
}
}
static function checkEditThrottle($profile_id) {
- $profile = Profile::staticGet($profile_id);
+ $profile = Profile::getKV($profile_id);
if (empty($profile)) {
return false;
}
return $this->_attachments;
}
- $f2ps = Memcached_DataObject::listGet('File_to_post', 'post_id', array($this->id));
+ $f2ps = File_to_post::listGet('post_id', array($this->id));
$ids = array();
$ids[] = $f2p->file_id;
}
- $files = Memcached_DataObject::multiGet('File', 'id', $ids);
+ $files = File::multiGet('id', $ids);
$this->_attachments = $files->fetchAll();
if ($root !== false && $root->inScope($profile)) {
return $root;
- } else {
- $last = $this;
+ }
- do {
- $parent = $last->getOriginal();
- if (!empty($parent) && $parent->inScope($profile)) {
+ $last = $this;
+ while (true) {
+ try {
+ $parent = $last->getParent();
+ if ($parent->inScope($profile)) {
$last = $parent;
continue;
- } else {
- $root = $last;
- break;
}
- } while (!empty($parent));
-
- self::cacheSet($keypart, $root);
+ } catch (Exception $e) {
+ // Latest notice has no parent
+ }
+ // No parent, or parent out of scope
+ $root = $last;
+ break;
}
+ self::cacheSet($keypart, $root);
+
return $root;
}
* if left empty, will be loaded from reply records
* @return array associating recipient user IDs with an inbox source constant
*/
- function whoGets($groups=null, $recipients=null)
+ function whoGets(array $groups=null, array $recipients=null)
{
$c = self::memcache();
$users = $ptag->getUserSubscribers();
foreach ($users as $id) {
if (!array_key_exists($id, $ni)) {
- $user = User::staticGet('id', $id);
- if (!$user->hasBlocked($profile)) {
- $ni[$id] = NOTICE_INBOX_SOURCE_PROFILE_TAG;
- }
+ $ni[$id] = NOTICE_INBOX_SOURCE_PROFILE_TAG;
}
}
}
if (!array_key_exists($recipient, $ni)) {
$ni[$recipient] = NOTICE_INBOX_SOURCE_REPLY;
}
+ }
- // Exclude any deleted, non-local, or blocking recipients.
- $profile = $this->getProfile();
- $originalProfile = null;
- if ($this->repeat_of) {
- // Check blocks against the original notice's poster as well.
- $original = Notice::staticGet('id', $this->repeat_of);
- if ($original) {
- $originalProfile = $original->getProfile();
- }
+ // Exclude any deleted, non-local, or blocking recipients.
+ $profile = $this->getProfile();
+ $originalProfile = null;
+ if ($this->repeat_of) {
+ // Check blocks against the original notice's poster as well.
+ $original = Notice::getKV('id', $this->repeat_of);
+ if ($original) {
+ $originalProfile = $original->getProfile();
}
- foreach ($ni as $id => $source) {
- $user = User::staticGet('id', $id);
- if (empty($user) || $user->hasBlocked($profile) ||
+ }
+
+ foreach ($ni as $id => $source) {
+ try {
+ $user = User::getKV('id', $id);
+ if (empty($user) ||
+ $user->hasBlocked($profile) ||
($originalProfile && $user->hasBlocked($originalProfile))) {
unset($ni[$id]);
}
+ } catch (UserNoProfileException $e) {
+ // User doesn't have a profile; invalid; skip them.
+ unset($ni[$id]);
}
}
* @param array $recipient optional list of reply profile ids
* if left empty, will be loaded from reply records
*/
- function addToInboxes($groups=null, $recipients=null)
+ function addToInboxes(array $groups=null, array $recipients=null)
{
$ni = $this->whoGets($groups, $recipients);
$groups = array();
foreach (array_unique($group_ids) as $id) {
- $group = User_group::staticGet('id', $id);
+ $group = User_group::getKV('id', $id);
if ($group) {
common_log(LOG_ERR, "Local delivery to group id $id, $group->nickname");
$result = $this->addToGroupInbox($group);
*
* Mail notifications etc will be handled later.
*
- * @param array of unique identifier URIs for recipients
+ * @param array $uris Array of unique identifier URIs for recipients
*/
- function saveKnownReplies($uris)
+ function saveKnownReplies(array $uris)
{
if (empty($uris)) {
return;
}
- $sender = Profile::staticGet($this->profile_id);
+ $sender = Profile::getKV($this->profile_id);
foreach (array_unique($uris) as $uri) {
return array();
}
- $sender = Profile::staticGet($this->profile_id);
+ $sender = Profile::getKV($this->profile_id);
$replied = array();
// If it's a reply, save for the replied-to author
-
- if (!empty($this->reply_to)) {
- $original = $this->getOriginal();
- if (!empty($original)) { // that'd be weird
- $author = $original->getProfile();
- if (!empty($author)) {
- $this->saveReply($author->id);
- $replied[$author->id] = 1;
- self::blow('reply:stream:%d', $author->id);
- }
+ try {
+ $parent = $this->getParent();
+ $author = $parent->getProfile();
+ if ($author instanceof Profile) {
+ $this->saveReply($author->id);
+ $replied[$author->id] = 1;
+ self::blow('reply:stream:%d', $author->id);
}
+ } catch (Exception $e) {
+ // Not a reply, since it has no parent!
}
// @todo ideally this parser information would only
// Don't save replies from blocked profile to local user
- $mentioned_user = User::staticGet('id', $mentioned->id);
+ $mentioned_user = User::getKV('id', $mentioned->id);
if (!empty($mentioned_user) && $mentioned_user->hasBlocked($sender)) {
continue;
}
return $this->_replies;
}
- $replyMap = Memcached_DataObject::listGet('Reply', 'notice_id', array($this->id));
+ $replyMap = Reply::listGet('notice_id', array($this->id));
$ids = array();
$recipientIds = $this->getReplies();
foreach ($recipientIds as $recipientId) {
- $user = User::staticGet('id', $recipientId);
+ $user = User::getKV('id', $recipientId);
if (!empty($user)) {
mail_notify_attn($user, $this);
}
return $this->_groups;
}
- $gis = Memcached_DataObject::listGet('Group_inbox', 'notice_id', array($this->id));
+ $gis = Group_inbox::listGet('notice_id', array($this->id));
$ids = array();
* @return Activity activity object representing this Notice.
*/
- function asActivity($cur)
+ function asActivity($cur=null)
{
$act = self::cacheGet(Cache::codeKey('notice:as-activity:'.$this->id));
$act->time = strtotime($this->created);
$act->link = $this->bestUrl();
$act->content = common_xml_safe_str($this->rendered);
- $act->title = common_xml_safe_str($this->content);
$profile = $this->getProfile();
$act->verb = $this->verb;
if ($this->repeat_of) {
- $repeated = Notice::staticGet('id', $this->repeat_of);
- $act->objects[] = $repeated->asActivity($cur);
+ $repeated = Notice::getKV('id', $this->repeat_of);
+ if (!empty($repeated)) {
+ $act->objects[] = $repeated->asActivity($cur);
+ }
} else {
$act->objects[] = ActivityObject::fromNotice($this);
}
$attachments = $this->attachments();
foreach ($attachments as $attachment) {
- $enclosure = $attachment->getEnclosure();
- if ($enclosure) {
- $act->enclosures[] = $enclosure;
+ // Save local attachments
+ if (!empty($attachment->filename)) {
+ $act->attachments[] = ActivityObject::fromFile($attachment);
}
}
$ctx = new ActivityContext();
if (!empty($this->reply_to)) {
- $reply = Notice::staticGet('id', $this->reply_to);
+ $reply = Notice::getKV('id', $this->reply_to);
if (!empty($reply)) {
$ctx->replyToID = $reply->uri;
$ctx->replyToUrl = $reply->bestUrl();
$conv = null;
if (!empty($this->conversation)) {
- $conv = Conversation::staticGet('id', $this->conversation);
+ $conv = Conversation::getKV('id', $this->conversation);
if (!empty($conv)) {
$ctx->conversation = $conv->uri;
}
$reply_ids = $this->getReplies();
foreach ($reply_ids as $id) {
- $rprofile = Profile::staticGet('id', $id);
+ $rprofile = Profile::getKV('id', $id);
if (!empty($rprofile)) {
$ctx->attention[] = $rprofile->getUri();
+ $ctx->attentionType[$rprofile->getUri()] = ActivityObject::PERSON;
}
}
foreach ($groups as $group) {
$ctx->attention[] = $group->getUri();
+ $ctx->attentionType[$group->getUri()] = ActivityObject::GROUP;
}
- // XXX: deprecated; use ActivityVerb::SHARE instead
-
- $repeat = null;
-
- if (!empty($this->repeat_of)) {
- $repeat = Notice::staticGet('id', $this->repeat_of);
- if (!empty($repeat)) {
- $ctx->forwardID = $repeat->uri;
- $ctx->forwardUrl = $repeat->bestUrl();
- }
+ switch ($this->scope) {
+ case Notice::PUBLIC_SCOPE:
+ $ctx->attention[] = "http://activityschema.org/collection/public";
+ $ctx->attentionType["http://activityschema.org/collection/public"] = ActivityObject::COLLECTION;
+ break;
+ case Notice::FOLLOWER_SCOPE:
+ $surl = common_local_url("subscribers", array('nickname' => $profile->nickname));
+ $ctx->attention[] = $surl;
+ $ctx->attentionType[$surl] = ActivityObject::COLLECTION;
+ break;
}
$act->context = $ctx;
+ $source = $this->getSource();
+
+ if ($source) {
+ $act->generator = ActivityObject::fromNoticeSource($source);
+ }
+
// Source
$atom_feed = $profile->getAtomFeed();
$act->source->updated = self::utcDate($notice->created);
}
- $user = User::staticGet('id', $profile->id);
+ $user = User::getKV('id', $profile->id);
if (!empty($user)) {
$act->source->links['license'] = common_config('license', 'url');
// favorite and repeated
if (!empty($cur)) {
- $noticeInfoAttr['favorite'] = ($cur->hasFave($this)) ? "true" : "false";
$cp = $cur->getProfile();
- $noticeInfoAttr['repeated'] = ($cp->hasRepeated($this->id)) ? "true" : "false";
+ $noticeInfoAttr['favorite'] = ($cp->hasFave($this)) ? "true" : "false";
+ $noticeInfoAttr['repeated'] = ($cp->hasRepeated($this)) ? "true" : "false";
}
if (!empty($this->repeat_of)) {
// return it if it does
if (!empty($reply_to)) {
- $reply_notice = Notice::staticGet('id', $reply_to);
+ $reply_notice = Notice::getKV('id', $reply_to);
if (!empty($reply_notice)) {
return $reply_notice;
}
// Figure out who that is.
- $sender = Profile::staticGet('id', $profile_id);
+ $sender = Profile::getKV('id', $profile_id);
if (empty($sender)) {
return null;
}
*/
function repeat($repeater_id, $source)
{
- $author = Profile::staticGet('id', $this->profile_id);
+ $author = Profile::getKV('id', $this->profile_id);
// TRANS: Message used to repeat a notice. RT is the abbreviation of 'retweet'.
// TRANS: %1$s is the repeated user's name, %2$s is the repeated notice.
// have to wait
Event::handle('StartNoticeDistribute', array($this));
- $user = User::staticGet('id', $this->profile_id);
+ $user = User::getKV('id', $this->profile_id);
if (!empty($user)) {
Inbox::insertNotice($user->id, $this->id);
}
$ns->code = $this->source;
break;
default:
- $ns = Notice_source::staticGet($this->source);
+ $ns = Notice_source::getKV($this->source);
if (!$ns) {
$ns = new Notice_source();
$ns->code = $this->source;
- $app = Oauth_application::staticGet('name', $this->source);
+ $app = Oauth_application::getKV('name', $this->source);
if ($app) {
$ns->name = $app->name;
$ns->url = $app->source_url;
return false;
}
- $notice = Notice::staticGet('id', $id);
+ $notice = Notice::getKV('id', $id);
if ($notice) {
return $notice->created;
}
- $deleted = Deleted_notice::staticGet('id', $id);
+ $deleted = Deleted_notice::getKV('id', $id);
if ($deleted) {
return $deleted->created;
}
$result = self::cacheGet($keypart);
if ($result === false) {
- $bResult = $this->_inScope($profile);
+ $bResult = false;
+ if (Event::handle('StartNoticeInScope', array($this, $profile, &$bResult))) {
+ $bResult = $this->_inScope($profile);
+ Event::handle('EndNoticeInScope', array($this, $profile, &$bResult));
+ }
$result = ($bResult) ? 1 : 0;
self::cacheSet($keypart, $result, 0, 300);
}
// If there's no scope, anyone (even anon) is in scope.
- if ($scope == 0) {
- return true;
- }
+ if ($scope == 0) { // Not private
- // If there's scope, anon cannot be in scope
+ return !$this->isHiddenSpam($profile);
- if (empty($profile)) {
- return false;
- }
+ } else { // Private, somehow
- // Author is always in scope
+ // If there's scope, anon cannot be in scope
- if ($this->profile_id == $profile->id) {
- return true;
- }
+ if (empty($profile)) {
+ return false;
+ }
- // Only for users on this site
+ // Author is always in scope
- if ($scope & Notice::SITE_SCOPE) {
- $user = $profile->getUser();
- if (empty($user)) {
+ if ($this->profile_id == $profile->id) {
+ return true;
+ }
+
+ // Only for users on this site
+
+ if (($scope & Notice::SITE_SCOPE) && !$profile->isLocal()) {
return false;
}
- }
- // Only for users mentioned in the notice
+ // Only for users mentioned in the notice
- if ($scope & Notice::ADDRESSEE_SCOPE) {
+ if ($scope & Notice::ADDRESSEE_SCOPE) {
- $repl = Reply::pkeyGet(array('notice_id' => $this->id,
- 'profile_id' => $profile->id));
+ $repl = Reply::pkeyGet(array('notice_id' => $this->id,
+ 'profile_id' => $profile->id));
- if (empty($repl)) {
- return false;
+ if (empty($repl)) {
+ return false;
+ }
}
- }
- // Only for members of the given group
+ // Only for members of the given group
- if ($scope & Notice::GROUP_SCOPE) {
+ if ($scope & Notice::GROUP_SCOPE) {
- // XXX: just query for the single membership
+ // XXX: just query for the single membership
- $groups = $this->getGroups();
+ $groups = $this->getGroups();
- $foundOne = false;
+ $foundOne = false;
- foreach ($groups as $group) {
- if ($profile->isMember($group)) {
- $foundOne = true;
- break;
+ foreach ($groups as $group) {
+ if ($profile->isMember($group)) {
+ $foundOne = true;
+ break;
+ }
+ }
+
+ if (!$foundOne) {
+ return false;
}
}
- if (!$foundOne) {
- return false;
+ // Only for followers of the author
+
+ $author = null;
+
+ if ($scope & Notice::FOLLOWER_SCOPE) {
+
+ try {
+ $author = $this->getProfile();
+ } catch (Exception $e) {
+ return false;
+ }
+
+ if (!Subscription::exists($profile, $author)) {
+ return false;
+ }
}
+
+ return !$this->isHiddenSpam($profile);
}
+ }
+
+ function isHiddenSpam($profile) {
+
+ // Hide posts by silenced users from everyone but moderators.
- // Only for followers of the author
+ if (common_config('notice', 'hidespam')) {
- if ($scope & Notice::FOLLOWER_SCOPE) {
- $author = $this->getProfile();
- if (!Subscription::exists($profile, $author)) {
- return false;
+ try {
+ $author = $this->getProfile();
+ } catch(Exception $e) {
+ // If we can't get an author, keep it hidden.
+ // XXX: technically not spam, but, whatever.
+ return true;
+ }
+
+ if ($author->hasRole(Profile_role::SILENCED)) {
+ if (empty($profile) || (($profile->id !== $author->id) && (!$profile->hasRight(Right::REVIEWSPAM)))) {
+ return true;
+ }
}
}
- return true;
+ return false;
}
static function groupsFromText($text, $profile)
return $groups;
}
- protected $_original = -1;
-
- function getOriginal()
+ public function getParent()
{
- if (is_int($this->_original) && $this->_original == -1) {
- if (empty($this->reply_to)) {
- $this->_original = null;
- } else {
- $this->_original = Notice::staticGet('id', $this->reply_to);
- }
+ $parent = Notice::getKV('id', $this->reply_to);
+
+ if (!$parent instanceof Notice) {
+ throw new ServerException('Notice has no parent');
}
- return $this->_original;
+
+ return $parent;
}
/**
function __sleep()
{
$vars = parent::__sleep();
- $skip = array('_original', '_profile', '_groups', '_attachments', '_faves', '_replies', '_repeats');
+ $skip = array('_profile', '_groups', '_attachments', '_faves', '_replies', '_repeats');
return array_diff($vars, $skip);
}
$ids = array_unique($ids);
- return Memcached_DataObject::pivotGet('Profile', 'id', $ids);
+ return Profile::pivotGet('id', $ids);
}
static function fillGroups(&$notices)
{
$ids = self::_idsOf($notices);
- $gis = Memcached_DataObject::listGet('Group_inbox', 'notice_id', $ids);
+ $gis = Group_inbox::listGet('notice_id', $ids);
$gids = array();
$gids = array_unique($gids);
- $group = Memcached_DataObject::pivotGet('User_group', 'id', $gids);
+ $group = User_group::pivotGet('id', $gids);
foreach ($notices as $notice)
{
{
$ids = self::_idsOf($notices);
- $f2pMap = Memcached_DataObject::listGet('File_to_post', 'post_id', $ids);
+ $f2pMap = File_to_post::listGet('post_id', $ids);
$fileIds = array();
$fileIds = array_unique($fileIds);
- $fileMap = Memcached_DataObject::pivotGet('File', 'id', $fileIds);
+ $fileMap = File::pivotGet('id', $fileIds);
foreach ($notices as $notice)
{
if (isset($this->_faves) && is_array($this->_faves)) {
return $this->_faves;
}
- $faveMap = Memcached_DataObject::listGet('Fave', 'notice_id', array($this->id));
+ $faveMap = Fave::listGet('notice_id', array($this->id));
$this->_faves = $faveMap[$this->id];
return $this->_faves;
}
static function fillFaves(&$notices)
{
$ids = self::_idsOf($notices);
- $faveMap = Memcached_DataObject::listGet('Fave', 'notice_id', $ids);
+ $faveMap = Fave::listGet('notice_id', $ids);
$cnt = 0;
$faved = array();
foreach ($faveMap as $id => $faves) {
static function fillReplies(&$notices)
{
$ids = self::_idsOf($notices);
- $replyMap = Memcached_DataObject::listGet('Reply', 'notice_id', $ids);
+ $replyMap = Reply::listGet('notice_id', $ids);
foreach ($notices as $notice) {
$replies = $replyMap[$notice->id];
$ids = array();
if (isset($this->_repeats) && is_array($this->_repeats)) {
return $this->_repeats;
}
- $repeatMap = Memcached_DataObject::listGet('Notice', 'repeat_of', array($this->id));
+ $repeatMap = Notice::listGet('repeat_of', array($this->id));
$this->_repeats = $repeatMap[$this->id];
return $this->_repeats;
}
static function fillRepeats(&$notices)
{
$ids = self::_idsOf($notices);
- $repeatMap = Memcached_DataObject::listGet('Notice', 'repeat_of', $ids);
+ $repeatMap = Notice::listGet('repeat_of', $ids);
foreach ($notices as $notice) {
$repeats = $repeatMap[$notice->id];
$notice->_setRepeats($repeats);