]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - classes/Profile.php
12ce5d9b6ce0025062401a844854f18810b3be6d
[quix0rs-gnu-social.git] / 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     function delete_avatars($original=true)
129     {
130         $avatar = new Avatar();
131         $avatar->profile_id = $this->id;
132         $avatar->find();
133         while ($avatar->fetch()) {
134             if ($avatar->original) {
135                 if ($original == false) {
136                     continue;
137                 }
138             }
139             $avatar->delete();
140         }
141         return true;
142     }
143
144     function getBestName()
145     {
146         return ($this->fullname) ? $this->fullname : $this->nickname;
147     }
148
149     /**
150      * Get the most recent notice posted by this user, if any.
151      *
152      * @return mixed Notice or null
153      */
154
155     function getCurrentNotice()
156     {
157         $notice = $this->getNotices(0, 1);
158
159         if ($notice->fetch()) {
160             return $notice;
161         } else {
162             return null;
163         }
164     }
165
166     function getTaggedNotices($tag, $offset=0, $limit=NOTICES_PER_PAGE, $since_id=0, $max_id=0)
167     {
168         $ids = Notice::stream(array($this, '_streamTaggedDirect'),
169                               array($tag),
170                               'profile:notice_ids_tagged:' . $this->id . ':' . $tag,
171                               $offset, $limit, $since_id, $max_id);
172         return Notice::getStreamByIds($ids);
173     }
174
175     function getNotices($offset=0, $limit=NOTICES_PER_PAGE, $since_id=0, $max_id=0)
176     {
177         // XXX: I'm not sure this is going to be any faster. It probably isn't.
178         $ids = Notice::stream(array($this, '_streamDirect'),
179                               array(),
180                               'profile:notice_ids:' . $this->id,
181                               $offset, $limit, $since_id, $max_id);
182
183         return Notice::getStreamByIds($ids);
184     }
185
186     function _streamTaggedDirect($tag, $offset, $limit, $since_id, $max_id)
187     {
188         // XXX It would be nice to do this without a join
189
190         $notice = new Notice();
191
192         $query =
193           "select id from notice join notice_tag on id=notice_id where tag='".
194           $notice->escape($tag) .
195           "' and profile_id=" . $notice->escape($this->id);
196
197         if ($since_id != 0) {
198             $query .= " and id > $since_id";
199         }
200
201         if ($max_id != 0) {
202             $query .= " and id < $max_id";
203         }
204
205         $query .= ' order by id DESC';
206
207         if (!is_null($offset)) {
208             $query .= " LIMIT $limit OFFSET $offset";
209         }
210
211         $notice->query($query);
212
213         $ids = array();
214
215         while ($notice->fetch()) {
216             $ids[] = $notice->id;
217         }
218
219         return $ids;
220     }
221
222     function _streamDirect($offset, $limit, $since_id, $max_id)
223     {
224         $notice = new Notice();
225
226         // Temporary hack until notice_profile_id_idx is updated
227         // to (profile_id, id) instead of (profile_id, created, id).
228         // It's been falling back to PRIMARY instead, which is really
229         // very inefficient for a profile that hasn't posted in a few
230         // months. Even though forcing the index will cause a filesort,
231         // it's usually going to be better.
232         if (common_config('db', 'type') == 'mysql') {
233             $index = '';
234             $query =
235               "select id from notice force index (notice_profile_id_idx) ".
236               "where profile_id=" . $notice->escape($this->id);
237
238             if ($since_id != 0) {
239                 $query .= " and id > $since_id";
240             }
241
242             if ($max_id != 0) {
243                 $query .= " and id < $max_id";
244             }
245
246             $query .= ' order by id DESC';
247
248             if (!is_null($offset)) {
249                 $query .= " LIMIT $limit OFFSET $offset";
250             }
251
252             $notice->query($query);
253         } else {
254             $index = '';
255
256             $notice->profile_id = $this->id;
257
258             $notice->selectAdd();
259             $notice->selectAdd('id');
260
261             if ($since_id != 0) {
262                 $notice->whereAdd('id > ' . $since_id);
263             }
264
265             if ($max_id != 0) {
266                 $notice->whereAdd('id <= ' . $max_id);
267             }
268
269             $notice->orderBy('id DESC');
270
271             if (!is_null($offset)) {
272                 $notice->limit($offset, $limit);
273             }
274
275             $notice->find();
276         }
277
278         $ids = array();
279
280         while ($notice->fetch()) {
281             $ids[] = $notice->id;
282         }
283
284         return $ids;
285     }
286
287     function isMember($group)
288     {
289         $mem = new Group_member();
290
291         $mem->group_id = $group->id;
292         $mem->profile_id = $this->id;
293
294         if ($mem->find()) {
295             return true;
296         } else {
297             return false;
298         }
299     }
300
301     function isAdmin($group)
302     {
303         $mem = new Group_member();
304
305         $mem->group_id = $group->id;
306         $mem->profile_id = $this->id;
307         $mem->is_admin = 1;
308
309         if ($mem->find()) {
310             return true;
311         } else {
312             return false;
313         }
314     }
315
316     function getGroups($offset=0, $limit=null)
317     {
318         $qry =
319           'SELECT user_group.* ' .
320           'FROM user_group JOIN group_member '.
321           'ON user_group.id = group_member.group_id ' .
322           'WHERE group_member.profile_id = %d ' .
323           'ORDER BY group_member.created DESC ';
324
325         if ($offset>0 && !is_null($limit)) {
326             if ($offset) {
327                 if (common_config('db','type') == 'pgsql') {
328                     $qry .= ' LIMIT ' . $limit . ' OFFSET ' . $offset;
329                 } else {
330                     $qry .= ' LIMIT ' . $offset . ', ' . $limit;
331                 }
332             }
333         }
334
335         $groups = new User_group();
336
337         $cnt = $groups->query(sprintf($qry, $this->id));
338
339         return $groups;
340     }
341
342     function avatarUrl($size=AVATAR_PROFILE_SIZE)
343     {
344         $avatar = $this->getAvatar($size);
345         if ($avatar) {
346             return $avatar->displayUrl();
347         } else {
348             return Avatar::defaultImage($size);
349         }
350     }
351
352     function getSubscriptions($offset=0, $limit=null)
353     {
354         $qry =
355           'SELECT profile.* ' .
356           'FROM profile JOIN subscription ' .
357           'ON profile.id = subscription.subscribed ' .
358           'WHERE subscription.subscriber = %d ' .
359           'AND subscription.subscribed != subscription.subscriber ' .
360           'ORDER BY subscription.created DESC ';
361
362         if ($offset>0 && !is_null($limit)){
363             if (common_config('db','type') == 'pgsql') {
364                 $qry .= ' LIMIT ' . $limit . ' OFFSET ' . $offset;
365             } else {
366                 $qry .= ' LIMIT ' . $offset . ', ' . $limit;
367             }
368         }
369
370         $profile = new Profile();
371
372         $profile->query(sprintf($qry, $this->id));
373
374         return $profile;
375     }
376
377     function getSubscribers($offset=0, $limit=null)
378     {
379         $qry =
380           'SELECT profile.* ' .
381           'FROM profile JOIN subscription ' .
382           'ON profile.id = subscription.subscriber ' .
383           'WHERE subscription.subscribed = %d ' .
384           'AND subscription.subscribed != subscription.subscriber ' .
385           'ORDER BY subscription.created DESC ';
386
387         if ($offset>0 && !is_null($limit)){
388             if ($offset) {
389                 if (common_config('db','type') == 'pgsql') {
390                     $qry .= ' LIMIT ' . $limit . ' OFFSET ' . $offset;
391                 } else {
392                     $qry .= ' LIMIT ' . $offset . ', ' . $limit;
393                 }
394             }
395         }
396
397         $profile = new Profile();
398
399         $cnt = $profile->query(sprintf($qry, $this->id));
400
401         return $profile;
402     }
403
404     function getApplications($offset = 0, $limit = null)
405     {
406         $qry =
407           'SELECT a.* ' .
408           'FROM oauth_application_user u, oauth_application a ' .
409           'WHERE u.profile_id = %d ' .
410           'AND a.id = u.application_id ' .
411           'AND u.access_type > 0 ' .
412           'ORDER BY u.created DESC ';
413
414         if ($offset > 0) {
415             if (common_config('db','type') == 'pgsql') {
416                 $qry .= ' LIMIT ' . $limit . ' OFFSET ' . $offset;
417             } else {
418                 $qry .= ' LIMIT ' . $offset . ', ' . $limit;
419             }
420         }
421
422         $application = new Oauth_application();
423
424         $cnt = $application->query(sprintf($qry, $this->id));
425
426         return $application;
427     }
428
429     function subscriptionCount()
430     {
431         $c = common_memcache();
432
433         if (!empty($c)) {
434             $cnt = $c->get(common_cache_key('profile:subscription_count:'.$this->id));
435             if (is_integer($cnt)) {
436                 return (int) $cnt;
437             }
438         }
439
440         $sub = new Subscription();
441         $sub->subscriber = $this->id;
442
443         $cnt = (int) $sub->count('distinct subscribed');
444
445         $cnt = ($cnt > 0) ? $cnt - 1 : $cnt;
446
447         if (!empty($c)) {
448             $c->set(common_cache_key('profile:subscription_count:'.$this->id), $cnt);
449         }
450
451         return $cnt;
452     }
453
454     function subscriberCount()
455     {
456         $c = common_memcache();
457         if (!empty($c)) {
458             $cnt = $c->get(common_cache_key('profile:subscriber_count:'.$this->id));
459             if (is_integer($cnt)) {
460                 return (int) $cnt;
461             }
462         }
463
464         $sub = new Subscription();
465         $sub->subscribed = $this->id;
466         $sub->whereAdd('subscriber != subscribed');
467         $cnt = (int) $sub->count('distinct subscriber');
468
469         if (!empty($c)) {
470             $c->set(common_cache_key('profile:subscriber_count:'.$this->id), $cnt);
471         }
472
473         return $cnt;
474     }
475
476     function hasFave($notice)
477     {
478         $cache = common_memcache();
479
480         // XXX: Kind of a hack.
481
482         if (!empty($cache)) {
483             // This is the stream of favorite notices, in rev chron
484             // order. This forces it into cache.
485
486             $ids = Fave::stream($this->id, 0, NOTICE_CACHE_WINDOW);
487
488             // If it's in the list, then it's a fave
489
490             if (in_array($notice->id, $ids)) {
491                 return true;
492             }
493
494             // If we're not past the end of the cache window,
495             // then the cache has all available faves, so this one
496             // is not a fave.
497
498             if (count($ids) < NOTICE_CACHE_WINDOW) {
499                 return false;
500             }
501
502             // Otherwise, cache doesn't have all faves;
503             // fall through to the default
504         }
505
506         $fave = Fave::pkeyGet(array('user_id' => $this->id,
507                                     'notice_id' => $notice->id));
508         return ((is_null($fave)) ? false : true);
509     }
510
511     function faveCount()
512     {
513         $c = common_memcache();
514         if (!empty($c)) {
515             $cnt = $c->get(common_cache_key('profile:fave_count:'.$this->id));
516             if (is_integer($cnt)) {
517                 return (int) $cnt;
518             }
519         }
520
521         $faves = new Fave();
522         $faves->user_id = $this->id;
523         $cnt = (int) $faves->count('distinct notice_id');
524
525         if (!empty($c)) {
526             $c->set(common_cache_key('profile:fave_count:'.$this->id), $cnt);
527         }
528
529         return $cnt;
530     }
531
532     function noticeCount()
533     {
534         $c = common_memcache();
535
536         if (!empty($c)) {
537             $cnt = $c->get(common_cache_key('profile:notice_count:'.$this->id));
538             if (is_integer($cnt)) {
539                 return (int) $cnt;
540             }
541         }
542
543         $notices = new Notice();
544         $notices->profile_id = $this->id;
545         $cnt = (int) $notices->count('distinct id');
546
547         if (!empty($c)) {
548             $c->set(common_cache_key('profile:notice_count:'.$this->id), $cnt);
549         }
550
551         return $cnt;
552     }
553
554     function blowFavesCache()
555     {
556         $cache = common_memcache();
557         if ($cache) {
558             // Faves don't happen chronologically, so we need to blow
559             // ;last cache, too
560             $cache->delete(common_cache_key('fave:ids_by_user:'.$this->id));
561             $cache->delete(common_cache_key('fave:ids_by_user:'.$this->id.';last'));
562             $cache->delete(common_cache_key('fave:ids_by_user_own:'.$this->id));
563             $cache->delete(common_cache_key('fave:ids_by_user_own:'.$this->id.';last'));
564         }
565         $this->blowFaveCount();
566     }
567
568     function blowSubscriberCount()
569     {
570         $c = common_memcache();
571         if (!empty($c)) {
572             $c->delete(common_cache_key('profile:subscriber_count:'.$this->id));
573         }
574     }
575
576     function blowSubscriptionCount()
577     {
578         $c = common_memcache();
579         if (!empty($c)) {
580             $c->delete(common_cache_key('profile:subscription_count:'.$this->id));
581         }
582     }
583
584     function blowFaveCount()
585     {
586         $c = common_memcache();
587         if (!empty($c)) {
588             $c->delete(common_cache_key('profile:fave_count:'.$this->id));
589         }
590     }
591
592     function blowNoticeCount()
593     {
594         $c = common_memcache();
595         if (!empty($c)) {
596             $c->delete(common_cache_key('profile:notice_count:'.$this->id));
597         }
598     }
599
600     static function maxBio()
601     {
602         $biolimit = common_config('profile', 'biolimit');
603         // null => use global limit (distinct from 0!)
604         if (is_null($biolimit)) {
605             $biolimit = common_config('site', 'textlimit');
606         }
607         return $biolimit;
608     }
609
610     static function bioTooLong($bio)
611     {
612         $biolimit = self::maxBio();
613         return ($biolimit > 0 && !empty($bio) && (mb_strlen($bio) > $biolimit));
614     }
615
616     function delete()
617     {
618         $this->_deleteNotices();
619         $this->_deleteSubscriptions();
620         $this->_deleteMessages();
621         $this->_deleteTags();
622         $this->_deleteBlocks();
623
624         $related = array('Avatar',
625                          'Reply',
626                          'Group_member',
627                          );
628         Event::handle('ProfileDeleteRelated', array($this, &$related));
629
630         foreach ($related as $cls) {
631             $inst = new $cls();
632             $inst->profile_id = $this->id;
633             $inst->delete();
634         }
635
636         parent::delete();
637     }
638
639     function _deleteNotices()
640     {
641         $notice = new Notice();
642         $notice->profile_id = $this->id;
643
644         if ($notice->find()) {
645             while ($notice->fetch()) {
646                 $other = clone($notice);
647                 $other->delete();
648             }
649         }
650     }
651
652     function _deleteSubscriptions()
653     {
654         $sub = new Subscription();
655         $sub->subscriber = $this->id;
656
657         $sub->find();
658
659         while ($sub->fetch()) {
660             $other = Profile::staticGet('id', $sub->subscribed);
661             if (empty($other)) {
662                 continue;
663             }
664             if ($other->id == $this->id) {
665                 continue;
666             }
667             Subscription::cancel($this, $other);
668         }
669
670         $subd = new Subscription();
671         $subd->subscribed = $this->id;
672         $subd->find();
673
674         while ($subd->fetch()) {
675             $other = Profile::staticGet('id', $subd->subscriber);
676             if (empty($other)) {
677                 continue;
678             }
679             if ($other->id == $this->id) {
680                 continue;
681             }
682             Subscription::cancel($other, $this);
683         }
684
685         $self = new Subscription();
686
687         $self->subscriber = $this->id;
688         $self->subscribed = $this->id;
689
690         $self->delete();
691     }
692
693     function _deleteMessages()
694     {
695         $msg = new Message();
696         $msg->from_profile = $this->id;
697         $msg->delete();
698
699         $msg = new Message();
700         $msg->to_profile = $this->id;
701         $msg->delete();
702     }
703
704     function _deleteTags()
705     {
706         $tag = new Profile_tag();
707         $tag->tagged = $this->id;
708         $tag->delete();
709     }
710
711     function _deleteBlocks()
712     {
713         $block = new Profile_block();
714         $block->blocked = $this->id;
715         $block->delete();
716
717         $block = new Group_block();
718         $block->blocked = $this->id;
719         $block->delete();
720     }
721
722     // XXX: identical to Notice::getLocation.
723
724     function getLocation()
725     {
726         $location = null;
727
728         if (!empty($this->location_id) && !empty($this->location_ns)) {
729             $location = Location::fromId($this->location_id, $this->location_ns);
730         }
731
732         if (is_null($location)) { // no ID, or Location::fromId() failed
733             if (!empty($this->lat) && !empty($this->lon)) {
734                 $location = Location::fromLatLon($this->lat, $this->lon);
735             }
736         }
737
738         if (is_null($location)) { // still haven't found it!
739             if (!empty($this->location)) {
740                 $location = Location::fromName($this->location);
741             }
742         }
743
744         return $location;
745     }
746
747     function hasRole($name)
748     {
749         $has_role = false;
750         if (Event::handle('StartHasRole', array($this, $name, &$has_role))) {
751             $role = Profile_role::pkeyGet(array('profile_id' => $this->id,
752                                                 'role' => $name));
753             $has_role = !empty($role);
754             Event::handle('EndHasRole', array($this, $name, $has_role));
755         }
756         return $has_role;
757     }
758
759     function grantRole($name)
760     {
761         $role = new Profile_role();
762
763         $role->profile_id = $this->id;
764         $role->role       = $name;
765         $role->created    = common_sql_now();
766
767         $result = $role->insert();
768
769         if (!$result) {
770             common_log_db_error($role, 'INSERT', __FILE__);
771             return false;
772         }
773
774         return true;
775     }
776
777     function revokeRole($name)
778     {
779         $role = Profile_role::pkeyGet(array('profile_id' => $this->id,
780                                             'role' => $name));
781
782         if (empty($role)) {
783             // TRANS: Exception thrown when trying to revoke an existing role for a user that does not exist.
784             // TRANS: %1$s is the role name, %2$s is the user ID (number).
785             throw new Exception(sprintf(_('Cannot revoke role "%1$s" for user #%2$d; does not exist.'),$name, $this->id));
786         }
787
788         $result = $role->delete();
789
790         if (!$result) {
791             common_log_db_error($role, 'DELETE', __FILE__);
792             // TRANS: Exception thrown when trying to revoke a role for a user with a failing database query.
793             // TRANS: %1$s is the role name, %2$s is the user ID (number).
794             throw new Exception(sprintf(_('Cannot revoke role "%1$s" for user #%2$d; database error.'),$name, $this->id));
795         }
796
797         return true;
798     }
799
800     function isSandboxed()
801     {
802         return $this->hasRole(Profile_role::SANDBOXED);
803     }
804
805     function isSilenced()
806     {
807         return $this->hasRole(Profile_role::SILENCED);
808     }
809
810     function sandbox()
811     {
812         $this->grantRole(Profile_role::SANDBOXED);
813     }
814
815     function unsandbox()
816     {
817         $this->revokeRole(Profile_role::SANDBOXED);
818     }
819
820     function silence()
821     {
822         $this->grantRole(Profile_role::SILENCED);
823     }
824
825     function unsilence()
826     {
827         $this->revokeRole(Profile_role::SILENCED);
828     }
829
830     /**
831      * Does this user have the right to do X?
832      *
833      * With our role-based authorization, this is merely a lookup for whether the user
834      * has a particular role. The implementation currently uses a switch statement
835      * to determine if the user has the pre-defined role to exercise the right. Future
836      * implementations may allow per-site roles, and different mappings of roles to rights.
837      *
838      * @param $right string Name of the right, usually a constant in class Right
839      * @return boolean whether the user has the right in question
840      */
841     function hasRight($right)
842     {
843         $result = false;
844
845         if ($this->hasRole(Profile_role::DELETED)) {
846             return false;
847         }
848
849         if (Event::handle('UserRightsCheck', array($this, $right, &$result))) {
850             switch ($right)
851             {
852             case Right::DELETEOTHERSNOTICE:
853             case Right::MAKEGROUPADMIN:
854             case Right::SANDBOXUSER:
855             case Right::SILENCEUSER:
856             case Right::DELETEUSER:
857             case Right::DELETEGROUP:
858                 $result = $this->hasRole(Profile_role::MODERATOR);
859                 break;
860             case Right::CONFIGURESITE:
861                 $result = $this->hasRole(Profile_role::ADMINISTRATOR);
862                 break;
863             case Right::GRANTROLE:
864             case Right::REVOKEROLE:
865                 $result = $this->hasRole(Profile_role::OWNER);
866                 break;
867             case Right::NEWNOTICE:
868             case Right::NEWMESSAGE:
869             case Right::SUBSCRIBE:
870                 $result = !$this->isSilenced();
871                 break;
872             case Right::PUBLICNOTICE:
873             case Right::EMAILONREPLY:
874             case Right::EMAILONSUBSCRIBE:
875             case Right::EMAILONFAVE:
876                 $result = !$this->isSandboxed();
877                 break;
878             default:
879                 $result = false;
880                 break;
881             }
882         }
883         return $result;
884     }
885
886     function hasRepeated($notice_id)
887     {
888         // XXX: not really a pkey, but should work
889
890         $notice = Memcached_DataObject::pkeyGet('Notice',
891                                                 array('profile_id' => $this->id,
892                                                       'repeat_of' => $notice_id));
893
894         return !empty($notice);
895     }
896
897     /**
898      * Returns an XML string fragment with limited profile information
899      * as an Atom <author> element.
900      *
901      * Assumes that Atom has been previously set up as the base namespace.
902      *
903      * @param Profile $cur the current authenticated user
904      *
905      * @return string
906      */
907     function asAtomAuthor($cur = null)
908     {
909         $xs = new XMLStringer(true);
910
911         $xs->elementStart('author');
912         $xs->element('name', null, $this->nickname);
913         $xs->element('uri', null, $this->getUri());
914         if ($cur != null) {
915             $attrs = Array();
916             $attrs['following'] = $cur->isSubscribed($this) ? 'true' : 'false';
917             $attrs['blocking']  = $cur->hasBlocked($this) ? 'true' : 'false';
918             $xs->element('statusnet:profile_info', $attrs, null);
919         }
920         $xs->elementEnd('author');
921
922         return $xs->getString();
923     }
924
925     /**
926      * Returns an XML string fragment with profile information as an
927      * Activity Streams <activity:actor> element.
928      *
929      * Assumes that 'activity' namespace has been previously defined.
930      *
931      * @return string
932      */
933     function asActivityActor()
934     {
935         return $this->asActivityNoun('actor');
936     }
937
938     /**
939      * Returns an XML string fragment with profile information as an
940      * Activity Streams noun object with the given element type.
941      *
942      * Assumes that 'activity', 'georss', and 'poco' namespace has been
943      * previously defined.
944      *
945      * @param string $element one of 'actor', 'subject', 'object', 'target'
946      *
947      * @return string
948      */
949     function asActivityNoun($element)
950     {
951         $noun = ActivityObject::fromProfile($this);
952         return $noun->asString('activity:' . $element);
953     }
954
955     /**
956      * Returns the best URI for a profile. Plugins may override.
957      *
958      * @return string $uri
959      */
960     function getUri()
961     {
962         $uri = null;
963
964         // give plugins a chance to set the URI
965         if (Event::handle('StartGetProfileUri', array($this, &$uri))) {
966
967             // check for a local user first
968             $user = User::staticGet('id', $this->id);
969
970             if (!empty($user)) {
971                 $uri = $user->uri;
972             } else {
973                 // return OMB profile if any
974                 $remote = Remote_profile::staticGet('id', $this->id);
975                 if (!empty($remote)) {
976                     $uri = $remote->uri;
977                 }
978             }
979             Event::handle('EndGetProfileUri', array($this, &$uri));
980         }
981
982         return $uri;
983     }
984
985     function hasBlocked($other)
986     {
987         $block = Profile_block::get($this->id, $other->id);
988
989         if (empty($block)) {
990             $result = false;
991         } else {
992             $result = true;
993         }
994
995         return $result;
996     }
997
998     function getAtomFeed()
999     {
1000         $feed = null;
1001
1002         if (Event::handle('StartProfileGetAtomFeed', array($this, &$feed))) {
1003             $user = User::staticGet('id', $this->id);
1004             if (!empty($user)) {
1005                 $feed = common_local_url('ApiTimelineUser', array('id' => $user->id,
1006                                                                   'format' => 'atom'));
1007             }
1008             Event::handle('EndProfileGetAtomFeed', array($this, $feed));
1009         }
1010
1011         return $feed;
1012     }
1013
1014     static function fromURI($uri)
1015     {
1016         $profile = null;
1017
1018         if (Event::handle('StartGetProfileFromURI', array($uri, &$profile))) {
1019             // Get a local user or remote (OMB 0.1) profile
1020             $user = User::staticGet('uri', $uri);
1021             if (!empty($user)) {
1022                 $profile = $user->getProfile();
1023             } else {
1024                 $remote_profile = Remote_profile::staticGet('uri', $uri);
1025                 if (!empty($remote_profile)) {
1026                     $profile = Profile::staticGet('id', $remote_profile->profile_id);
1027                 }
1028             }
1029             Event::handle('EndGetProfileFromURI', array($uri, $profile));
1030         }
1031
1032         return $profile;
1033     }
1034 }