]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - lib/apiaction.php
Output selfLink from notice asActivity[Object]
[quix0rs-gnu-social.git] / lib / apiaction.php
1 <?php
2 /**
3  * StatusNet, the distributed open-source microblogging tool
4  *
5  * Base API action
6  *
7  * PHP version 5
8  *
9  * LICENCE: This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU Affero General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU Affero General Public License for more details.
18  *
19  * You should have received a copy of the GNU Affero General Public License
20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  *
22  * @category  API
23  * @package   StatusNet
24  * @author    Craig Andrews <candrews@integralblue.com>
25  * @author    Dan Moore <dan@moore.cx>
26  * @author    Evan Prodromou <evan@status.net>
27  * @author    Jeffery To <jeffery.to@gmail.com>
28  * @author    Toby Inkster <mail@tobyinkster.co.uk>
29  * @author    Zach Copley <zach@status.net>
30  * @copyright 2009-2010 StatusNet, Inc.
31  * @copyright 2009 Free Software Foundation, Inc http://www.fsf.org
32  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html GNU Affero General Public License version 3.0
33  * @link      http://status.net/
34  */
35
36 /* External API usage documentation. Please update when you change how the API works. */
37
38 /*! @mainpage StatusNet REST API
39
40     @section Introduction
41
42     Some explanatory text about the API would be nice.
43
44     @section API Methods
45
46     @subsection timelinesmethods_sec Timeline Methods
47
48     @li @ref publictimeline
49     @li @ref friendstimeline
50
51     @subsection statusmethods_sec Status Methods
52
53     @li @ref statusesupdate
54
55     @subsection usermethods_sec User Methods
56
57     @subsection directmessagemethods_sec Direct Message Methods (now a plugin)
58
59     @subsection friendshipmethods_sec Friendship Methods
60
61     @subsection socialgraphmethods_sec Social Graph Methods
62
63     @subsection accountmethods_sec Account Methods
64
65     @subsection favoritesmethods_sec Favorites Methods
66
67     @subsection blockmethods_sec Block Methods
68
69     @subsection oauthmethods_sec OAuth Methods
70
71     @subsection helpmethods_sec Help Methods
72
73     @subsection groupmethods_sec Group Methods
74
75     @page apiroot API Root
76
77     The URLs for methods referred to in this API documentation are
78     relative to the StatusNet API root. The API root is determined by the
79     site's @b server and @b path variables, which are generally specified
80     in config.php. For example:
81
82     @code
83     $config['site']['server'] = 'example.org';
84     $config['site']['path'] = 'statusnet'
85     @endcode
86
87     The pattern for a site's API root is: @c protocol://server/path/api E.g:
88
89     @c http://example.org/statusnet/api
90
91     The @b path can be empty.  In that case the API root would simply be:
92
93     @c http://example.org/api
94
95 */
96
97 if (!defined('STATUSNET')) {
98     exit(1);
99 }
100
101 class ApiValidationException extends Exception { }
102
103 /**
104  * Contains most of the Twitter-compatible API output functions.
105  *
106  * @category API
107  * @package  StatusNet
108  * @author   Craig Andrews <candrews@integralblue.com>
109  * @author   Dan Moore <dan@moore.cx>
110  * @author   Evan Prodromou <evan@status.net>
111  * @author   Jeffery To <jeffery.to@gmail.com>
112  * @author   Toby Inkster <mail@tobyinkster.co.uk>
113  * @author   Zach Copley <zach@status.net>
114  * @license  http://www.fsf.org/licensing/licenses/agpl-3.0.html GNU Affero General Public License version 3.0
115  * @link     http://status.net/
116  */
117 class ApiAction extends Action
118 {
119     const READ_ONLY  = 1;
120     const READ_WRITE = 2;
121
122     var $user      = null;
123     var $auth_user = null;
124     var $page      = null;
125     var $count     = null;
126     var $offset    = null;
127     var $limit     = null;
128     var $max_id    = null;
129     var $since_id  = null;
130     var $source    = null;
131     var $callback  = null;
132     var $format    = null;
133
134     var $access    = self::READ_ONLY;  // read (default) or read-write
135
136     static $reserved_sources = array('web', 'omb', 'ostatus', 'mail', 'xmpp', 'api');
137
138     /**
139      * Initialization.
140      *
141      * @param array $args Web and URL arguments
142      *
143      * @return boolean false if user doesn't exist
144      */
145     protected function prepare(array $args=array())
146     {
147         GNUsocial::setApi(true); // reduce exception reports to aid in debugging
148         parent::prepare($args);
149
150         $this->format   = $this->arg('format');
151         $this->callback = $this->arg('callback');
152         $this->page     = (int)$this->arg('page', 1);
153         $this->count    = (int)$this->arg('count', 20);
154         $this->max_id   = (int)$this->arg('max_id', 0);
155         $this->since_id = (int)$this->arg('since_id', 0);
156
157         // These two are not used everywhere, mainly just AtompubAction extensions
158         $this->offset   = ($this->page-1) * $this->count;
159         $this->limit    = $this->count + 1;
160
161         if ($this->arg('since')) {
162             header('X-GNUsocial-Warning: since parameter is disabled; use since_id');
163         }
164
165         $this->source = $this->trimmed('source');
166
167         if (empty($this->source) || in_array($this->source, self::$reserved_sources)) {
168             $this->source = 'api';
169         }
170
171         return true;
172     }
173
174     /**
175      * Handle a request
176      *
177      * @param array $args Arguments from $_REQUEST
178      *
179      * @return void
180      */
181     protected function handle()
182     {
183         header('Access-Control-Allow-Origin: *');
184         parent::handle();
185     }
186
187     /**
188      * Overrides XMLOutputter::element to write booleans as strings (true|false).
189      * See that method's documentation for more info.
190      *
191      * @param string $tag     Element type or tagname
192      * @param array  $attrs   Array of element attributes, as
193      *                        key-value pairs
194      * @param string $content string content of the element
195      *
196      * @return void
197      */
198     function element($tag, $attrs=null, $content=null)
199     {
200         if (is_bool($content)) {
201             $content = ($content ? 'true' : 'false');
202         }
203
204         return parent::element($tag, $attrs, $content);
205     }
206
207     function twitterUserArray($profile, $get_notice=false)
208     {
209         $twitter_user = array();
210
211         try {
212             $user = $profile->getUser();
213         } catch (NoSuchUserException $e) {
214             $user = null;
215         }
216
217         $twitter_user['id'] = $profile->getID();
218         $twitter_user['name'] = $profile->getBestName();
219         $twitter_user['screen_name'] = $profile->getNickname();
220         $twitter_user['location'] = $profile->location;
221         $twitter_user['description'] = $profile->getDescription();
222
223         // TODO: avatar url template (example.com/user/avatar?size={x}x{y})
224         $twitter_user['profile_image_url'] = Avatar::urlByProfile($profile, AVATAR_STREAM_SIZE);
225         $twitter_user['profile_image_url_https'] = $twitter_user['profile_image_url'];
226
227         // START introduced by qvitter API, not necessary for StatusNet API
228         $twitter_user['profile_image_url_profile_size'] = Avatar::urlByProfile($profile, AVATAR_PROFILE_SIZE);
229         try {
230             $avatar  = Avatar::getUploaded($profile);
231             $origurl = $avatar->displayUrl();
232         } catch (Exception $e) {
233             $origurl = $twitter_user['profile_image_url_profile_size'];
234         }
235         $twitter_user['profile_image_url_original'] = $origurl;
236
237         $twitter_user['groups_count'] = $profile->getGroupCount();
238         foreach (array('linkcolor', 'backgroundcolor') as $key) {
239             $twitter_user[$key] = Profile_prefs::getConfigData($profile, 'theme', $key);
240         }
241         // END introduced by qvitter API, not necessary for StatusNet API
242
243         $twitter_user['url'] = ($profile->homepage) ? $profile->homepage : null;
244         $twitter_user['protected'] = (!empty($user) && $user->private_stream) ? true : false;
245         $twitter_user['followers_count'] = $profile->subscriberCount();
246
247         // Note: some profiles don't have an associated user
248
249         $twitter_user['friends_count'] = $profile->subscriptionCount();
250
251         $twitter_user['created_at'] = self::dateTwitter($profile->created);
252
253         $timezone = 'UTC';
254
255         if (!empty($user) && $user->timezone) {
256             $timezone = $user->timezone;
257         }
258
259         $t = new DateTime;
260         $t->setTimezone(new DateTimeZone($timezone));
261
262         $twitter_user['utc_offset'] = $t->format('Z');
263         $twitter_user['time_zone'] = $timezone;
264         $twitter_user['statuses_count'] = $profile->noticeCount();
265
266         // Is the requesting user following this user?
267         // These values might actually also mean "unknown". Ambiguity issues?
268         $twitter_user['following'] = false;
269         $twitter_user['statusnet_blocking'] = false;
270         $twitter_user['notifications'] = false;
271
272         if ($this->scoped instanceof Profile) {
273             try {
274                 $sub = Subscription::getSubscription($this->scoped, $profile);
275                 // Notifications on?
276                 $twitter_user['following'] = true;
277                 $twitter_user['notifications'] = ($sub->jabber || $sub->sms);
278             } catch (NoResultException $e) {
279                 // well, the values are already false...
280             }
281             $twitter_user['statusnet_blocking']  = $this->scoped->hasBlocked($profile);            
282         }
283
284         if ($get_notice) {
285             $notice = $profile->getCurrentNotice();
286             if ($notice instanceof Notice) {
287                 // don't get user!
288                 $twitter_user['status'] = $this->twitterStatusArray($notice, false);
289             }
290         }
291
292         // StatusNet-specific
293
294         $twitter_user['statusnet_profile_url'] = $profile->profileurl;
295
296         // The event call to handle NoticeSimpleStatusArray lets plugins add data to the output array
297         Event::handle('TwitterUserArray', array($profile, &$twitter_user, $this->scoped, array()));
298
299         return $twitter_user;
300     }
301
302     function twitterStatusArray($notice, $include_user=true)
303     {
304         $base = $this->twitterSimpleStatusArray($notice, $include_user);
305
306         // FIXME: MOVE TO SHARE PLUGIN
307         if (!empty($notice->repeat_of)) {
308             $original = Notice::getKV('id', $notice->repeat_of);
309             if ($original instanceof Notice) {
310                 $orig_array = $this->twitterSimpleStatusArray($original, $include_user);
311                 $base['retweeted_status'] = $orig_array;
312             }
313         }
314
315         return $base;
316     }
317
318     function twitterSimpleStatusArray($notice, $include_user=true)
319     {
320         $profile = $notice->getProfile();
321
322         $twitter_status = array();
323         $twitter_status['text'] = $notice->content;
324         $twitter_status['truncated'] = false; # Not possible on StatusNet
325         $twitter_status['created_at'] = self::dateTwitter($notice->created);
326         try {
327             // We could just do $notice->reply_to but maybe the future holds a
328             // different story for parenting.
329             $parent = $notice->getParent();
330             $in_reply_to = $parent->id;
331         } catch (NoParentNoticeException $e) {
332             $in_reply_to = null;
333         } catch (NoResultException $e) {
334             // the in_reply_to message has probably been deleted
335             $in_reply_to = null;
336         }
337         $twitter_status['in_reply_to_status_id'] = $in_reply_to;
338
339         $source = null;
340         $source_link = null;
341
342         $ns = $notice->getSource();
343         if ($ns instanceof Notice_source) {
344             $source = $ns->code;
345             if (!empty($ns->url)) {
346                 $source_link = $ns->url;
347                 if (!empty($ns->name)) {
348                     $source = $ns->name;
349                 }
350             }
351         }
352
353         $twitter_status['uri'] = $notice->getUri();
354         $twitter_status['source'] = $source;
355         $twitter_status['source_link'] = $source_link;
356         $twitter_status['id'] = intval($notice->id);
357
358         $replier_profile = null;
359
360         if ($notice->reply_to) {
361             $reply = Notice::getKV(intval($notice->reply_to));
362             if ($reply) {
363                 $replier_profile = $reply->getProfile();
364             }
365         }
366
367         $twitter_status['in_reply_to_user_id'] =
368             ($replier_profile) ? intval($replier_profile->id) : null;
369         $twitter_status['in_reply_to_screen_name'] =
370             ($replier_profile) ? $replier_profile->nickname : null;
371
372         try {
373             $notloc = Notice_location::locFromStored($notice);
374             // This is the format that GeoJSON expects stuff to be in
375             $twitter_status['geo'] = array('type' => 'Point',
376                                            'coordinates' => array((float) $notloc->lat,
377                                                                   (float) $notloc->lon));
378         } catch (ServerException $e) {
379             $twitter_status['geo'] = null;
380         }
381
382         // Enclosures
383         $attachments = $notice->attachments();
384
385         if (!empty($attachments)) {
386
387             $twitter_status['attachments'] = array();
388
389             foreach ($attachments as $attachment) {
390                 try {
391                     $enclosure_o = $attachment->getEnclosure();
392                     $enclosure = array();
393                     $enclosure['url'] = $enclosure_o->url;
394                     $enclosure['mimetype'] = $enclosure_o->mimetype;
395                     $enclosure['size'] = $enclosure_o->size;
396                     $twitter_status['attachments'][] = $enclosure;
397                 } catch (ServerException $e) {
398                     // There was not enough metadata available
399                 }
400             }
401         }
402
403         if ($include_user && $profile) {
404             // Don't get notice (recursive!)
405             $twitter_user = $this->twitterUserArray($profile, false);
406             $twitter_status['user'] = $twitter_user;
407         }
408
409         // StatusNet-specific
410
411         $twitter_status['statusnet_html'] = $notice->getRendered();
412         $twitter_status['statusnet_conversation_id'] = intval($notice->conversation);
413
414         // The event call to handle NoticeSimpleStatusArray lets plugins add data to the output array
415         Event::handle('NoticeSimpleStatusArray', array($notice, &$twitter_status, $this->scoped,
416                                                        array('include_user'=>$include_user)));
417
418         return $twitter_status;
419     }
420
421     function twitterGroupArray($group)
422     {
423         $twitter_group = array();
424
425         $twitter_group['id'] = intval($group->id);
426         $twitter_group['url'] = $group->permalink();
427         $twitter_group['nickname'] = $group->nickname;
428         $twitter_group['fullname'] = $group->fullname;
429
430         if ($this->scoped instanceof Profile) {
431             $twitter_group['member'] = $this->scoped->isMember($group);
432             $twitter_group['blocked'] = Group_block::isBlocked(
433                 $group,
434                 $this->scoped
435             );
436         }
437
438         $twitter_group['admin_count'] = $group->getAdminCount();
439         $twitter_group['member_count'] = $group->getMemberCount();
440         $twitter_group['original_logo'] = $group->original_logo;
441         $twitter_group['homepage_logo'] = $group->homepage_logo;
442         $twitter_group['stream_logo'] = $group->stream_logo;
443         $twitter_group['mini_logo'] = $group->mini_logo;
444         $twitter_group['homepage'] = $group->homepage;
445         $twitter_group['description'] = $group->description;
446         $twitter_group['location'] = $group->location;
447         $twitter_group['created'] = self::dateTwitter($group->created);
448         $twitter_group['modified'] = self::dateTwitter($group->modified);
449
450         return $twitter_group;
451     }
452
453     function twitterRssGroupArray($group)
454     {
455         $entry = array();
456         $entry['content']=$group->description;
457         $entry['title']=$group->nickname;
458         $entry['link']=$group->permalink();
459         $entry['published']=common_date_iso8601($group->created);
460         $entry['updated']==common_date_iso8601($group->modified);
461         $taguribase = common_config('integration', 'groupuri');
462         $entry['id'] = "group:$groupuribase:$entry[link]";
463
464         $entry['description'] = $entry['content'];
465         $entry['pubDate'] = common_date_rfc2822($group->created);
466         $entry['guid'] = $entry['link'];
467
468         return $entry;
469     }
470
471     function twitterListArray($list)
472     {
473         $profile = Profile::getKV('id', $list->tagger);
474
475         $twitter_list = array();
476         $twitter_list['id'] = $list->id;
477         $twitter_list['name'] = $list->tag;
478         $twitter_list['full_name'] = '@'.$profile->nickname.'/'.$list->tag;;
479         $twitter_list['slug'] = $list->tag;
480         $twitter_list['description'] = $list->description;
481         $twitter_list['subscriber_count'] = $list->subscriberCount();
482         $twitter_list['member_count'] = $list->taggedCount();
483         $twitter_list['uri'] = $list->getUri();
484
485         if ($this->scoped instanceof Profile) {
486             $twitter_list['following'] = $list->hasSubscriber($this->scoped);
487         } else {
488             $twitter_list['following'] = false;
489         }
490
491         $twitter_list['mode'] = ($list->private) ? 'private' : 'public';
492         $twitter_list['user'] = $this->twitterUserArray($profile, false);
493
494         return $twitter_list;
495     }
496
497     function twitterRssEntryArray($notice)
498     {
499         $entry = array();
500
501         if (Event::handle('StartRssEntryArray', array($notice, &$entry))) {
502             $profile = $notice->getProfile();
503
504             // We trim() to avoid extraneous whitespace in the output
505
506             $entry['content'] = common_xml_safe_str(trim($notice->getRendered()));
507             $entry['title'] = $profile->nickname . ': ' . common_xml_safe_str(trim($notice->content));
508             $entry['link'] = common_local_url('shownotice', array('notice' => $notice->id));
509             $entry['published'] = common_date_iso8601($notice->created);
510
511             $taguribase = TagURI::base();
512             $entry['id'] = "tag:$taguribase:$entry[link]";
513
514             $entry['updated'] = $entry['published'];
515             $entry['author'] = $profile->getBestName();
516
517             // Enclosures
518             $attachments = $notice->attachments();
519             $enclosures = array();
520
521             foreach ($attachments as $attachment) {
522                 try {
523                     $enclosure_o = $attachment->getEnclosure();
524                     $enclosure = array();
525                     $enclosure['url'] = $enclosure_o->url;
526                     $enclosure['mimetype'] = $enclosure_o->mimetype;
527                     $enclosure['size'] = $enclosure_o->size;
528                     $enclosures[] = $enclosure;
529                 } catch (ServerException $e) {
530                     // There was not enough metadata available
531                 }
532             }
533
534             if (!empty($enclosures)) {
535                 $entry['enclosures'] = $enclosures;
536             }
537
538             // Tags/Categories
539             $tag = new Notice_tag();
540             $tag->notice_id = $notice->id;
541             if ($tag->find()) {
542                 $entry['tags']=array();
543                 while ($tag->fetch()) {
544                     $entry['tags'][]=$tag->tag;
545                 }
546             }
547             $tag->free();
548
549             // RSS Item specific
550             $entry['description'] = $entry['content'];
551             $entry['pubDate'] = common_date_rfc2822($notice->created);
552             $entry['guid'] = $entry['link'];
553
554             try {
555                 $notloc = Notice_location::locFromStored($notice);
556                 // This is the format that GeoJSON expects stuff to be in.
557                 // showGeoRSS() below uses it for XML output, so we reuse it
558                 $entry['geo'] = array('type' => 'Point',
559                                       'coordinates' => array((float) $notloc->lat,
560                                                              (float) $notloc->lon));
561             } catch (ServerException $e) {
562                 $entry['geo'] = null;
563             }
564
565             Event::handle('EndRssEntryArray', array($notice, &$entry));
566         }
567
568         return $entry;
569     }
570
571     function twitterRelationshipArray($source, $target)
572     {
573         $relationship = array();
574
575         $relationship['source'] =
576             $this->relationshipDetailsArray($source->getProfile(), $target->getProfile());
577         $relationship['target'] =
578             $this->relationshipDetailsArray($target->getProfile(), $source->getProfile());
579
580         return array('relationship' => $relationship);
581     }
582
583     function relationshipDetailsArray(Profile $source, Profile $target)
584     {
585         $details = array();
586
587         $details['screen_name'] = $source->getNickname();
588         $details['followed_by'] = $target->isSubscribed($source);
589
590         try {
591             $sub = Subscription::getSubscription($source, $target);
592             $details['following'] = true;
593             $details['notifications_enabled'] = ($sub->jabber || $sub->sms);
594         } catch (NoResultException $e) {
595             $details['following'] = false;
596             $details['notifications_enabled'] = false;
597         }
598
599         $details['blocking'] = $source->hasBlocked($target);
600         $details['id'] = intval($source->id);
601
602         return $details;
603     }
604
605     function showTwitterXmlRelationship($relationship)
606     {
607         $this->elementStart('relationship');
608
609         foreach($relationship as $element => $value) {
610             if ($element == 'source' || $element == 'target') {
611                 $this->elementStart($element);
612                 $this->showXmlRelationshipDetails($value);
613                 $this->elementEnd($element);
614             }
615         }
616
617         $this->elementEnd('relationship');
618     }
619
620     function showXmlRelationshipDetails($details)
621     {
622         foreach($details as $element => $value) {
623             $this->element($element, null, $value);
624         }
625     }
626
627     function showTwitterXmlStatus($twitter_status, $tag='status', $namespaces=false)
628     {
629         $attrs = array();
630         if ($namespaces) {
631             $attrs['xmlns:statusnet'] = 'http://status.net/schema/api/1/';
632         }
633         $this->elementStart($tag, $attrs);
634         foreach($twitter_status as $element => $value) {
635             switch ($element) {
636             case 'user':
637                 $this->showTwitterXmlUser($twitter_status['user']);
638                 break;
639             case 'text':
640                 $this->element($element, null, common_xml_safe_str($value));
641                 break;
642             case 'attachments':
643                 $this->showXmlAttachments($twitter_status['attachments']);
644                 break;
645             case 'geo':
646                 $this->showGeoXML($value);
647                 break;
648             case 'retweeted_status':
649                 // FIXME: MOVE TO SHARE PLUGIN
650                 $this->showTwitterXmlStatus($value, 'retweeted_status');
651                 break;
652             default:
653                 if (strncmp($element, 'statusnet_', 10) == 0) {
654                     if ($element === 'statusnet_in_groups' && is_array($value)) {
655                         // QVITTERFIX because it would cause an array to be sent as $value
656                         // THIS IS UNDOCUMENTED AND SHOULD NEVER BE RELIED UPON (qvitter uses json output)
657                         $value = json_encode($value);
658                     }
659                     $this->element('statusnet:'.substr($element, 10), null, $value);
660                 } else {
661                     $this->element($element, null, $value);
662                 }
663             }
664         }
665         $this->elementEnd($tag);
666     }
667
668     function showTwitterXmlGroup($twitter_group)
669     {
670         $this->elementStart('group');
671         foreach($twitter_group as $element => $value) {
672             $this->element($element, null, $value);
673         }
674         $this->elementEnd('group');
675     }
676
677     function showTwitterXmlList($twitter_list)
678     {
679         $this->elementStart('list');
680         foreach($twitter_list as $element => $value) {
681             if($element == 'user') {
682                 $this->showTwitterXmlUser($value, 'user');
683             }
684             else {
685                 $this->element($element, null, $value);
686             }
687         }
688         $this->elementEnd('list');
689     }
690
691     function showTwitterXmlUser($twitter_user, $role='user', $namespaces=false)
692     {
693         $attrs = array();
694         if ($namespaces) {
695             $attrs['xmlns:statusnet'] = 'http://status.net/schema/api/1/';
696         }
697         $this->elementStart($role, $attrs);
698         foreach($twitter_user as $element => $value) {
699             if ($element == 'status') {
700                 $this->showTwitterXmlStatus($twitter_user['status']);
701             } else if (strncmp($element, 'statusnet_', 10) == 0) {
702                 $this->element('statusnet:'.substr($element, 10), null, $value);
703             } else {
704                 $this->element($element, null, $value);
705             }
706         }
707         $this->elementEnd($role);
708     }
709
710     function showXmlAttachments($attachments) {
711         if (!empty($attachments)) {
712             $this->elementStart('attachments', array('type' => 'array'));
713             foreach ($attachments as $attachment) {
714                 $attrs = array();
715                 $attrs['url'] = $attachment['url'];
716                 $attrs['mimetype'] = $attachment['mimetype'];
717                 $attrs['size'] = $attachment['size'];
718                 $this->element('enclosure', $attrs, '');
719             }
720             $this->elementEnd('attachments');
721         }
722     }
723
724     function showGeoXML($geo)
725     {
726         if (empty($geo)) {
727             // empty geo element
728             $this->element('geo');
729         } else {
730             $this->elementStart('geo', array('xmlns:georss' => 'http://www.georss.org/georss'));
731             $this->element('georss:point', null, $geo['coordinates'][0] . ' ' . $geo['coordinates'][1]);
732             $this->elementEnd('geo');
733         }
734     }
735
736     function showGeoRSS($geo)
737     {
738         if (!empty($geo)) {
739             $this->element(
740                 'georss:point',
741                 null,
742                 $geo['coordinates'][0] . ' ' . $geo['coordinates'][1]
743             );
744         }
745     }
746
747     function showTwitterRssItem($entry)
748     {
749         $this->elementStart('item');
750         $this->element('title', null, $entry['title']);
751         $this->element('description', null, $entry['description']);
752         $this->element('pubDate', null, $entry['pubDate']);
753         $this->element('guid', null, $entry['guid']);
754         $this->element('link', null, $entry['link']);
755
756         // RSS only supports 1 enclosure per item
757         if(array_key_exists('enclosures', $entry) and !empty($entry['enclosures'])){
758             $enclosure = $entry['enclosures'][0];
759             $this->element('enclosure', array('url'=>$enclosure['url'],'type'=>$enclosure['mimetype'],'length'=>$enclosure['size']), null);
760         }
761
762         if(array_key_exists('tags', $entry)){
763             foreach($entry['tags'] as $tag){
764                 $this->element('category', null,$tag);
765             }
766         }
767
768         $this->showGeoRSS($entry['geo']);
769         $this->elementEnd('item');
770     }
771
772     function showJsonObjects($objects)
773     {
774         $json_objects = json_encode($objects);
775         if($json_objects === false) {
776             $this->clientError(_('JSON encoding failed. Error: ').json_last_error_msg());                  
777         } else {
778                 print $json_objects;
779         }
780     }
781
782
783     function showSingleXmlStatus($notice)
784     {
785         $this->initDocument('xml');
786         $twitter_status = $this->twitterStatusArray($notice);
787         $this->showTwitterXmlStatus($twitter_status, 'status', true);
788         $this->endDocument('xml');
789     }
790
791     function showSingleAtomStatus($notice)
792     {
793         header('Content-Type: application/atom+xml; charset=utf-8');
794         print $notice->asAtomEntry(true, true, true, $this->scoped);
795     }
796
797     function show_single_json_status($notice)
798     {
799         $this->initDocument('json');
800         $status = $this->twitterStatusArray($notice);
801         $this->showJsonObjects($status);
802         $this->endDocument('json');
803     }
804
805     function showXmlTimeline($notice)
806     {
807         $this->initDocument('xml');
808         $this->elementStart('statuses', array('type' => 'array',
809                                               'xmlns:statusnet' => 'http://status.net/schema/api/1/'));
810
811         if (is_array($notice)) {
812             //FIXME: make everything calling showJsonTimeline use only Notice objects
813             $ids = array();
814             foreach ($notice as $n) {
815                 $ids[] = $n->getID();
816             }
817             $notice = Notice::multiGet('id', $ids);
818         }
819
820         while ($notice->fetch()) {
821             try {
822                 $twitter_status = $this->twitterStatusArray($notice);
823                 $this->showTwitterXmlStatus($twitter_status);
824             } catch (Exception $e) {
825                 common_log(LOG_ERR, $e->getMessage());
826                 continue;
827             }
828         }
829
830         $this->elementEnd('statuses');
831         $this->endDocument('xml');
832     }
833
834     function showRssTimeline($notice, $title, $link, $subtitle, $suplink = null, $logo = null, $self = null)
835     {
836         $this->initDocument('rss');
837
838         $this->element('title', null, $title);
839         $this->element('link', null, $link);
840
841         if (!is_null($self)) {
842             $this->element(
843                 'atom:link',
844                 array(
845                     'type' => 'application/rss+xml',
846                     'href' => $self,
847                     'rel'  => 'self'
848                 )
849            );
850         }
851
852         if (!is_null($suplink)) {
853             // For FriendFeed's SUP protocol
854             $this->element('link', array('xmlns' => 'http://www.w3.org/2005/Atom',
855                                          'rel' => 'http://api.friendfeed.com/2008/03#sup',
856                                          'href' => $suplink,
857                                          'type' => 'application/json'));
858         }
859
860         if (!is_null($logo)) {
861             $this->elementStart('image');
862             $this->element('link', null, $link);
863             $this->element('title', null, $title);
864             $this->element('url', null, $logo);
865             $this->elementEnd('image');
866         }
867
868         $this->element('description', null, $subtitle);
869         $this->element('language', null, 'en-us');
870         $this->element('ttl', null, '40');
871
872         if (is_array($notice)) {
873             //FIXME: make everything calling showJsonTimeline use only Notice objects
874             $ids = array();
875             foreach ($notice as $n) {
876                 $ids[] = $n->getID();
877             }
878             $notice = Notice::multiGet('id', $ids);
879         }
880
881         while ($notice->fetch()) {
882             try {
883                 $entry = $this->twitterRssEntryArray($notice);
884                 $this->showTwitterRssItem($entry);
885             } catch (Exception $e) {
886                 common_log(LOG_ERR, $e->getMessage());
887                 // continue on exceptions
888             }
889         }
890
891         $this->endTwitterRss();
892     }
893
894     function showAtomTimeline($notice, $title, $id, $link, $subtitle=null, $suplink=null, $selfuri=null, $logo=null)
895     {
896         $this->initDocument('atom');
897
898         $this->element('title', null, $title);
899         $this->element('id', null, $id);
900         $this->element('link', array('href' => $link, 'rel' => 'alternate', 'type' => 'text/html'), null);
901
902         if (!is_null($logo)) {
903             $this->element('logo',null,$logo);
904         }
905
906         if (!is_null($suplink)) {
907             // For FriendFeed's SUP protocol
908             $this->element('link', array('rel' => 'http://api.friendfeed.com/2008/03#sup',
909                                          'href' => $suplink,
910                                          'type' => 'application/json'));
911         }
912
913         if (!is_null($selfuri)) {
914             $this->element('link', array('href' => $selfuri,
915                 'rel' => 'self', 'type' => 'application/atom+xml'), null);
916         }
917
918         $this->element('updated', null, common_date_iso8601('now'));
919         $this->element('subtitle', null, $subtitle);
920
921         if (is_array($notice)) {
922             //FIXME: make everything calling showJsonTimeline use only Notice objects
923             $ids = array();
924             foreach ($notice as $n) {
925                 $ids[] = $n->getID();
926             }
927             $notice = Notice::multiGet('id', $ids);
928         }
929
930         while ($notice->fetch()) {
931             try {
932                 $this->raw($notice->asAtomEntry());
933             } catch (Exception $e) {
934                 common_log(LOG_ERR, $e->getMessage());
935                 continue;
936             }
937         }
938
939         $this->endDocument('atom');
940     }
941
942     function showRssGroups($group, $title, $link, $subtitle)
943     {
944         $this->initDocument('rss');
945
946         $this->element('title', null, $title);
947         $this->element('link', null, $link);
948         $this->element('description', null, $subtitle);
949         $this->element('language', null, 'en-us');
950         $this->element('ttl', null, '40');
951
952         if (is_array($group)) {
953             foreach ($group as $g) {
954                 $twitter_group = $this->twitterRssGroupArray($g);
955                 $this->showTwitterRssItem($twitter_group);
956             }
957         } else {
958             while ($group->fetch()) {
959                 $twitter_group = $this->twitterRssGroupArray($group);
960                 $this->showTwitterRssItem($twitter_group);
961             }
962         }
963
964         $this->endTwitterRss();
965     }
966
967     function showTwitterAtomEntry($entry)
968     {
969         $this->elementStart('entry');
970         $this->element('title', null, common_xml_safe_str($entry['title']));
971         $this->element(
972             'content',
973             array('type' => 'html'),
974             common_xml_safe_str($entry['content'])
975         );
976         $this->element('id', null, $entry['id']);
977         $this->element('published', null, $entry['published']);
978         $this->element('updated', null, $entry['updated']);
979         $this->element('link', array('type' => 'text/html',
980                                      'href' => $entry['link'],
981                                      'rel' => 'alternate'));
982         $this->element('link', array('type' => $entry['avatar-type'],
983                                      'href' => $entry['avatar'],
984                                      'rel' => 'image'));
985         $this->elementStart('author');
986
987         $this->element('name', null, $entry['author-name']);
988         $this->element('uri', null, $entry['author-uri']);
989
990         $this->elementEnd('author');
991         $this->elementEnd('entry');
992     }
993
994     function showAtomGroups($group, $title, $id, $link, $subtitle=null, $selfuri=null)
995     {
996         $this->initDocument('atom');
997
998         $this->element('title', null, common_xml_safe_str($title));
999         $this->element('id', null, $id);
1000         $this->element('link', array('href' => $link, 'rel' => 'alternate', 'type' => 'text/html'), null);
1001
1002         if (!is_null($selfuri)) {
1003             $this->element('link', array('href' => $selfuri,
1004                 'rel' => 'self', 'type' => 'application/atom+xml'), null);
1005         }
1006
1007         $this->element('updated', null, common_date_iso8601('now'));
1008         $this->element('subtitle', null, common_xml_safe_str($subtitle));
1009
1010         if (is_array($group)) {
1011             foreach ($group as $g) {
1012                 $this->raw($g->asAtomEntry());
1013             }
1014         } else {
1015             while ($group->fetch()) {
1016                 $this->raw($group->asAtomEntry());
1017             }
1018         }
1019
1020         $this->endDocument('atom');
1021
1022     }
1023
1024     function showJsonTimeline($notice)
1025     {
1026         $this->initDocument('json');
1027
1028         $statuses = array();
1029
1030         if (is_array($notice)) {
1031             //FIXME: make everything calling showJsonTimeline use only Notice objects
1032             $ids = array();
1033             foreach ($notice as $n) {
1034                 $ids[] = $n->getID();
1035             }
1036             $notice = Notice::multiGet('id', $ids);
1037         }
1038
1039         while ($notice->fetch()) {
1040             try {
1041                 $twitter_status = $this->twitterStatusArray($notice);
1042                 array_push($statuses, $twitter_status);
1043             } catch (Exception $e) {
1044                 common_log(LOG_ERR, $e->getMessage());
1045                 continue;
1046             }
1047         }
1048
1049         $this->showJsonObjects($statuses);
1050
1051         $this->endDocument('json');
1052     }
1053
1054     function showJsonGroups($group)
1055     {
1056         $this->initDocument('json');
1057
1058         $groups = array();
1059
1060         if (is_array($group)) {
1061             foreach ($group as $g) {
1062                 $twitter_group = $this->twitterGroupArray($g);
1063                 array_push($groups, $twitter_group);
1064             }
1065         } else {
1066             while ($group->fetch()) {
1067                 $twitter_group = $this->twitterGroupArray($group);
1068                 array_push($groups, $twitter_group);
1069             }
1070         }
1071
1072         $this->showJsonObjects($groups);
1073
1074         $this->endDocument('json');
1075     }
1076
1077     function showXmlGroups($group)
1078     {
1079
1080         $this->initDocument('xml');
1081         $this->elementStart('groups', array('type' => 'array'));
1082
1083         if (is_array($group)) {
1084             foreach ($group as $g) {
1085                 $twitter_group = $this->twitterGroupArray($g);
1086                 $this->showTwitterXmlGroup($twitter_group);
1087             }
1088         } else {
1089             while ($group->fetch()) {
1090                 $twitter_group = $this->twitterGroupArray($group);
1091                 $this->showTwitterXmlGroup($twitter_group);
1092             }
1093         }
1094
1095         $this->elementEnd('groups');
1096         $this->endDocument('xml');
1097     }
1098
1099     function showXmlLists($list, $next_cursor=0, $prev_cursor=0)
1100     {
1101
1102         $this->initDocument('xml');
1103         $this->elementStart('lists_list');
1104         $this->elementStart('lists', array('type' => 'array'));
1105
1106         if (is_array($list)) {
1107             foreach ($list as $l) {
1108                 $twitter_list = $this->twitterListArray($l);
1109                 $this->showTwitterXmlList($twitter_list);
1110             }
1111         } else {
1112             while ($list->fetch()) {
1113                 $twitter_list = $this->twitterListArray($list);
1114                 $this->showTwitterXmlList($twitter_list);
1115             }
1116         }
1117
1118         $this->elementEnd('lists');
1119
1120         $this->element('next_cursor', null, $next_cursor);
1121         $this->element('previous_cursor', null, $prev_cursor);
1122
1123         $this->elementEnd('lists_list');
1124         $this->endDocument('xml');
1125     }
1126
1127     function showJsonLists($list, $next_cursor=0, $prev_cursor=0)
1128     {
1129         $this->initDocument('json');
1130
1131         $lists = array();
1132
1133         if (is_array($list)) {
1134             foreach ($list as $l) {
1135                 $twitter_list = $this->twitterListArray($l);
1136                 array_push($lists, $twitter_list);
1137             }
1138         } else {
1139             while ($list->fetch()) {
1140                 $twitter_list = $this->twitterListArray($list);
1141                 array_push($lists, $twitter_list);
1142             }
1143         }
1144
1145         $lists_list = array(
1146             'lists' => $lists,
1147             'next_cursor' => $next_cursor,
1148             'next_cursor_str' => strval($next_cursor),
1149             'previous_cursor' => $prev_cursor,
1150             'previous_cursor_str' => strval($prev_cursor)
1151         );
1152
1153         $this->showJsonObjects($lists_list);
1154
1155         $this->endDocument('json');
1156     }
1157
1158     function showTwitterXmlUsers($user)
1159     {
1160         $this->initDocument('xml');
1161         $this->elementStart('users', array('type' => 'array',
1162                                            'xmlns:statusnet' => 'http://status.net/schema/api/1/'));
1163
1164         if (is_array($user)) {
1165             foreach ($user as $u) {
1166                 $twitter_user = $this->twitterUserArray($u);
1167                 $this->showTwitterXmlUser($twitter_user);
1168             }
1169         } else {
1170             while ($user->fetch()) {
1171                 $twitter_user = $this->twitterUserArray($user);
1172                 $this->showTwitterXmlUser($twitter_user);
1173             }
1174         }
1175
1176         $this->elementEnd('users');
1177         $this->endDocument('xml');
1178     }
1179
1180     function showJsonUsers($user)
1181     {
1182         $this->initDocument('json');
1183
1184         $users = array();
1185
1186         if (is_array($user)) {
1187             foreach ($user as $u) {
1188                 $twitter_user = $this->twitterUserArray($u);
1189                 array_push($users, $twitter_user);
1190             }
1191         } else {
1192             while ($user->fetch()) {
1193                 $twitter_user = $this->twitterUserArray($user);
1194                 array_push($users, $twitter_user);
1195             }
1196         }
1197
1198         $this->showJsonObjects($users);
1199
1200         $this->endDocument('json');
1201     }
1202
1203     function showSingleJsonGroup($group)
1204     {
1205         $this->initDocument('json');
1206         $twitter_group = $this->twitterGroupArray($group);
1207         $this->showJsonObjects($twitter_group);
1208         $this->endDocument('json');
1209     }
1210
1211     function showSingleXmlGroup($group)
1212     {
1213         $this->initDocument('xml');
1214         $twitter_group = $this->twitterGroupArray($group);
1215         $this->showTwitterXmlGroup($twitter_group);
1216         $this->endDocument('xml');
1217     }
1218
1219     function showSingleJsonList($list)
1220     {
1221         $this->initDocument('json');
1222         $twitter_list = $this->twitterListArray($list);
1223         $this->showJsonObjects($twitter_list);
1224         $this->endDocument('json');
1225     }
1226
1227     function showSingleXmlList($list)
1228     {
1229         $this->initDocument('xml');
1230         $twitter_list = $this->twitterListArray($list);
1231         $this->showTwitterXmlList($twitter_list);
1232         $this->endDocument('xml');
1233     }
1234
1235     static function dateTwitter($dt)
1236     {
1237         $dateStr = date('d F Y H:i:s', strtotime($dt));
1238         $d = new DateTime($dateStr, new DateTimeZone('UTC'));
1239         $d->setTimezone(new DateTimeZone(common_timezone()));
1240         return $d->format('D M d H:i:s O Y');
1241     }
1242
1243     function initDocument($type='xml')
1244     {
1245         switch ($type) {
1246         case 'xml':
1247             header('Content-Type: application/xml; charset=utf-8');
1248             $this->startXML();
1249             break;
1250         case 'json':
1251             header('Content-Type: application/json; charset=utf-8');
1252
1253             // Check for JSONP callback
1254             if (isset($this->callback)) {
1255                 print $this->callback . '(';
1256             }
1257             break;
1258         case 'rss':
1259             header("Content-Type: application/rss+xml; charset=utf-8");
1260             $this->initTwitterRss();
1261             break;
1262         case 'atom':
1263             header('Content-Type: application/atom+xml; charset=utf-8');
1264             $this->initTwitterAtom();
1265             break;
1266         default:
1267             // TRANS: Client error on an API request with an unsupported data format.
1268             $this->clientError(_('Not a supported data format.'));
1269         }
1270
1271         return;
1272     }
1273
1274     function endDocument($type='xml')
1275     {
1276         switch ($type) {
1277         case 'xml':
1278             $this->endXML();
1279             break;
1280         case 'json':
1281             // Check for JSONP callback
1282             if (isset($this->callback)) {
1283                 print ')';
1284             }
1285             break;
1286         case 'rss':
1287             $this->endTwitterRss();
1288             break;
1289         case 'atom':
1290             $this->endTwitterRss();
1291             break;
1292         default:
1293             // TRANS: Client error on an API request with an unsupported data format.
1294             $this->clientError(_('Not a supported data format.'));
1295         }
1296         return;
1297     }
1298
1299     function initTwitterRss()
1300     {
1301         $this->startXML();
1302         $this->elementStart(
1303             'rss',
1304             array(
1305                 'version'      => '2.0',
1306                 'xmlns:atom'   => 'http://www.w3.org/2005/Atom',
1307                 'xmlns:georss' => 'http://www.georss.org/georss'
1308             )
1309         );
1310         $this->elementStart('channel');
1311         Event::handle('StartApiRss', array($this));
1312     }
1313
1314     function endTwitterRss()
1315     {
1316         $this->elementEnd('channel');
1317         $this->elementEnd('rss');
1318         $this->endXML();
1319     }
1320
1321     function initTwitterAtom()
1322     {
1323         $this->startXML();
1324         // FIXME: don't hardcode the language here!
1325         $this->elementStart('feed', array('xmlns' => 'http://www.w3.org/2005/Atom',
1326                                           'xml:lang' => 'en-US',
1327                                           'xmlns:thr' => 'http://purl.org/syndication/thread/1.0'));
1328     }
1329
1330     function endTwitterAtom()
1331     {
1332         $this->elementEnd('feed');
1333         $this->endXML();
1334     }
1335
1336     function showProfile($profile, $content_type='xml', $notice=null, $includeStatuses=true)
1337     {
1338         $profile_array = $this->twitterUserArray($profile, $includeStatuses);
1339         switch ($content_type) {
1340         case 'xml':
1341             $this->showTwitterXmlUser($profile_array);
1342             break;
1343         case 'json':
1344             $this->showJsonObjects($profile_array);
1345             break;
1346         default:
1347             // TRANS: Client error on an API request with an unsupported data format.
1348             $this->clientError(_('Not a supported data format.'));
1349         }
1350         return;
1351     }
1352
1353     private static function is_decimal($str)
1354     {
1355         return preg_match('/^[0-9]+$/', $str);
1356     }
1357
1358     function getTargetUser($id)
1359     {
1360         if (empty($id)) {
1361             // Twitter supports these other ways of passing the user ID
1362             if (self::is_decimal($this->arg('id'))) {
1363                 return User::getKV($this->arg('id'));
1364             } else if ($this->arg('id')) {
1365                 $nickname = common_canonical_nickname($this->arg('id'));
1366                 return User::getKV('nickname', $nickname);
1367             } else if ($this->arg('user_id')) {
1368                 // This is to ensure that a non-numeric user_id still
1369                 // overrides screen_name even if it doesn't get used
1370                 if (self::is_decimal($this->arg('user_id'))) {
1371                     return User::getKV('id', $this->arg('user_id'));
1372                 }
1373             } else if ($this->arg('screen_name')) {
1374                 $nickname = common_canonical_nickname($this->arg('screen_name'));
1375                 return User::getKV('nickname', $nickname);
1376             } else {
1377                 // Fall back to trying the currently authenticated user
1378                 return $this->scoped->getUser();
1379             }
1380
1381         } else if (self::is_decimal($id)) {
1382             return User::getKV($id);
1383         } else {
1384             $nickname = common_canonical_nickname($id);
1385             return User::getKV('nickname', $nickname);
1386         }
1387     }
1388
1389     function getTargetProfile($id)
1390     {
1391         if (empty($id)) {
1392
1393             // Twitter supports these other ways of passing the user ID
1394             if (self::is_decimal($this->arg('id'))) {
1395                 return Profile::getKV($this->arg('id'));
1396             } else if ($this->arg('id')) {
1397                 // Screen names currently can only uniquely identify a local user.
1398                 $nickname = common_canonical_nickname($this->arg('id'));
1399                 $user = User::getKV('nickname', $nickname);
1400                 return $user ? $user->getProfile() : null;
1401             } else if ($this->arg('user_id')) {
1402                 // This is to ensure that a non-numeric user_id still
1403                 // overrides screen_name even if it doesn't get used
1404                 if (self::is_decimal($this->arg('user_id'))) {
1405                     return Profile::getKV('id', $this->arg('user_id'));
1406                 }
1407             } elseif (mb_strlen($this->arg('screen_name')) > 0) {
1408                 $nickname = common_canonical_nickname($this->arg('screen_name'));
1409                 $user = User::getByNickname($nickname);
1410                 return $user->getProfile();
1411             } else {
1412                 // Fall back to trying the currently authenticated user
1413                 return $this->scoped;
1414             }
1415         } else if (self::is_decimal($id) && intval($id) > 0) {
1416             return Profile::getByID($id);
1417         } else {
1418             // FIXME: check if isAcct to identify remote profiles and not just local nicknames
1419             $nickname = common_canonical_nickname($id);
1420             $user = User::getByNickname($nickname);
1421             return $user->getProfile();
1422         }
1423     }
1424
1425     function getTargetGroup($id)
1426     {
1427         if (empty($id)) {
1428             if (self::is_decimal($this->arg('id'))) {
1429                 return User_group::getKV('id', $this->arg('id'));
1430             } else if ($this->arg('id')) {
1431                 return User_group::getForNickname($this->arg('id'));
1432             } else if ($this->arg('group_id')) {
1433                 // This is to ensure that a non-numeric group_id still
1434                 // overrides group_name even if it doesn't get used
1435                 if (self::is_decimal($this->arg('group_id'))) {
1436                     return User_group::getKV('id', $this->arg('group_id'));
1437                 }
1438             } else if ($this->arg('group_name')) {
1439                 return User_group::getForNickname($this->arg('group_name'));
1440             }
1441
1442         } else if (self::is_decimal($id)) {
1443             return User_group::getKV('id', $id);
1444         } else if ($this->arg('uri')) { // FIXME: move this into empty($id) check?
1445             return User_group::getKV('uri', urldecode($this->arg('uri')));
1446         } else {
1447             return User_group::getForNickname($id);
1448         }
1449     }
1450
1451     function getTargetList($user=null, $id=null)
1452     {
1453         $tagger = $this->getTargetUser($user);
1454         $list = null;
1455
1456         if (empty($id)) {
1457             $id = $this->arg('id');
1458         }
1459
1460         if($id) {
1461             if (is_numeric($id)) {
1462                 $list = Profile_list::getKV('id', $id);
1463
1464                 // only if the list with the id belongs to the tagger
1465                 if(empty($list) || $list->tagger != $tagger->id) {
1466                     $list = null;
1467                 }
1468             }
1469             if (empty($list)) {
1470                 $tag = common_canonical_tag($id);
1471                 $list = Profile_list::getByTaggerAndTag($tagger->id, $tag);
1472             }
1473
1474             if (!empty($list) && $list->private) {
1475                 if ($this->scoped->id == $list->tagger) {
1476                     return $list;
1477                 }
1478             } else {
1479                 return $list;
1480             }
1481         }
1482         return null;
1483     }
1484
1485     /**
1486      * Returns query argument or default value if not found. Certain
1487      * parameters used throughout the API are lightly scrubbed and
1488      * bounds checked.  This overrides Action::arg().
1489      *
1490      * @param string $key requested argument
1491      * @param string $def default value to return if $key is not provided
1492      *
1493      * @return var $var
1494      */
1495     function arg($key, $def=null)
1496     {
1497         // XXX: Do even more input validation/scrubbing?
1498
1499         if (array_key_exists($key, $this->args)) {
1500             switch($key) {
1501             case 'page':
1502                 $page = (int)$this->args['page'];
1503                 return ($page < 1) ? 1 : $page;
1504             case 'count':
1505                 $count = (int)$this->args['count'];
1506                 if ($count < 1) {
1507                     return 20;
1508                 } elseif ($count > 200) {
1509                     return 200;
1510                 } else {
1511                     return $count;
1512                 }
1513             case 'since_id':
1514                 $since_id = (int)$this->args['since_id'];
1515                 return ($since_id < 1) ? 0 : $since_id;
1516             case 'max_id':
1517                 $max_id = (int)$this->args['max_id'];
1518                 return ($max_id < 1) ? 0 : $max_id;
1519             default:
1520                 return parent::arg($key, $def);
1521             }
1522         } else {
1523             return $def;
1524         }
1525     }
1526
1527     /**
1528      * Calculate the complete URI that called up this action.  Used for
1529      * Atom rel="self" links.  Warning: this is funky.
1530      *
1531      * @return string URL    a URL suitable for rel="self" Atom links
1532      */
1533     function getSelfUri()
1534     {
1535         $action = mb_substr(get_class($this), 0, -6); // remove 'Action'
1536
1537         $id = $this->arg('id');
1538         $aargs = array('format' => $this->format);
1539         if (!empty($id)) {
1540             $aargs['id'] = $id;
1541         }
1542
1543         $user = $this->arg('user');
1544         if (!empty($user)) {
1545             $aargs['user'] = $user;
1546         }
1547
1548         $tag = $this->arg('tag');
1549         if (!empty($tag)) {
1550             $aargs['tag'] = $tag;
1551         }
1552
1553         parse_str($_SERVER['QUERY_STRING'], $params);
1554         $pstring = '';
1555         if (!empty($params)) {
1556             unset($params['p']);
1557             $pstring = http_build_query($params);
1558         }
1559
1560         $uri = common_local_url($action, $aargs);
1561
1562         if (!empty($pstring)) {
1563             $uri .= '?' . $pstring;
1564         }
1565
1566         return $uri;
1567     }
1568 }