classes/Profile.php

   1 <?php
   2 /*
   3  * StatusNet - the distributed open-source microblogging tool
   4  * Copyright (C) 2008, 2009, StatusNet, Inc.
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU Affero General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Affero General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Affero General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 if (!defined('STATUSNET') && !defined('LACONICA')) { exit(1); }
  21
  22 /**
  23  * Table Definition for profile
  24  */
  25 require_once INSTALLDIR.'/classes/Memcached_DataObject.php';
  26
  27 class Profile extends Memcached_DataObject
  28 {
  29     ###START_AUTOCODE
  30     /* the code below is auto generated do not remove the above tag */
  31
  32     public $__table = 'profile';                         // table name
  33     public $id;                              // int(4)  primary_key not_null
  34     public $nickname;                        // varchar(64)  multiple_key not_null
  35     public $fullname;                        // varchar(255)  multiple_key
  36     public $profileurl;                      // varchar(255)
  37     public $homepage;                        // varchar(255)  multiple_key
  38     public $bio;                             // text()  multiple_key
  39     public $location;                        // varchar(255)  multiple_key
  40     public $lat;                             // decimal(10,7)
  41     public $lon;                             // decimal(10,7)
  42     public $location_id;                     // int(4)
  43     public $location_ns;                     // int(4)
  44     public $created;                         // datetime()   not_null
  45     public $modified;                        // timestamp()   not_null default_CURRENT_TIMESTAMP
  46
  47     /* Static get */
  48     function staticGet($k,$v=NULL) {
  49         return Memcached_DataObject::staticGet('Profile',$k,$v);
  50     }
  51
  52     /* the code above is auto generated do not remove the tag below */
  53     ###END_AUTOCODE
  54
  55     function getUser()
  56     {
  57         return User::staticGet('id', $this->id);
  58     }
  59
  60     function getAvatar($width, $height=null)
  61     {
  62         if (is_null($height)) {
  63             $height = $width;
  64         }
  65         return Avatar::pkeyGet(array('profile_id' => $this->id,
  66                                      'width' => $width,
  67                                      'height' => $height));
  68     }
  69
  70     function getOriginalAvatar()
  71     {
  72         $avatar = DB_DataObject::factory('avatar');
  73         $avatar->profile_id = $this->id;
  74         $avatar->original = true;
  75         if ($avatar->find(true)) {
  76             return $avatar;
  77         } else {
  78             return null;
  79         }
  80     }
  81
  82     function setOriginal($filename)
  83     {
  84         $imagefile = new ImageFile($this->id, Avatar::path($filename));
  85
  86         $avatar = new Avatar();
  87         $avatar->profile_id = $this->id;
  88         $avatar->width = $imagefile->width;
  89         $avatar->height = $imagefile->height;
  90         $avatar->mediatype = image_type_to_mime_type($imagefile->type);
  91         $avatar->filename = $filename;
  92         $avatar->original = true;
  93         $avatar->url = Avatar::url($filename);
  94         $avatar->created = DB_DataObject_Cast::dateTime(); # current time
  95
  96         // XXX: start a transaction here
  97
  98         if (!$this->delete_avatars() || !$avatar->insert()) {
  99             @unlink(Avatar::path($filename));
 100             return null;
 101         }
 102
 103         foreach (array(AVATAR_PROFILE_SIZE, AVATAR_STREAM_SIZE, AVATAR_MINI_SIZE) as $size) {
 104             // We don't do a scaled one if original is our scaled size
 105             if (!($avatar->width == $size && $avatar->height == $size)) {
 106                 $scaled_filename = $imagefile->resize($size);
 107
 108                 //$scaled = DB_DataObject::factory('avatar');
 109                 $scaled = new Avatar();
 110                 $scaled->profile_id = $this->id;
 111                 $scaled->width = $size;
 112                 $scaled->height = $size;
 113                 $scaled->original = false;
 114                 $scaled->mediatype = image_type_to_mime_type($imagefile->type);
 115                 $scaled->filename = $scaled_filename;
 116                 $scaled->url = Avatar::url($scaled_filename);
 117                 $scaled->created = DB_DataObject_Cast::dateTime(); # current time
 118
 119                 if (!$scaled->insert()) {
 120                     return null;
 121                 }
 122             }
 123         }
 124
 125         return $avatar;
 126     }
 127
 128     /**
 129      * Delete attached avatars for this user from the database and filesystem.
 130      * This should be used instead of a batch delete() to ensure that files
 131      * get removed correctly.
 132      *
 133      * @param boolean $original true to delete only the original-size file
 134      * @return <type>
 135      */
 136     function delete_avatars($original=true)
 137     {
 138         $avatar = new Avatar();
 139         $avatar->profile_id = $this->id;
 140         $avatar->find();
 141         while ($avatar->fetch()) {
 142             if ($avatar->original) {
 143                 if ($original == false) {
 144                     continue;
 145                 }
 146             }
 147             $avatar->delete();
 148         }
 149         return true;
 150     }
 151
 152     /**
 153      * Gets either the full name (if filled) or the nickname.
 154      *
 155      * @return string
 156      */
 157     function getBestName()
 158     {
 159         return ($this->fullname) ? $this->fullname : $this->nickname;
 160     }
 161
 162     /**
 163      * Gets the full name (if filled) with nickname as a parenthetical, or the nickname alone
 164      * if no fullname is provided.
 165      *
 166      * @return string
 167      */
 168     function getFancyName()
 169     {
 170         if ($this->fullname) {
 171             // TRANS: Full name of a profile or group followed by nickname in parens
 172             return sprintf(_m('FANCYNAME','%1$s (%2$s)'), $this->fullname, $this->nickname);
 173         } else {
 174             return $this->nickname;
 175         }
 176     }
 177
 178     /**
 179      * Get the most recent notice posted by this user, if any.
 180      *
 181      * @return mixed Notice or null
 182      */
 183
 184     function getCurrentNotice()
 185     {
 186         $notice = $this->getNotices(0, 1);
 187
 188         if ($notice->fetch()) {
 189             if ($notice instanceof ArrayWrapper) {
 190                 // hack for things trying to work with single notices
 191                 return $notice->_items[0];
 192             }
 193             return $notice;
 194         } else {
 195             return null;
 196         }
 197     }
 198
 199     function getTaggedNotices($tag, $offset=0, $limit=NOTICES_PER_PAGE, $since_id=0, $max_id=0)
 200     {
 201         $stream = new TaggedProfileNoticeStream($this, $tag);
 202
 203         return $stream->getNotices($offset, $limit, $since_id, $max_id);
 204     }
 205
 206     function getNotices($offset=0, $limit=NOTICES_PER_PAGE, $since_id=0, $max_id=0)
 207     {
 208         $stream = new ProfileNoticeStream($this);
 209
 210         return $stream->getNotices($offset, $limit, $since_id, $max_id);
 211     }
 212
 213     function isMember($group)
 214     {
 215         $mem = new Group_member();
 216
 217         $mem->group_id = $group->id;
 218         $mem->profile_id = $this->id;
 219
 220         if ($mem->find()) {
 221             return true;
 222         } else {
 223             return false;
 224         }
 225     }
 226
 227     function isAdmin($group)
 228     {
 229         $mem = new Group_member();
 230
 231         $mem->group_id = $group->id;
 232         $mem->profile_id = $this->id;
 233         $mem->is_admin = 1;
 234
 235         if ($mem->find()) {
 236             return true;
 237         } else {
 238             return false;
 239         }
 240     }
 241
 242     function isPendingMember($group)
 243     {
 244         $request = Group_join_queue::pkeyGet(array('profile_id' => $this->id,
 245                                                    'group_id' => $group->id));
 246         return !empty($request);
 247     }
 248
 249     function getGroups($offset=0, $limit=null)
 250     {
 251         $qry =
 252           'SELECT user_group.* ' .
 253           'FROM user_group JOIN group_member '.
 254           'ON user_group.id = group_member.group_id ' .
 255           'WHERE group_member.profile_id = %d ' .
 256           'ORDER BY group_member.created DESC ';
 257
 258         if ($offset>0 && !is_null($limit)) {
 259             if ($offset) {
 260                 if (common_config('db','type') == 'pgsql') {
 261                     $qry .= ' LIMIT ' . $limit . ' OFFSET ' . $offset;
 262                 } else {
 263                     $qry .= ' LIMIT ' . $offset . ', ' . $limit;
 264                 }
 265             }
 266         }
 267
 268         $groups = new User_group();
 269
 270         $cnt = $groups->query(sprintf($qry, $this->id));
 271
 272         return $groups;
 273     }
 274
 275     /**
 276      * Request to join the given group.
 277      * May throw exceptions on failure.
 278      *
 279      * @param User_group $group
 280      * @return mixed: Group_member on success, Group_join_queue if pending approval, null on some cancels?
 281      */
 282     function joinGroup(User_group $group)
 283     {
 284         $join = null;
 285         if ($group->join_policy == User_group::JOIN_POLICY_MODERATE) {
 286             $join = Group_join_queue::saveNew($this, $group);
 287         } else {
 288             if (Event::handle('StartJoinGroup', array($group, $this))) {
 289                 $join = Group_member::join($group->id, $this->id);
 290                 Event::handle('EndJoinGroup', array($group, $this));
 291             }
 292         }
 293         if ($join) {
 294             // Send any applicable notifications...
 295             $join->notify();
 296         }
 297         return $join;
 298     }
 299
 300     /**
 301      * Cancel a pending group join...
 302      *
 303      * @param User_group $group
 304      */
 305     function cancelJoinGroup(User_group $group)
 306     {
 307         $request = Group_join_queue::pkeyGet(array('profile_id' => $this->id,
 308                                                    'group_id' => $group->id));
 309         if ($request) {
 310             if (Event::handle('StartCancelJoinGroup', array($group, $this))) {
 311                 $request->delete();
 312                 Event::handle('EndCancelJoinGroup', array($group, $this));
 313             }
 314         }
 315     }
 316
 317     /**
 318      * Complete a pending group join on our end...
 319      *
 320      * @param User_group $group
 321      */
 322     function completeJoinGroup(User_group $group)
 323     {
 324         $join = null;
 325         $request = Group_join_queue::pkeyGet(array('profile_id' => $this->id,
 326                                                    'group_id' => $group->id));
 327         if ($request) {
 328             if (Event::handle('StartJoinGroup', array($group, $this))) {
 329                 $join = Group_member::join($group->id, $this->id);
 330                 $request->delete();
 331                 Event::handle('EndJoinGroup', array($group, $this));
 332             }
 333         } else {
 334             // TRANS: Exception thrown trying to approve a non-existing group join request.
 335             throw new Exception(_('Invalid group join approval: not pending.'));
 336         }
 337         if ($join) {
 338             $join->notify();
 339         }
 340         return $join;
 341     }
 342
 343     /**
 344      * Leave a group that this profile is a member of.
 345      *
 346      * @param User_group $group
 347      */
 348     function leaveGroup(User_group $group)
 349     {
 350         if (Event::handle('StartLeaveGroup', array($group, $this))) {
 351             Group_member::leave($group->id, $this->id);
 352             Event::handle('EndLeaveGroup', array($group, $this));
 353         }
 354     }
 355
 356     function avatarUrl($size=AVATAR_PROFILE_SIZE)
 357     {
 358         $avatar = $this->getAvatar($size);
 359         if ($avatar) {
 360             return $avatar->displayUrl();
 361         } else {
 362             return Avatar::defaultImage($size);
 363         }
 364     }
 365
 366     /**
 367      * Request a subscription to another local or remote profile.
 368      * This will result in either the subscription going through
 369      * immediately, being queued for approval, or being rejected
 370      * immediately.
 371      *
 372      * @param Profile $profile
 373      * @return mixed: Subscription or Subscription_queue object on success
 374      * @throws Exception of various types on invalid state
 375      */
 376     function subscribe($profile)
 377     {
 378         //
 379     }
 380
 381     /**
 382      * Cancel an outstanding subscription request to the other profile.
 383      *
 384      * @param Profile $profile
 385      */
 386     function cancelSubscribe($profile)
 387     {
 388         $request = Subscribe_join_queue::pkeyGet(array('subscriber' => $this->id,
 389                                                        'subscribed' => $profile->id));
 390         if ($request) {
 391             if (Event::handle('StartCancelSubscription', array($this, $profile))) {
 392                 $request->delete();
 393                 Event::handle('EndCancelSubscription', array($this, $profile));
 394             }
 395         }
 396     }
 397
 398     /**
 399      *
 400      * @param <type> $profile
 401      */
 402     function completeSubscribe($profile)
 403     {
 404
 405     }
 406
 407     function getSubscriptions($offset=0, $limit=null)
 408     {
 409         $subs = Subscription::bySubscriber($this->id,
 410                                            $offset,
 411                                            $limit);
 412
 413         $profiles = array();
 414
 415         while ($subs->fetch()) {
 416             $profile = Profile::staticGet($subs->subscribed);
 417             if ($profile) {
 418                 $profiles[] = $profile;
 419             }
 420         }
 421
 422         return new ArrayWrapper($profiles);
 423     }
 424
 425     function getSubscribers($offset=0, $limit=null)
 426     {
 427         $subs = Subscription::bySubscribed($this->id,
 428                                            $offset,
 429                                            $limit);
 430
 431         $profiles = array();
 432
 433         while ($subs->fetch()) {
 434             $profile = Profile::staticGet($subs->subscriber);
 435             if ($profile) {
 436                 $profiles[] = $profile;
 437             }
 438         }
 439
 440         return new ArrayWrapper($profiles);
 441     }
 442
 443     function subscriptionCount()
 444     {
 445         $c = Cache::instance();
 446
 447         if (!empty($c)) {
 448             $cnt = $c->get(Cache::key('profile:subscription_count:'.$this->id));
 449             if (is_integer($cnt)) {
 450                 return (int) $cnt;
 451             }
 452         }
 453
 454         $sub = new Subscription();
 455         $sub->subscriber = $this->id;
 456
 457         $cnt = (int) $sub->count('distinct subscribed');
 458
 459         $cnt = ($cnt > 0) ? $cnt - 1 : $cnt;
 460
 461         if (!empty($c)) {
 462             $c->set(Cache::key('profile:subscription_count:'.$this->id), $cnt);
 463         }
 464
 465         return $cnt;
 466     }
 467
 468     function subscriberCount()
 469     {
 470         $c = Cache::instance();
 471         if (!empty($c)) {
 472             $cnt = $c->get(Cache::key('profile:subscriber_count:'.$this->id));
 473             if (is_integer($cnt)) {
 474                 return (int) $cnt;
 475             }
 476         }
 477
 478         $sub = new Subscription();
 479         $sub->subscribed = $this->id;
 480         $sub->whereAdd('subscriber != subscribed');
 481         $cnt = (int) $sub->count('distinct subscriber');
 482
 483         if (!empty($c)) {
 484             $c->set(Cache::key('profile:subscriber_count:'.$this->id), $cnt);
 485         }
 486
 487         return $cnt;
 488     }
 489
 490     /**
 491      * Is this profile subscribed to another profile?
 492      *
 493      * @param Profile $other
 494      * @return boolean
 495      */
 496     function isSubscribed($other)
 497     {
 498         return Subscription::exists($this, $other);
 499     }
 500
 501     /**
 502      * Are these two profiles subscribed to each other?
 503      *
 504      * @param Profile $other
 505      * @return boolean
 506      */
 507     function mutuallySubscribed($other)
 508     {
 509         return $this->isSubscribed($other) &&
 510           $other->isSubscribed($this);
 511     }
 512
 513     function hasFave($notice)
 514     {
 515         $cache = Cache::instance();
 516
 517         // XXX: Kind of a hack.
 518
 519         if (!empty($cache)) {
 520             // This is the stream of favorite notices, in rev chron
 521             // order. This forces it into cache.
 522
 523             $ids = Fave::idStream($this->id, 0, CachingNoticeStream::CACHE_WINDOW);
 524
 525             // If it's in the list, then it's a fave
 526
 527             if (in_array($notice->id, $ids)) {
 528                 return true;
 529             }
 530
 531             // If we're not past the end of the cache window,
 532             // then the cache has all available faves, so this one
 533             // is not a fave.
 534
 535             if (count($ids) < CachingNoticeStream::CACHE_WINDOW) {
 536                 return false;
 537             }
 538
 539             // Otherwise, cache doesn't have all faves;
 540             // fall through to the default
 541         }
 542
 543         $fave = Fave::pkeyGet(array('user_id' => $this->id,
 544                                     'notice_id' => $notice->id));
 545         return ((is_null($fave)) ? false : true);
 546     }
 547
 548     function faveCount()
 549     {
 550         $c = Cache::instance();
 551         if (!empty($c)) {
 552             $cnt = $c->get(Cache::key('profile:fave_count:'.$this->id));
 553             if (is_integer($cnt)) {
 554                 return (int) $cnt;
 555             }
 556         }
 557
 558         $faves = new Fave();
 559         $faves->user_id = $this->id;
 560         $cnt = (int) $faves->count('distinct notice_id');
 561
 562         if (!empty($c)) {
 563             $c->set(Cache::key('profile:fave_count:'.$this->id), $cnt);
 564         }
 565
 566         return $cnt;
 567     }
 568
 569     function noticeCount()
 570     {
 571         $c = Cache::instance();
 572
 573         if (!empty($c)) {
 574             $cnt = $c->get(Cache::key('profile:notice_count:'.$this->id));
 575             if (is_integer($cnt)) {
 576                 return (int) $cnt;
 577             }
 578         }
 579
 580         $notices = new Notice();
 581         $notices->profile_id = $this->id;
 582         $cnt = (int) $notices->count('distinct id');
 583
 584         if (!empty($c)) {
 585             $c->set(Cache::key('profile:notice_count:'.$this->id), $cnt);
 586         }
 587
 588         return $cnt;
 589     }
 590
 591     function blowFavesCache()
 592     {
 593         $cache = Cache::instance();
 594         if ($cache) {
 595             // Faves don't happen chronologically, so we need to blow
 596             // ;last cache, too
 597             $cache->delete(Cache::key('fave:ids_by_user:'.$this->id));
 598             $cache->delete(Cache::key('fave:ids_by_user:'.$this->id.';last'));
 599             $cache->delete(Cache::key('fave:ids_by_user_own:'.$this->id));
 600             $cache->delete(Cache::key('fave:ids_by_user_own:'.$this->id.';last'));
 601         }
 602         $this->blowFaveCount();
 603     }
 604
 605     function blowSubscriberCount()
 606     {
 607         $c = Cache::instance();
 608         if (!empty($c)) {
 609             $c->delete(Cache::key('profile:subscriber_count:'.$this->id));
 610         }
 611     }
 612
 613     function blowSubscriptionCount()
 614     {
 615         $c = Cache::instance();
 616         if (!empty($c)) {
 617             $c->delete(Cache::key('profile:subscription_count:'.$this->id));
 618         }
 619     }
 620
 621     function blowFaveCount()
 622     {
 623         $c = Cache::instance();
 624         if (!empty($c)) {
 625             $c->delete(Cache::key('profile:fave_count:'.$this->id));
 626         }
 627     }
 628
 629     function blowNoticeCount()
 630     {
 631         $c = Cache::instance();
 632         if (!empty($c)) {
 633             $c->delete(Cache::key('profile:notice_count:'.$this->id));
 634         }
 635     }
 636
 637     static function maxBio()
 638     {
 639         $biolimit = common_config('profile', 'biolimit');
 640         // null => use global limit (distinct from 0!)
 641         if (is_null($biolimit)) {
 642             $biolimit = common_config('site', 'textlimit');
 643         }
 644         return $biolimit;
 645     }
 646
 647     static function bioTooLong($bio)
 648     {
 649         $biolimit = self::maxBio();
 650         return ($biolimit > 0 && !empty($bio) && (mb_strlen($bio) > $biolimit));
 651     }
 652
 653     function delete()
 654     {
 655         $this->_deleteNotices();
 656         $this->_deleteSubscriptions();
 657         $this->_deleteMessages();
 658         $this->_deleteTags();
 659         $this->_deleteBlocks();
 660         $this->delete_avatars();
 661
 662         // Warning: delete() will run on the batch objects,
 663         // not on individual objects.
 664         $related = array('Reply',
 665                          'Group_member',
 666                          );
 667         Event::handle('ProfileDeleteRelated', array($this, &$related));
 668
 669         foreach ($related as $cls) {
 670             $inst = new $cls();
 671             $inst->profile_id = $this->id;
 672             $inst->delete();
 673         }
 674
 675         parent::delete();
 676     }
 677
 678     function _deleteNotices()
 679     {
 680         $notice = new Notice();
 681         $notice->profile_id = $this->id;
 682
 683         if ($notice->find()) {
 684             while ($notice->fetch()) {
 685                 $other = clone($notice);
 686                 $other->delete();
 687             }
 688         }
 689     }
 690
 691     function _deleteSubscriptions()
 692     {
 693         $sub = new Subscription();
 694         $sub->subscriber = $this->id;
 695
 696         $sub->find();
 697
 698         while ($sub->fetch()) {
 699             $other = Profile::staticGet('id', $sub->subscribed);
 700             if (empty($other)) {
 701                 continue;
 702             }
 703             if ($other->id == $this->id) {
 704                 continue;
 705             }
 706             Subscription::cancel($this, $other);
 707         }
 708
 709         $subd = new Subscription();
 710         $subd->subscribed = $this->id;
 711         $subd->find();
 712
 713         while ($subd->fetch()) {
 714             $other = Profile::staticGet('id', $subd->subscriber);
 715             if (empty($other)) {
 716                 continue;
 717             }
 718             if ($other->id == $this->id) {
 719                 continue;
 720             }
 721             Subscription::cancel($other, $this);
 722         }
 723
 724         $self = new Subscription();
 725
 726         $self->subscriber = $this->id;
 727         $self->subscribed = $this->id;
 728
 729         $self->delete();
 730     }
 731
 732     function _deleteMessages()
 733     {
 734         $msg = new Message();
 735         $msg->from_profile = $this->id;
 736         $msg->delete();
 737
 738         $msg = new Message();
 739         $msg->to_profile = $this->id;
 740         $msg->delete();
 741     }
 742
 743     function _deleteTags()
 744     {
 745         $tag = new Profile_tag();
 746         $tag->tagged = $this->id;
 747         $tag->delete();
 748     }
 749
 750     function _deleteBlocks()
 751     {
 752         $block = new Profile_block();
 753         $block->blocked = $this->id;
 754         $block->delete();
 755
 756         $block = new Group_block();
 757         $block->blocked = $this->id;
 758         $block->delete();
 759     }
 760
 761     // XXX: identical to Notice::getLocation.
 762
 763     function getLocation()
 764     {
 765         $location = null;
 766
 767         if (!empty($this->location_id) && !empty($this->location_ns)) {
 768             $location = Location::fromId($this->location_id, $this->location_ns);
 769         }
 770
 771         if (is_null($location)) { // no ID, or Location::fromId() failed
 772             if (!empty($this->lat) && !empty($this->lon)) {
 773                 $location = Location::fromLatLon($this->lat, $this->lon);
 774             }
 775         }
 776
 777         if (is_null($location)) { // still haven't found it!
 778             if (!empty($this->location)) {
 779                 $location = Location::fromName($this->location);
 780             }
 781         }
 782
 783         return $location;
 784     }
 785
 786     function hasRole($name)
 787     {
 788         $has_role = false;
 789         if (Event::handle('StartHasRole', array($this, $name, &$has_role))) {
 790             $role = Profile_role::pkeyGet(array('profile_id' => $this->id,
 791                                                 'role' => $name));
 792             $has_role = !empty($role);
 793             Event::handle('EndHasRole', array($this, $name, $has_role));
 794         }
 795         return $has_role;
 796     }
 797
 798     function grantRole($name)
 799     {
 800         if (Event::handle('StartGrantRole', array($this, $name))) {
 801
 802             $role = new Profile_role();
 803
 804             $role->profile_id = $this->id;
 805             $role->role       = $name;
 806             $role->created    = common_sql_now();
 807
 808             $result = $role->insert();
 809
 810             if (!$result) {
 811                 throw new Exception("Can't save role '$name' for profile '{$this->id}'");
 812             }
 813
 814             if ($name == 'owner') {
 815                 User::blow('user:site_owner');
 816             }
 817
 818             Event::handle('EndGrantRole', array($this, $name));
 819         }
 820
 821         return $result;
 822     }
 823
 824     function revokeRole($name)
 825     {
 826         if (Event::handle('StartRevokeRole', array($this, $name))) {
 827
 828             $role = Profile_role::pkeyGet(array('profile_id' => $this->id,
 829                                                 'role' => $name));
 830
 831             if (empty($role)) {
 832                 // TRANS: Exception thrown when trying to revoke an existing role for a user that does not exist.
 833                 // TRANS: %1$s is the role name, %2$s is the user ID (number).
 834                 throw new Exception(sprintf(_('Cannot revoke role "%1$s" for user #%2$d; does not exist.'),$name, $this->id));
 835             }
 836
 837             $result = $role->delete();
 838
 839             if (!$result) {
 840                 common_log_db_error($role, 'DELETE', __FILE__);
 841                 // TRANS: Exception thrown when trying to revoke a role for a user with a failing database query.
 842                 // TRANS: %1$s is the role name, %2$s is the user ID (number).
 843                 throw new Exception(sprintf(_('Cannot revoke role "%1$s" for user #%2$d; database error.'),$name, $this->id));
 844             }
 845
 846             if ($name == 'owner') {
 847                 User::blow('user:site_owner');
 848             }
 849
 850             Event::handle('EndRevokeRole', array($this, $name));
 851
 852             return true;
 853         }
 854     }
 855
 856     function isSandboxed()
 857     {
 858         return $this->hasRole(Profile_role::SANDBOXED);
 859     }
 860
 861     function isSilenced()
 862     {
 863         return $this->hasRole(Profile_role::SILENCED);
 864     }
 865
 866     function sandbox()
 867     {
 868         $this->grantRole(Profile_role::SANDBOXED);
 869     }
 870
 871     function unsandbox()
 872     {
 873         $this->revokeRole(Profile_role::SANDBOXED);
 874     }
 875
 876     function silence()
 877     {
 878         $this->grantRole(Profile_role::SILENCED);
 879     }
 880
 881     function unsilence()
 882     {
 883         $this->revokeRole(Profile_role::SILENCED);
 884     }
 885
 886     /**
 887      * Does this user have the right to do X?
 888      *
 889      * With our role-based authorization, this is merely a lookup for whether the user
 890      * has a particular role. The implementation currently uses a switch statement
 891      * to determine if the user has the pre-defined role to exercise the right. Future
 892      * implementations may allow per-site roles, and different mappings of roles to rights.
 893      *
 894      * @param $right string Name of the right, usually a constant in class Right
 895      * @return boolean whether the user has the right in question
 896      */
 897     function hasRight($right)
 898     {
 899         $result = false;
 900
 901         if ($this->hasRole(Profile_role::DELETED)) {
 902             return false;
 903         }
 904
 905         if (Event::handle('UserRightsCheck', array($this, $right, &$result))) {
 906             switch ($right)
 907             {
 908             case Right::DELETEOTHERSNOTICE:
 909             case Right::MAKEGROUPADMIN:
 910             case Right::SANDBOXUSER:
 911             case Right::SILENCEUSER:
 912             case Right::DELETEUSER:
 913             case Right::DELETEGROUP:
 914                 $result = $this->hasRole(Profile_role::MODERATOR);
 915                 break;
 916             case Right::CONFIGURESITE:
 917                 $result = $this->hasRole(Profile_role::ADMINISTRATOR);
 918                 break;
 919             case Right::GRANTROLE:
 920             case Right::REVOKEROLE:
 921                 $result = $this->hasRole(Profile_role::OWNER);
 922                 break;
 923             case Right::NEWNOTICE:
 924             case Right::NEWMESSAGE:
 925             case Right::SUBSCRIBE:
 926             case Right::CREATEGROUP:
 927                 $result = !$this->isSilenced();
 928                 break;
 929             case Right::PUBLICNOTICE:
 930             case Right::EMAILONREPLY:
 931             case Right::EMAILONSUBSCRIBE:
 932             case Right::EMAILONFAVE:
 933                 $result = !$this->isSandboxed();
 934                 break;
 935             case Right::WEBLOGIN:
 936                 $result = !$this->isSilenced();
 937                 break;
 938             case Right::API:
 939                 $result = !$this->isSilenced();
 940                 break;
 941             case Right::BACKUPACCOUNT:
 942                 $result = common_config('profile', 'backup');
 943                 break;
 944             case Right::RESTOREACCOUNT:
 945                 $result = common_config('profile', 'restore');
 946                 break;
 947             case Right::DELETEACCOUNT:
 948                 $result = common_config('profile', 'delete');
 949                 break;
 950             case Right::MOVEACCOUNT:
 951                 $result = common_config('profile', 'move');
 952                 break;
 953             default:
 954                 $result = false;
 955                 break;
 956             }
 957         }
 958         return $result;
 959     }
 960
 961     function hasRepeated($notice_id)
 962     {
 963         // XXX: not really a pkey, but should work
 964
 965         $notice = Memcached_DataObject::pkeyGet('Notice',
 966                                                 array('profile_id' => $this->id,
 967                                                       'repeat_of' => $notice_id));
 968
 969         return !empty($notice);
 970     }
 971
 972     /**
 973      * Returns an XML string fragment with limited profile information
 974      * as an Atom <author> element.
 975      *
 976      * Assumes that Atom has been previously set up as the base namespace.
 977      *
 978      * @param Profile $cur the current authenticated user
 979      *
 980      * @return string
 981      */
 982     function asAtomAuthor($cur = null)
 983     {
 984         $xs = new XMLStringer(true);
 985
 986         $xs->elementStart('author');
 987         $xs->element('name', null, $this->nickname);
 988         $xs->element('uri', null, $this->getUri());
 989         if ($cur != null) {
 990             $attrs = Array();
 991             $attrs['following'] = $cur->isSubscribed($this) ? 'true' : 'false';
 992             $attrs['blocking']  = $cur->hasBlocked($this) ? 'true' : 'false';
 993             $xs->element('statusnet:profile_info', $attrs, null);
 994         }
 995         $xs->elementEnd('author');
 996
 997         return $xs->getString();
 998     }
 999
1000     /**
1001      * Extra profile info for atom entries
1002      *
1003      * Clients use some extra profile info in the atom stream.
1004      * This gives it to them.
1005      *
1006      * @param User $cur Current user
1007      *
1008      * @return array representation of <statusnet:profile_info> element or null
1009      */
1010
1011     function profileInfo($cur)
1012     {
1013         $profileInfoAttr = array('local_id' => $this->id);
1014
1015         if ($cur != null) {
1016             // Whether the current user is a subscribed to this profile
1017             $profileInfoAttr['following'] = $cur->isSubscribed($this) ? 'true' : 'false';
1018             // Whether the current user is has blocked this profile
1019             $profileInfoAttr['blocking']  = $cur->hasBlocked($this) ? 'true' : 'false';
1020         }
1021
1022         return array('statusnet:profile_info', $profileInfoAttr, null);
1023     }
1024
1025     /**
1026      * Returns an XML string fragment with profile information as an
1027      * Activity Streams <activity:actor> element.
1028      *
1029      * Assumes that 'activity' namespace has been previously defined.
1030      *
1031      * @return string
1032      */
1033     function asActivityActor()
1034     {
1035         return $this->asActivityNoun('actor');
1036     }
1037
1038     /**
1039      * Returns an XML string fragment with profile information as an
1040      * Activity Streams noun object with the given element type.
1041      *
1042      * Assumes that 'activity', 'georss', and 'poco' namespace has been
1043      * previously defined.
1044      *
1045      * @param string $element one of 'actor', 'subject', 'object', 'target'
1046      *
1047      * @return string
1048      */
1049     function asActivityNoun($element)
1050     {
1051         $noun = ActivityObject::fromProfile($this);
1052         return $noun->asString('activity:' . $element);
1053     }
1054
1055     /**
1056      * Returns the best URI for a profile. Plugins may override.
1057      *
1058      * @return string $uri
1059      */
1060     function getUri()
1061     {
1062         $uri = null;
1063
1064         // give plugins a chance to set the URI
1065         if (Event::handle('StartGetProfileUri', array($this, &$uri))) {
1066
1067             // check for a local user first
1068             $user = User::staticGet('id', $this->id);
1069
1070             if (!empty($user)) {
1071                 $uri = $user->uri;
1072             } else {
1073                 // return OMB profile if any
1074                 $remote = Remote_profile::staticGet('id', $this->id);
1075                 if (!empty($remote)) {
1076                     $uri = $remote->uri;
1077                 }
1078             }
1079             Event::handle('EndGetProfileUri', array($this, &$uri));
1080         }
1081
1082         return $uri;
1083     }
1084
1085     function hasBlocked($other)
1086     {
1087         $block = Profile_block::get($this->id, $other->id);
1088
1089         if (empty($block)) {
1090             $result = false;
1091         } else {
1092             $result = true;
1093         }
1094
1095         return $result;
1096     }
1097
1098     function getAtomFeed()
1099     {
1100         $feed = null;
1101
1102         if (Event::handle('StartProfileGetAtomFeed', array($this, &$feed))) {
1103             $user = User::staticGet('id', $this->id);
1104             if (!empty($user)) {
1105                 $feed = common_local_url('ApiTimelineUser', array('id' => $user->id,
1106                                                                   'format' => 'atom'));
1107             }
1108             Event::handle('EndProfileGetAtomFeed', array($this, $feed));
1109         }
1110
1111         return $feed;
1112     }
1113
1114     static function fromURI($uri)
1115     {
1116         $profile = null;
1117
1118         if (Event::handle('StartGetProfileFromURI', array($uri, &$profile))) {
1119             // Get a local user or remote (OMB 0.1) profile
1120             $user = User::staticGet('uri', $uri);
1121             if (!empty($user)) {
1122                 $profile = $user->getProfile();
1123             } else {
1124                 $remote_profile = Remote_profile::staticGet('uri', $uri);
1125                 if (!empty($remote_profile)) {
1126                     $profile = Profile::staticGet('id', $remote_profile->profile_id);
1127                 }
1128             }
1129             Event::handle('EndGetProfileFromURI', array($uri, $profile));
1130         }
1131
1132         return $profile;
1133     }
1134 }