plugins/Favorite/classes/Fave.php

   1 <?php
   2 /**
   3  * Table Definition for fave
   4  */
   5
   6 class Fave extends Managed_DataObject
   7 {
   8     public $__table = 'fave';                            // table name
   9     public $notice_id;                       // int(4)  primary_key not_null
  10     public $user_id;                         // int(4)  primary_key not_null
  11     public $uri;                             // varchar(255)
  12     public $created;                         // datetime  multiple_key not_null
  13     public $modified;                        // timestamp()   not_null default_CURRENT_TIMESTAMP
  14
  15     public static function schemaDef()
  16     {
  17         return array(
  18             'fields' => array(
  19                 'notice_id' => array('type' => 'int', 'not null' => true, 'description' => 'notice that is the favorite'),
  20                 'user_id' => array('type' => 'int', 'not null' => true, 'description' => 'user who likes this notice'),
  21                 'uri' => array('type' => 'varchar', 'length' => 255, 'description' => 'universally unique identifier, usually a tag URI'),
  22                 'created' => array('type' => 'datetime', 'not null' => true, 'description' => 'date this record was created'),
  23                 'modified' => array('type' => 'timestamp', 'not null' => true, 'description' => 'date this record was modified'),
  24             ),
  25             'primary key' => array('notice_id', 'user_id'),
  26             'unique keys' => array(
  27                 'fave_uri_key' => array('uri'),
  28             ),
  29             'foreign keys' => array(
  30                 'fave_notice_id_fkey' => array('notice', array('notice_id' => 'id')),
  31                 'fave_user_id_fkey' => array('profile', array('user_id' => 'id')), // note: formerly referenced notice.id, but we can now record remote users' favorites
  32             ),
  33             'indexes' => array(
  34                 'fave_notice_id_idx' => array('notice_id'),
  35                 'fave_user_id_idx' => array('user_id', 'modified'),
  36                 'fave_modified_idx' => array('modified'),
  37             ),
  38         );
  39     }
  40
  41     /**
  42      * Save a favorite record.
  43      * @fixme post-author notification should be moved here
  44      *
  45      * @param Profile $profile the local or remote user who likes
  46      * @param Notice $notice the notice that is liked
  47      * @return Fave record on success
  48      * @throws Exception on failure
  49      */
  50     static function addNew(Profile $profile, Notice $notice) {
  51
  52         $fave = null;
  53
  54         if (Event::handle('StartFavorNotice', array($profile, $notice, &$fave))) {
  55
  56             $fave = new Fave();
  57
  58             $fave->user_id   = $profile->id;
  59             $fave->notice_id = $notice->id;
  60             $fave->created   = common_sql_now();
  61             $fave->modified  = common_sql_now();
  62             $fave->uri       = self::newUri($profile,
  63                                             $notice,
  64                                             $fave->created);
  65
  66             try {
  67                 $fave->insert();
  68             } catch (ServerException $e) {
  69                 common_log_db_error($fave, 'INSERT', __FILE__);
  70                 throw $e;
  71             }
  72             self::blowCacheForProfileId($fave->user_id);
  73             self::blowCacheForNoticeId($fave->notice_id);
  74             self::blow('popular');
  75
  76             Event::handle('EndFavorNotice', array($profile, $notice));
  77         }
  78
  79         return $fave;
  80     }
  81
  82     // exception throwing takeover!
  83     public function insert()
  84     {
  85         if (!parent::insert()) {
  86             throw new ServerException(sprintf(_m('Could not store new object of type %s'), get_called_class()));
  87         }
  88         self::blowCacheForProfileId($this->user_id);
  89         self::blowCacheForNoticeId($this->notice_id);
  90         return $this;
  91     }
  92
  93     public function delete($useWhere=false)
  94     {
  95         $profile = Profile::getKV('id', $this->user_id);
  96         $notice  = Notice::getKV('id', $this->notice_id);
  97
  98         $result = null;
  99
 100         if (Event::handle('StartDisfavorNotice', array($profile, $notice, &$result))) {
 101
 102             $result = parent::delete($useWhere);
 103
 104             self::blowCacheForProfileId($this->user_id);
 105             self::blowCacheForNoticeId($this->notice_id);
 106             self::blow('popular');
 107
 108             if ($result) {
 109                 Event::handle('EndDisfavorNotice', array($profile, $notice));
 110             }
 111         }
 112
 113         return $result;
 114     }
 115
 116     function stream($user_id, $offset=0, $limit=NOTICES_PER_PAGE, $own=false, $since_id=0, $max_id=0)
 117     {
 118         $stream = new FaveNoticeStream($user_id, $own);
 119
 120         return $stream->getNotices($offset, $limit, $since_id, $max_id);
 121     }
 122
 123     function idStream($user_id, $offset=0, $limit=NOTICES_PER_PAGE, $own=false, $since_id=0, $max_id=0)
 124     {
 125         $stream = new FaveNoticeStream($user_id, $own);
 126
 127         return $stream->getNoticeIds($offset, $limit, $since_id, $max_id);
 128     }
 129
 130     function asActivity()
 131     {
 132         $target = $this->getTarget();
 133         $actor  = $this->getActor();
 134
 135         $act = new Activity();
 136
 137         $act->verb = ActivityVerb::FAVORITE;
 138
 139         // FIXME: rationalize this with URL below
 140
 141         $act->id   = $this->getUri();
 142
 143         $act->time    = strtotime($this->created);
 144         // TRANS: Activity title when marking a notice as favorite.
 145         $act->title   = _("Favor");
 146         $act->content = $target->rendered ?: $target->content;
 147
 148         $act->actor     = $actor->asActivityObject();
 149         $act->target    = $target->asActivityObject();
 150         $act->objects   = array(clone($act->target));
 151
 152         $url = common_local_url('AtomPubShowFavorite',
 153                                           array('profile' => $actor->id,
 154                                                 'notice'  => $target->id));
 155
 156         $act->selfLink = $url;
 157         $act->editLink = $url;
 158
 159         return $act;
 160     }
 161
 162     static function existsForProfile($notice, Profile $scoped)
 163     {
 164         $fave = self::pkeyGet(array('user_id'=>$scoped->id, 'notice_id'=>$notice->id));
 165
 166         return ($fave instanceof Fave);
 167     }
 168
 169     /**
 170      * Fetch a stream of favorites by profile
 171      *
 172      * @param integer $profileId Profile that faved
 173      * @param integer $offset    Offset from last
 174      * @param integer $limit     Number to get
 175      *
 176      * @return mixed stream of faves, use fetch() to iterate
 177      *
 178      * @todo Cache results
 179      * @todo integrate with Fave::stream()
 180      */
 181
 182     static function byProfile($profileId, $offset, $limit)
 183     {
 184         $fav = new Fave();
 185
 186         $fav->user_id = $profileId;
 187
 188         $fav->orderBy('modified DESC');
 189
 190         $fav->limit($offset, $limit);
 191
 192         $fav->find();
 193
 194         return $fav;
 195     }
 196
 197     static function countByProfile(Profile $profile)
 198     {
 199         $c = Cache::instance();
 200         if (!empty($c)) {
 201             $cnt = $c->get(Cache::key('fave:count_by_profile:'.$profile->id));
 202             if (is_integer($cnt)) {
 203                 return $cnt;
 204             }
 205         }
 206
 207         $faves = new Fave();
 208         $faves->user_id = $profile->id;
 209         $cnt = (int) $faves->count('notice_id');
 210
 211         if (!empty($c)) {
 212             $c->set(Cache::key('fave:count_by_profile:'.$profile->id), $cnt);
 213         }
 214
 215         return $cnt;
 216     }
 217
 218     static protected $_faves = array();
 219
 220     /**
 221      * All faves of this notice
 222      *
 223      * @param Notice $notice A notice we wish to get faves for (may still be ArrayWrapper)
 224      *
 225      * @return array Array of Fave objects
 226      */
 227     static public function byNotice($notice)
 228     {
 229         if (!isset(self::$_faves[$notice->id])) {
 230             self::fillFaves(array($notice->id));
 231         }
 232         return self::$_faves[$notice->id];
 233     }
 234
 235     static public function fillFaves(array $notice_ids)
 236     {
 237         $faveMap = Fave::listGet('notice_id', $notice_ids);
 238         self::$_faves = array_replace(self::$_faves, $faveMap);
 239     }
 240
 241     static public function blowCacheForProfileId($profile_id)
 242     {
 243         $cache = Cache::instance();
 244         if ($cache) {
 245             // Faves don't happen chronologically, so we need to blow
 246             // ;last cache, too
 247             $cache->delete(Cache::key('fave:ids_by_user:'.$profile_id));
 248             $cache->delete(Cache::key('fave:ids_by_user:'.$profile_id.';last'));
 249             $cache->delete(Cache::key('fave:ids_by_user_own:'.$profile_id));
 250             $cache->delete(Cache::key('fave:ids_by_user_own:'.$profile_id.';last'));
 251             $cache->delete(Cache::key('fave:count_by_profile:'.$profile_id));
 252         }
 253     }
 254     static public function blowCacheForNoticeId($notice_id)
 255     {
 256         $cache = Cache::instance();
 257         if ($cache) {
 258             $cache->delete(Cache::key('fave:list-ids:notice_id:'.$notice_id));
 259         }
 260     }
 261
 262     // Remember that we want the _activity_ notice here, not faves applied
 263     // to the supplied Notice (as with byNotice)!
 264     static public function fromStored(Notice $stored)
 265     {
 266         $class = get_called_class();
 267         $object = new $class;
 268         $object->uri = $stored->uri;
 269         if (!$object->find(true)) {
 270             throw new NoResultException($object);
 271         }
 272         return $object;
 273     }
 274
 275     /**
 276      * Retrieves the _targeted_ notice of a verb (such as the notice that was
 277      * _favorited_, but not the favorite activity itself).
 278      *
 279      * @param Notice $stored    The activity notice.
 280      *
 281      * @throws NoResultException when it can't find what it's looking for.
 282      */
 283     static public function getTargetFromStored(Notice $stored)
 284     {
 285         return self::fromStored($stored)->getTarget();
 286     }
 287
 288     static public function getObjectType()
 289     {
 290         return 'activity';
 291     }
 292
 293     public function asActivityObject(Profile $scoped=null)
 294     {
 295         $actobj = new ActivityObject();
 296         $actobj->id = $this->getUri();
 297         $actobj->type = ActivityUtils::resolveUri(self::getObjectType());
 298         $actobj->actor = $this->getActorObject();
 299         $actobj->target = $this->getTargetObject();
 300         $actobj->objects = array(clone($actobj->target));
 301         $actobj->verb = ActivityVerb::FAVORITE;
 302         $actobj->title = ActivityUtils::verbToTitle($actobj->verb);
 303         $actobj->content = $this->getTarget()->rendered ?: $this->getTarget()->content;
 304         return $actobj;
 305     }
 306
 307     /**
 308      * @param ActivityObject $actobj The _favored_ notice (which we're "in-reply-to")
 309      * @param Notice         $stored The _activity_ notice, i.e. the favor itself.
 310      */
 311     static public function parseActivityObject(ActivityObject $actobj, Notice $stored)
 312     {
 313         $local = ActivityUtils::findLocalObject($actobj->getIdentifiers());
 314         if (!$local instanceof Notice) {
 315             // $local always returns something, but this was not what we expected. Something is wrong.
 316             throw new Exception('Something other than a Notice was returned from findLocalObject');
 317         }
 318
 319         $actor = $stored->getProfile();
 320         $object = new Fave();
 321         $object->user_id = $stored->getProfile()->id;
 322         $object->notice_id = $local->id;
 323         $object->uri = $stored->uri;
 324         $object->created = $stored->created;
 325         $object->modified = $stored->modified;
 326         return $object;
 327     }
 328
 329     static public function extendActivity(Notice $stored, Activity $act, Profile $scoped=null)
 330     {
 331         $target = self::getTargetFromStored($stored);
 332
 333         // The following logic was copied from StatusNet's Activity plugin
 334         if (ActivityUtils::compareTypes($target->verb, array(ActivityVerb::POST))) {
 335             // "I like the thing you posted"
 336             $act->objects = $target->asActivity()->objects;
 337         } else {
 338             // "I like that you did whatever you did"
 339             $act->target = $target->asActivityObject();
 340             $act->objects = array(clone($act->target));
 341         }
 342         $act->context->replyToID = $target->getUri();
 343         $act->context->replyToUrl = $target->getUrl();
 344         $act->title = ActivityUtils::verbToTitle($act->verb);
 345     }
 346
 347     static function saveActivityObject(ActivityObject $actobj, Notice $stored)
 348     {
 349         $object = self::parseActivityObject($actobj, $stored);
 350         $object->insert();  // exception throwing!
 351         Event::handle('EndFavorNotice', array($stored->getProfile(), $object->getTarget()));
 352         return $object;
 353     }
 354
 355     public function getAttentionArray() {
 356         // not all objects can/should carry attentions, so we don't require extending this
 357         // the format should be an array with URIs to mentioned profiles
 358         return array();
 359     }
 360
 361     public function getTarget()
 362     {
 363         // throws exception on failure
 364         $target = new Notice();
 365         $target->id = $this->notice_id;
 366         if (!$target->find(true)) {
 367             throw new NoResultException($target);
 368         }
 369
 370         return $target;
 371     }
 372
 373     public function getTargetObject()
 374     {
 375         return $this->getTarget()->asActivityObject();
 376     }
 377
 378     protected $_stored = array();
 379
 380     public function getStored()
 381     {
 382         if (!isset($this->_stored[$this->uri])) {
 383             $stored = new Notice();
 384             $stored->uri = $this->uri;
 385             if (!$stored->find(true)) {
 386                 throw new NoResultException($stored);
 387             }
 388             $this->_stored[$this->uri] = $stored;
 389         }
 390         return $this->_stored[$this->uri];
 391     }
 392
 393     public function getActor()
 394     {
 395         $profile = new Profile();
 396         $profile->id = $this->user_id;
 397         if (!$profile->find(true)) {
 398             throw new NoResultException($profile);
 399         }
 400         return $profile;
 401     }
 402
 403     public function getActorObject()
 404     {
 405         return $this->getActor()->asActivityObject();
 406     }
 407
 408     public function getUri()
 409     {
 410         if (!empty($this->uri)) {
 411             return $this->uri;
 412         }
 413
 414         // We (should've in this case) created it ourselves, so we tag it ourselves
 415         return self::newUri($this->getActor(), $this->getTarget(), $this->created);
 416     }
 417
 418     static function newUri(Profile $actor, Managed_DataObject $target, $created=null)
 419     {
 420         if (is_null($created)) {
 421             $created = common_sql_now();
 422         }
 423         return TagURI::mint(strtolower(get_called_class()).':%d:%s:%d:%s',
 424                                         $actor->id,
 425                                         ActivityUtils::resolveUri(self::getObjectType(), true),
 426                                         $target->id,
 427                                         common_date_iso8601($created));
 428     }
 429 }