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'] = intval($profile->id);
 218         $twitter_user['name'] = $profile->getBestName();
 219         $twitter_user['screen_name'] = $profile->nickname;
 220         $twitter_user['location'] = ($profile->location) ? $profile->location : null;
 221         $twitter_user['description'] = ($profile->bio) ? $profile->bio : null;
 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['statusnet_blocking']  = $this->scoped->hasBlocked($profile);
 278                 $twitter_user['notifications'] = ($sub->jabber || $sub->sms);
 279             } catch (NoResultException $e) {
 280                 // well, the values are already false...
 281             }
 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         }
 334         $twitter_status['in_reply_to_status_id'] = $in_reply_to;
 335
 336         $source = null;
 337
 338         $ns = $notice->getSource();
 339         if ($ns instanceof Notice_source) {
 340             if (!empty($ns->name) && !empty($ns->url)) {
 341                 $source = '<a href="'
 342                     . htmlspecialchars($ns->url)
 343                     . '" rel="nofollow">'
 344                     . htmlspecialchars($ns->name)
 345                     . '</a>';
 346             } else {
 347                 $source = $ns->code;
 348             }
 349         }
 350
 351         $twitter_status['uri'] = $notice->getUri();
 352         $twitter_status['source'] = $source;
 353         $twitter_status['id'] = intval($notice->id);
 354
 355         $replier_profile = null;
 356
 357         if ($notice->reply_to) {
 358             $reply = Notice::getKV(intval($notice->reply_to));
 359             if ($reply) {
 360                 $replier_profile = $reply->getProfile();
 361             }
 362         }
 363
 364         $twitter_status['in_reply_to_user_id'] =
 365             ($replier_profile) ? intval($replier_profile->id) : null;
 366         $twitter_status['in_reply_to_screen_name'] =
 367             ($replier_profile) ? $replier_profile->nickname : null;
 368
 369         try {
 370             $notloc = Notice_location::locFromStored($notice);
 371             // This is the format that GeoJSON expects stuff to be in
 372             $twitter_status['geo'] = array('type' => 'Point',
 373                                            'coordinates' => array((float) $notloc->lat,
 374                                                                   (float) $notloc->lon));
 375         } catch (ServerException $e) {
 376             $twitter_status['geo'] = null;
 377         }
 378
 379         // Enclosures
 380         $attachments = $notice->attachments();
 381
 382         if (!empty($attachments)) {
 383
 384             $twitter_status['attachments'] = array();
 385
 386             foreach ($attachments as $attachment) {
 387                 try {
 388                     $enclosure_o = $attachment->getEnclosure();
 389                     $enclosure = array();
 390                     $enclosure['url'] = $enclosure_o->url;
 391                     $enclosure['mimetype'] = $enclosure_o->mimetype;
 392                     $enclosure['size'] = $enclosure_o->size;
 393                     $twitter_status['attachments'][] = $enclosure;
 394                 } catch (ServerException $e) {
 395                     // There was not enough metadata available
 396                 }
 397             }
 398         }
 399
 400         if ($include_user && $profile) {
 401             // Don't get notice (recursive!)
 402             $twitter_user = $this->twitterUserArray($profile, false);
 403             $twitter_status['user'] = $twitter_user;
 404         }
 405
 406         // StatusNet-specific
 407
 408         $twitter_status['statusnet_html'] = $notice->rendered;
 409         $twitter_status['statusnet_conversation_id'] = intval($notice->conversation);
 410
 411         // The event call to handle NoticeSimpleStatusArray lets plugins add data to the output array
 412         Event::handle('NoticeSimpleStatusArray', array($notice, &$twitter_status, $this->scoped,
 413                                                        array('include_user'=>$include_user)));
 414
 415         return $twitter_status;
 416     }
 417
 418     function twitterGroupArray($group)
 419     {
 420         $twitter_group = array();
 421
 422         $twitter_group['id'] = intval($group->id);
 423         $twitter_group['url'] = $group->permalink();
 424         $twitter_group['nickname'] = $group->nickname;
 425         $twitter_group['fullname'] = $group->fullname;
 426
 427         if ($this->scoped instanceof Profile) {
 428             $twitter_group['member'] = $this->scoped->isMember($group);
 429             $twitter_group['blocked'] = Group_block::isBlocked(
 430                 $group,
 431                 $this->scoped
 432             );
 433         }
 434
 435         $twitter_group['admin_count'] = $group->getAdminCount();
 436         $twitter_group['member_count'] = $group->getMemberCount();
 437         $twitter_group['original_logo'] = $group->original_logo;
 438         $twitter_group['homepage_logo'] = $group->homepage_logo;
 439         $twitter_group['stream_logo'] = $group->stream_logo;
 440         $twitter_group['mini_logo'] = $group->mini_logo;
 441         $twitter_group['homepage'] = $group->homepage;
 442         $twitter_group['description'] = $group->description;
 443         $twitter_group['location'] = $group->location;
 444         $twitter_group['created'] = self::dateTwitter($group->created);
 445         $twitter_group['modified'] = self::dateTwitter($group->modified);
 446
 447         return $twitter_group;
 448     }
 449
 450     function twitterRssGroupArray($group)
 451     {
 452         $entry = array();
 453         $entry['content']=$group->description;
 454         $entry['title']=$group->nickname;
 455         $entry['link']=$group->permalink();
 456         $entry['published']=common_date_iso8601($group->created);
 457         $entry['updated']==common_date_iso8601($group->modified);
 458         $taguribase = common_config('integration', 'groupuri');
 459         $entry['id'] = "group:$groupuribase:$entry[link]";
 460
 461         $entry['description'] = $entry['content'];
 462         $entry['pubDate'] = common_date_rfc2822($group->created);
 463         $entry['guid'] = $entry['link'];
 464
 465         return $entry;
 466     }
 467
 468     function twitterListArray($list)
 469     {
 470         $profile = Profile::getKV('id', $list->tagger);
 471
 472         $twitter_list = array();
 473         $twitter_list['id'] = $list->id;
 474         $twitter_list['name'] = $list->tag;
 475         $twitter_list['full_name'] = '@'.$profile->nickname.'/'.$list->tag;;
 476         $twitter_list['slug'] = $list->tag;
 477         $twitter_list['description'] = $list->description;
 478         $twitter_list['subscriber_count'] = $list->subscriberCount();
 479         $twitter_list['member_count'] = $list->taggedCount();
 480         $twitter_list['uri'] = $list->getUri();
 481
 482         if ($this->scoped instanceof Profile) {
 483             $twitter_list['following'] = $list->hasSubscriber($this->scoped);
 484         } else {
 485             $twitter_list['following'] = false;
 486         }
 487
 488         $twitter_list['mode'] = ($list->private) ? 'private' : 'public';
 489         $twitter_list['user'] = $this->twitterUserArray($profile, false);
 490
 491         return $twitter_list;
 492     }
 493
 494     function twitterRssEntryArray($notice)
 495     {
 496         $entry = array();
 497
 498         if (Event::handle('StartRssEntryArray', array($notice, &$entry))) {
 499             $profile = $notice->getProfile();
 500
 501             // We trim() to avoid extraneous whitespace in the output
 502
 503             $entry['content'] = common_xml_safe_str(trim($notice->rendered));
 504             $entry['title'] = $profile->nickname . ': ' . common_xml_safe_str(trim($notice->content));
 505             $entry['link'] = common_local_url('shownotice', array('notice' => $notice->id));
 506             $entry['published'] = common_date_iso8601($notice->created);
 507
 508             $taguribase = TagURI::base();
 509             $entry['id'] = "tag:$taguribase:$entry[link]";
 510
 511             $entry['updated'] = $entry['published'];
 512             $entry['author'] = $profile->getBestName();
 513
 514             // Enclosures
 515             $attachments = $notice->attachments();
 516             $enclosures = array();
 517
 518             foreach ($attachments as $attachment) {
 519                 try {
 520                     $enclosure_o = $attachment->getEnclosure();
 521                     $enclosure = array();
 522                     $enclosure['url'] = $enclosure_o->url;
 523                     $enclosure['mimetype'] = $enclosure_o->mimetype;
 524                     $enclosure['size'] = $enclosure_o->size;
 525                     $enclosures[] = $enclosure;
 526                 } catch (ServerException $e) {
 527                     // There was not enough metadata available
 528                 }
 529             }
 530
 531             if (!empty($enclosures)) {
 532                 $entry['enclosures'] = $enclosures;
 533             }
 534
 535             // Tags/Categories
 536             $tag = new Notice_tag();
 537             $tag->notice_id = $notice->id;
 538             if ($tag->find()) {
 539                 $entry['tags']=array();
 540                 while ($tag->fetch()) {
 541                     $entry['tags'][]=$tag->tag;
 542                 }
 543             }
 544             $tag->free();
 545
 546             // RSS Item specific
 547             $entry['description'] = $entry['content'];
 548             $entry['pubDate'] = common_date_rfc2822($notice->created);
 549             $entry['guid'] = $entry['link'];
 550
 551             try {
 552                 $notloc = Notice_location::locFromStored($notice);
 553                 // This is the format that GeoJSON expects stuff to be in.
 554                 // showGeoRSS() below uses it for XML output, so we reuse it
 555                 $entry['geo'] = array('type' => 'Point',
 556                                       'coordinates' => array((float) $notloc->lat,
 557                                                              (float) $notloc->lon));
 558             } catch (ServerException $e) {
 559                 $entry['geo'] = null;
 560             }
 561
 562             Event::handle('EndRssEntryArray', array($notice, &$entry));
 563         }
 564
 565         return $entry;
 566     }
 567
 568     function twitterRelationshipArray($source, $target)
 569     {
 570         $relationship = array();
 571
 572         $relationship['source'] =
 573             $this->relationshipDetailsArray($source->getProfile(), $target->getProfile());
 574         $relationship['target'] =
 575             $this->relationshipDetailsArray($target->getProfile(), $source->getProfile());
 576
 577         return array('relationship' => $relationship);
 578     }
 579
 580     function relationshipDetailsArray(Profile $source, Profile $target)
 581     {
 582         $details = array();
 583
 584         $details['screen_name'] = $source->getNickname();
 585         $details['followed_by'] = $target->isSubscribed($source);
 586
 587         try {
 588             $sub = Subscription::getSubscription($source, $target);
 589             $details['following'] = true;
 590             $details['notifications_enabled'] = ($sub->jabber || $sub->sms);
 591         } catch (NoResultException $e) {
 592             $details['following'] = false;
 593             $details['notifications_enabled'] = false;
 594         }
 595
 596         $details['blocking'] = $source->hasBlocked($target);
 597         $details['id'] = intval($source->id);
 598
 599         return $details;
 600     }
 601
 602     function showTwitterXmlRelationship($relationship)
 603     {
 604         $this->elementStart('relationship');
 605
 606         foreach($relationship as $element => $value) {
 607             if ($element == 'source' || $element == 'target') {
 608                 $this->elementStart($element);
 609                 $this->showXmlRelationshipDetails($value);
 610                 $this->elementEnd($element);
 611             }
 612         }
 613
 614         $this->elementEnd('relationship');
 615     }
 616
 617     function showXmlRelationshipDetails($details)
 618     {
 619         foreach($details as $element => $value) {
 620             $this->element($element, null, $value);
 621         }
 622     }
 623
 624     function showTwitterXmlStatus($twitter_status, $tag='status', $namespaces=false)
 625     {
 626         $attrs = array();
 627         if ($namespaces) {
 628             $attrs['xmlns:statusnet'] = 'http://status.net/schema/api/1/';
 629         }
 630         $this->elementStart($tag, $attrs);
 631         foreach($twitter_status as $element => $value) {
 632             switch ($element) {
 633             case 'user':
 634                 $this->showTwitterXmlUser($twitter_status['user']);
 635                 break;
 636             case 'text':
 637                 $this->element($element, null, common_xml_safe_str($value));
 638                 break;
 639             case 'attachments':
 640                 $this->showXmlAttachments($twitter_status['attachments']);
 641                 break;
 642             case 'geo':
 643                 $this->showGeoXML($value);
 644                 break;
 645             case 'retweeted_status':
 646                 // FIXME: MOVE TO SHARE PLUGIN
 647                 $this->showTwitterXmlStatus($value, 'retweeted_status');
 648                 break;
 649             default:
 650                 if (strncmp($element, 'statusnet_', 10) == 0) {
 651                     $this->element('statusnet:'.substr($element, 10), null, $value);
 652                 } else {
 653                     $this->element($element, null, $value);
 654                 }
 655             }
 656         }
 657         $this->elementEnd($tag);
 658     }
 659
 660     function showTwitterXmlGroup($twitter_group)
 661     {
 662         $this->elementStart('group');
 663         foreach($twitter_group as $element => $value) {
 664             $this->element($element, null, $value);
 665         }
 666         $this->elementEnd('group');
 667     }
 668
 669     function showTwitterXmlList($twitter_list)
 670     {
 671         $this->elementStart('list');
 672         foreach($twitter_list as $element => $value) {
 673             if($element == 'user') {
 674                 $this->showTwitterXmlUser($value, 'user');
 675             }
 676             else {
 677                 $this->element($element, null, $value);
 678             }
 679         }
 680         $this->elementEnd('list');
 681     }
 682
 683     function showTwitterXmlUser($twitter_user, $role='user', $namespaces=false)
 684     {
 685         $attrs = array();
 686         if ($namespaces) {
 687             $attrs['xmlns:statusnet'] = 'http://status.net/schema/api/1/';
 688         }
 689         $this->elementStart($role, $attrs);
 690         foreach($twitter_user as $element => $value) {
 691             if ($element == 'status') {
 692                 $this->showTwitterXmlStatus($twitter_user['status']);
 693             } else if (strncmp($element, 'statusnet_', 10) == 0) {
 694                 $this->element('statusnet:'.substr($element, 10), null, $value);
 695             } else {
 696                 $this->element($element, null, $value);
 697             }
 698         }
 699         $this->elementEnd($role);
 700     }
 701
 702     function showXmlAttachments($attachments) {
 703         if (!empty($attachments)) {
 704             $this->elementStart('attachments', array('type' => 'array'));
 705             foreach ($attachments as $attachment) {
 706                 $attrs = array();
 707                 $attrs['url'] = $attachment['url'];
 708                 $attrs['mimetype'] = $attachment['mimetype'];
 709                 $attrs['size'] = $attachment['size'];
 710                 $this->element('enclosure', $attrs, '');
 711             }
 712             $this->elementEnd('attachments');
 713         }
 714     }
 715
 716     function showGeoXML($geo)
 717     {
 718         if (empty($geo)) {
 719             // empty geo element
 720             $this->element('geo');
 721         } else {
 722             $this->elementStart('geo', array('xmlns:georss' => 'http://www.georss.org/georss'));
 723             $this->element('georss:point', null, $geo['coordinates'][0] . ' ' . $geo['coordinates'][1]);
 724             $this->elementEnd('geo');
 725         }
 726     }
 727
 728     function showGeoRSS($geo)
 729     {
 730         if (!empty($geo)) {
 731             $this->element(
 732                 'georss:point',
 733                 null,
 734                 $geo['coordinates'][0] . ' ' . $geo['coordinates'][1]
 735             );
 736         }
 737     }
 738
 739     function showTwitterRssItem($entry)
 740     {
 741         $this->elementStart('item');
 742         $this->element('title', null, $entry['title']);
 743         $this->element('description', null, $entry['description']);
 744         $this->element('pubDate', null, $entry['pubDate']);
 745         $this->element('guid', null, $entry['guid']);
 746         $this->element('link', null, $entry['link']);
 747
 748         // RSS only supports 1 enclosure per item
 749         if(array_key_exists('enclosures', $entry) and !empty($entry['enclosures'])){
 750             $enclosure = $entry['enclosures'][0];
 751             $this->element('enclosure', array('url'=>$enclosure['url'],'type'=>$enclosure['mimetype'],'length'=>$enclosure['size']), null);
 752         }
 753
 754         if(array_key_exists('tags', $entry)){
 755             foreach($entry['tags'] as $tag){
 756                 $this->element('category', null,$tag);
 757             }
 758         }
 759
 760         $this->showGeoRSS($entry['geo']);
 761         $this->elementEnd('item');
 762     }
 763
 764     function showJsonObjects($objects)
 765     {
 766         print(json_encode($objects));
 767     }
 768
 769     function showSingleXmlStatus($notice)
 770     {
 771         $this->initDocument('xml');
 772         $twitter_status = $this->twitterStatusArray($notice);
 773         $this->showTwitterXmlStatus($twitter_status, 'status', true);
 774         $this->endDocument('xml');
 775     }
 776
 777     function showSingleAtomStatus($notice)
 778     {
 779         header('Content-Type: application/atom+xml; charset=utf-8');
 780         print $notice->asAtomEntry(true, true, true, $this->scoped);
 781     }
 782
 783     function show_single_json_status($notice)
 784     {
 785         $this->initDocument('json');
 786         $status = $this->twitterStatusArray($notice);
 787         $this->showJsonObjects($status);
 788         $this->endDocument('json');
 789     }
 790
 791     function showXmlTimeline($notice)
 792     {
 793         $this->initDocument('xml');
 794         $this->elementStart('statuses', array('type' => 'array',
 795                                               'xmlns:statusnet' => 'http://status.net/schema/api/1/'));
 796
 797         if (is_array($notice)) {
 798             $notice = new ArrayWrapper($notice);
 799         }
 800
 801         while ($notice->fetch()) {
 802             try {
 803                 $twitter_status = $this->twitterStatusArray($notice);
 804                 $this->showTwitterXmlStatus($twitter_status);
 805             } catch (Exception $e) {
 806                 common_log(LOG_ERR, $e->getMessage());
 807                 continue;
 808             }
 809         }
 810
 811         $this->elementEnd('statuses');
 812         $this->endDocument('xml');
 813     }
 814
 815     function showRssTimeline($notice, $title, $link, $subtitle, $suplink = null, $logo = null, $self = null)
 816     {
 817         $this->initDocument('rss');
 818
 819         $this->element('title', null, $title);
 820         $this->element('link', null, $link);
 821
 822         if (!is_null($self)) {
 823             $this->element(
 824                 'atom:link',
 825                 array(
 826                     'type' => 'application/rss+xml',
 827                     'href' => $self,
 828                     'rel'  => 'self'
 829                 )
 830            );
 831         }
 832
 833         if (!is_null($suplink)) {
 834             // For FriendFeed's SUP protocol
 835             $this->element('link', array('xmlns' => 'http://www.w3.org/2005/Atom',
 836                                          'rel' => 'http://api.friendfeed.com/2008/03#sup',
 837                                          'href' => $suplink,
 838                                          'type' => 'application/json'));
 839         }
 840
 841         if (!is_null($logo)) {
 842             $this->elementStart('image');
 843             $this->element('link', null, $link);
 844             $this->element('title', null, $title);
 845             $this->element('url', null, $logo);
 846             $this->elementEnd('image');
 847         }
 848
 849         $this->element('description', null, $subtitle);
 850         $this->element('language', null, 'en-us');
 851         $this->element('ttl', null, '40');
 852
 853         if (is_array($notice)) {
 854             $notice = new ArrayWrapper($notice);
 855         }
 856
 857         while ($notice->fetch()) {
 858             try {
 859                 $entry = $this->twitterRssEntryArray($notice);
 860                 $this->showTwitterRssItem($entry);
 861             } catch (Exception $e) {
 862                 common_log(LOG_ERR, $e->getMessage());
 863                 // continue on exceptions
 864             }
 865         }
 866
 867         $this->endTwitterRss();
 868     }
 869
 870     function showAtomTimeline($notice, $title, $id, $link, $subtitle=null, $suplink=null, $selfuri=null, $logo=null)
 871     {
 872         $this->initDocument('atom');
 873
 874         $this->element('title', null, $title);
 875         $this->element('id', null, $id);
 876         $this->element('link', array('href' => $link, 'rel' => 'alternate', 'type' => 'text/html'), null);
 877
 878         if (!is_null($logo)) {
 879             $this->element('logo',null,$logo);
 880         }
 881
 882         if (!is_null($suplink)) {
 883             // For FriendFeed's SUP protocol
 884             $this->element('link', array('rel' => 'http://api.friendfeed.com/2008/03#sup',
 885                                          'href' => $suplink,
 886                                          'type' => 'application/json'));
 887         }
 888
 889         if (!is_null($selfuri)) {
 890             $this->element('link', array('href' => $selfuri,
 891                 'rel' => 'self', 'type' => 'application/atom+xml'), null);
 892         }
 893
 894         $this->element('updated', null, common_date_iso8601('now'));
 895         $this->element('subtitle', null, $subtitle);
 896
 897         if (is_array($notice)) {
 898             $notice = new ArrayWrapper($notice);
 899         }
 900
 901         while ($notice->fetch()) {
 902             try {
 903                 $this->raw($notice->asAtomEntry());
 904             } catch (Exception $e) {
 905                 common_log(LOG_ERR, $e->getMessage());
 906                 continue;
 907             }
 908         }
 909
 910         $this->endDocument('atom');
 911     }
 912
 913     function showRssGroups($group, $title, $link, $subtitle)
 914     {
 915         $this->initDocument('rss');
 916
 917         $this->element('title', null, $title);
 918         $this->element('link', null, $link);
 919         $this->element('description', null, $subtitle);
 920         $this->element('language', null, 'en-us');
 921         $this->element('ttl', null, '40');
 922
 923         if (is_array($group)) {
 924             foreach ($group as $g) {
 925                 $twitter_group = $this->twitterRssGroupArray($g);
 926                 $this->showTwitterRssItem($twitter_group);
 927             }
 928         } else {
 929             while ($group->fetch()) {
 930                 $twitter_group = $this->twitterRssGroupArray($group);
 931                 $this->showTwitterRssItem($twitter_group);
 932             }
 933         }
 934
 935         $this->endTwitterRss();
 936     }
 937
 938     function showTwitterAtomEntry($entry)
 939     {
 940         $this->elementStart('entry');
 941         $this->element('title', null, common_xml_safe_str($entry['title']));
 942         $this->element(
 943             'content',
 944             array('type' => 'html'),
 945             common_xml_safe_str($entry['content'])
 946         );
 947         $this->element('id', null, $entry['id']);
 948         $this->element('published', null, $entry['published']);
 949         $this->element('updated', null, $entry['updated']);
 950         $this->element('link', array('type' => 'text/html',
 951                                      'href' => $entry['link'],
 952                                      'rel' => 'alternate'));
 953         $this->element('link', array('type' => $entry['avatar-type'],
 954                                      'href' => $entry['avatar'],
 955                                      'rel' => 'image'));
 956         $this->elementStart('author');
 957
 958         $this->element('name', null, $entry['author-name']);
 959         $this->element('uri', null, $entry['author-uri']);
 960
 961         $this->elementEnd('author');
 962         $this->elementEnd('entry');
 963     }
 964
 965     function showAtomGroups($group, $title, $id, $link, $subtitle=null, $selfuri=null)
 966     {
 967         $this->initDocument('atom');
 968
 969         $this->element('title', null, common_xml_safe_str($title));
 970         $this->element('id', null, $id);
 971         $this->element('link', array('href' => $link, 'rel' => 'alternate', 'type' => 'text/html'), null);
 972
 973         if (!is_null($selfuri)) {
 974             $this->element('link', array('href' => $selfuri,
 975                 'rel' => 'self', 'type' => 'application/atom+xml'), null);
 976         }
 977
 978         $this->element('updated', null, common_date_iso8601('now'));
 979         $this->element('subtitle', null, common_xml_safe_str($subtitle));
 980
 981         if (is_array($group)) {
 982             foreach ($group as $g) {
 983                 $this->raw($g->asAtomEntry());
 984             }
 985         } else {
 986             while ($group->fetch()) {
 987                 $this->raw($group->asAtomEntry());
 988             }
 989         }
 990
 991         $this->endDocument('atom');
 992
 993     }
 994
 995     function showJsonTimeline($notice)
 996     {
 997         $this->initDocument('json');
 998
 999         $statuses = array();
1000
1001         if (is_array($notice)) {
1002             //FIXME: make everything calling showJsonTimeline use only Notice objects
1003             common_debug('ArrayWrapper avoidance in progress! Beep boop, make showJsonTimeline only receive Notice objects!');
1004             $ids = array();
1005             foreach ($notice as $n) {
1006                 $ids[] = $n->getID();
1007             }
1008             $notice = Notice::multiGet('id', $ids);
1009         }
1010
1011         while ($notice->fetch()) {
1012             try {
1013                 $twitter_status = $this->twitterStatusArray($notice);
1014                 array_push($statuses, $twitter_status);
1015             } catch (Exception $e) {
1016                 common_log(LOG_ERR, $e->getMessage());
1017                 continue;
1018             }
1019         }
1020
1021         $this->showJsonObjects($statuses);
1022
1023         $this->endDocument('json');
1024     }
1025
1026     function showJsonGroups($group)
1027     {
1028         $this->initDocument('json');
1029
1030         $groups = array();
1031
1032         if (is_array($group)) {
1033             foreach ($group as $g) {
1034                 $twitter_group = $this->twitterGroupArray($g);
1035                 array_push($groups, $twitter_group);
1036             }
1037         } else {
1038             while ($group->fetch()) {
1039                 $twitter_group = $this->twitterGroupArray($group);
1040                 array_push($groups, $twitter_group);
1041             }
1042         }
1043
1044         $this->showJsonObjects($groups);
1045
1046         $this->endDocument('json');
1047     }
1048
1049     function showXmlGroups($group)
1050     {
1051
1052         $this->initDocument('xml');
1053         $this->elementStart('groups', array('type' => 'array'));
1054
1055         if (is_array($group)) {
1056             foreach ($group as $g) {
1057                 $twitter_group = $this->twitterGroupArray($g);
1058                 $this->showTwitterXmlGroup($twitter_group);
1059             }
1060         } else {
1061             while ($group->fetch()) {
1062                 $twitter_group = $this->twitterGroupArray($group);
1063                 $this->showTwitterXmlGroup($twitter_group);
1064             }
1065         }
1066
1067         $this->elementEnd('groups');
1068         $this->endDocument('xml');
1069     }
1070
1071     function showXmlLists($list, $next_cursor=0, $prev_cursor=0)
1072     {
1073
1074         $this->initDocument('xml');
1075         $this->elementStart('lists_list');
1076         $this->elementStart('lists', array('type' => 'array'));
1077
1078         if (is_array($list)) {
1079             foreach ($list as $l) {
1080                 $twitter_list = $this->twitterListArray($l);
1081                 $this->showTwitterXmlList($twitter_list);
1082             }
1083         } else {
1084             while ($list->fetch()) {
1085                 $twitter_list = $this->twitterListArray($list);
1086                 $this->showTwitterXmlList($twitter_list);
1087             }
1088         }
1089
1090         $this->elementEnd('lists');
1091
1092         $this->element('next_cursor', null, $next_cursor);
1093         $this->element('previous_cursor', null, $prev_cursor);
1094
1095         $this->elementEnd('lists_list');
1096         $this->endDocument('xml');
1097     }
1098
1099     function showJsonLists($list, $next_cursor=0, $prev_cursor=0)
1100     {
1101         $this->initDocument('json');
1102
1103         $lists = array();
1104
1105         if (is_array($list)) {
1106             foreach ($list as $l) {
1107                 $twitter_list = $this->twitterListArray($l);
1108                 array_push($lists, $twitter_list);
1109             }
1110         } else {
1111             while ($list->fetch()) {
1112                 $twitter_list = $this->twitterListArray($list);
1113                 array_push($lists, $twitter_list);
1114             }
1115         }
1116
1117         $lists_list = array(
1118             'lists' => $lists,
1119             'next_cursor' => $next_cursor,
1120             'next_cursor_str' => strval($next_cursor),
1121             'previous_cursor' => $prev_cursor,
1122             'previous_cursor_str' => strval($prev_cursor)
1123         );
1124
1125         $this->showJsonObjects($lists_list);
1126
1127         $this->endDocument('json');
1128     }
1129
1130     function showTwitterXmlUsers($user)
1131     {
1132         $this->initDocument('xml');
1133         $this->elementStart('users', array('type' => 'array',
1134                                            'xmlns:statusnet' => 'http://status.net/schema/api/1/'));
1135
1136         if (is_array($user)) {
1137             foreach ($user as $u) {
1138                 $twitter_user = $this->twitterUserArray($u);
1139                 $this->showTwitterXmlUser($twitter_user);
1140             }
1141         } else {
1142             while ($user->fetch()) {
1143                 $twitter_user = $this->twitterUserArray($user);
1144                 $this->showTwitterXmlUser($twitter_user);
1145             }
1146         }
1147
1148         $this->elementEnd('users');
1149         $this->endDocument('xml');
1150     }
1151
1152     function showJsonUsers($user)
1153     {
1154         $this->initDocument('json');
1155
1156         $users = array();
1157
1158         if (is_array($user)) {
1159             foreach ($user as $u) {
1160                 $twitter_user = $this->twitterUserArray($u);
1161                 array_push($users, $twitter_user);
1162             }
1163         } else {
1164             while ($user->fetch()) {
1165                 $twitter_user = $this->twitterUserArray($user);
1166                 array_push($users, $twitter_user);
1167             }
1168         }
1169
1170         $this->showJsonObjects($users);
1171
1172         $this->endDocument('json');
1173     }
1174
1175     function showSingleJsonGroup($group)
1176     {
1177         $this->initDocument('json');
1178         $twitter_group = $this->twitterGroupArray($group);
1179         $this->showJsonObjects($twitter_group);
1180         $this->endDocument('json');
1181     }
1182
1183     function showSingleXmlGroup($group)
1184     {
1185         $this->initDocument('xml');
1186         $twitter_group = $this->twitterGroupArray($group);
1187         $this->showTwitterXmlGroup($twitter_group);
1188         $this->endDocument('xml');
1189     }
1190
1191     function showSingleJsonList($list)
1192     {
1193         $this->initDocument('json');
1194         $twitter_list = $this->twitterListArray($list);
1195         $this->showJsonObjects($twitter_list);
1196         $this->endDocument('json');
1197     }
1198
1199     function showSingleXmlList($list)
1200     {
1201         $this->initDocument('xml');
1202         $twitter_list = $this->twitterListArray($list);
1203         $this->showTwitterXmlList($twitter_list);
1204         $this->endDocument('xml');
1205     }
1206
1207     static function dateTwitter($dt)
1208     {
1209         $dateStr = date('d F Y H:i:s', strtotime($dt));
1210         $d = new DateTime($dateStr, new DateTimeZone('UTC'));
1211         $d->setTimezone(new DateTimeZone(common_timezone()));
1212         return $d->format('D M d H:i:s O Y');
1213     }
1214
1215     function initDocument($type='xml')
1216     {
1217         switch ($type) {
1218         case 'xml':
1219             header('Content-Type: application/xml; charset=utf-8');
1220             $this->startXML();
1221             break;
1222         case 'json':
1223             header('Content-Type: application/json; charset=utf-8');
1224
1225             // Check for JSONP callback
1226             if (isset($this->callback)) {
1227                 print $this->callback . '(';
1228             }
1229             break;
1230         case 'rss':
1231             header("Content-Type: application/rss+xml; charset=utf-8");
1232             $this->initTwitterRss();
1233             break;
1234         case 'atom':
1235             header('Content-Type: application/atom+xml; charset=utf-8');
1236             $this->initTwitterAtom();
1237             break;
1238         default:
1239             // TRANS: Client error on an API request with an unsupported data format.
1240             $this->clientError(_('Not a supported data format.'));
1241         }
1242
1243         return;
1244     }
1245
1246     function endDocument($type='xml')
1247     {
1248         switch ($type) {
1249         case 'xml':
1250             $this->endXML();
1251             break;
1252         case 'json':
1253             // Check for JSONP callback
1254             if (isset($this->callback)) {
1255                 print ')';
1256             }
1257             break;
1258         case 'rss':
1259             $this->endTwitterRss();
1260             break;
1261         case 'atom':
1262             $this->endTwitterRss();
1263             break;
1264         default:
1265             // TRANS: Client error on an API request with an unsupported data format.
1266             $this->clientError(_('Not a supported data format.'));
1267         }
1268         return;
1269     }
1270
1271     function initTwitterRss()
1272     {
1273         $this->startXML();
1274         $this->elementStart(
1275             'rss',
1276             array(
1277                 'version'      => '2.0',
1278                 'xmlns:atom'   => 'http://www.w3.org/2005/Atom',
1279                 'xmlns:georss' => 'http://www.georss.org/georss'
1280             )
1281         );
1282         $this->elementStart('channel');
1283         Event::handle('StartApiRss', array($this));
1284     }
1285
1286     function endTwitterRss()
1287     {
1288         $this->elementEnd('channel');
1289         $this->elementEnd('rss');
1290         $this->endXML();
1291     }
1292
1293     function initTwitterAtom()
1294     {
1295         $this->startXML();
1296         // FIXME: don't hardcode the language here!
1297         $this->elementStart('feed', array('xmlns' => 'http://www.w3.org/2005/Atom',
1298                                           'xml:lang' => 'en-US',
1299                                           'xmlns:thr' => 'http://purl.org/syndication/thread/1.0'));
1300     }
1301
1302     function endTwitterAtom()
1303     {
1304         $this->elementEnd('feed');
1305         $this->endXML();
1306     }
1307
1308     function showProfile($profile, $content_type='xml', $notice=null, $includeStatuses=true)
1309     {
1310         $profile_array = $this->twitterUserArray($profile, $includeStatuses);
1311         switch ($content_type) {
1312         case 'xml':
1313             $this->showTwitterXmlUser($profile_array);
1314             break;
1315         case 'json':
1316             $this->showJsonObjects($profile_array);
1317             break;
1318         default:
1319             // TRANS: Client error on an API request with an unsupported data format.
1320             $this->clientError(_('Not a supported data format.'));
1321         }
1322         return;
1323     }
1324
1325     private static function is_decimal($str)
1326     {
1327         return preg_match('/^[0-9]+$/', $str);
1328     }
1329
1330     function getTargetUser($id)
1331     {
1332         if (empty($id)) {
1333             // Twitter supports these other ways of passing the user ID
1334             if (self::is_decimal($this->arg('id'))) {
1335                 return User::getKV($this->arg('id'));
1336             } else if ($this->arg('id')) {
1337                 $nickname = common_canonical_nickname($this->arg('id'));
1338                 return User::getKV('nickname', $nickname);
1339             } else if ($this->arg('user_id')) {
1340                 // This is to ensure that a non-numeric user_id still
1341                 // overrides screen_name even if it doesn't get used
1342                 if (self::is_decimal($this->arg('user_id'))) {
1343                     return User::getKV('id', $this->arg('user_id'));
1344                 }
1345             } else if ($this->arg('screen_name')) {
1346                 $nickname = common_canonical_nickname($this->arg('screen_name'));
1347                 return User::getKV('nickname', $nickname);
1348             } else {
1349                 // Fall back to trying the currently authenticated user
1350                 return $this->scoped->getUser();
1351             }
1352
1353         } else if (self::is_decimal($id)) {
1354             return User::getKV($id);
1355         } else {
1356             $nickname = common_canonical_nickname($id);
1357             return User::getKV('nickname', $nickname);
1358         }
1359     }
1360
1361     function getTargetProfile($id)
1362     {
1363         if (empty($id)) {
1364
1365             // Twitter supports these other ways of passing the user ID
1366             if (self::is_decimal($this->arg('id'))) {
1367                 return Profile::getKV($this->arg('id'));
1368             } else if ($this->arg('id')) {
1369                 // Screen names currently can only uniquely identify a local user.
1370                 $nickname = common_canonical_nickname($this->arg('id'));
1371                 $user = User::getKV('nickname', $nickname);
1372                 return $user ? $user->getProfile() : null;
1373             } else if ($this->arg('user_id')) {
1374                 // This is to ensure that a non-numeric user_id still
1375                 // overrides screen_name even if it doesn't get used
1376                 if (self::is_decimal($this->arg('user_id'))) {
1377                     return Profile::getKV('id', $this->arg('user_id'));
1378                 }
1379             } else if ($this->arg('screen_name')) {
1380                 $nickname = common_canonical_nickname($this->arg('screen_name'));
1381                 $user = User::getKV('nickname', $nickname);
1382                 return $user instanceof User ? $user->getProfile() : null;
1383             } else {
1384                 // Fall back to trying the currently authenticated user
1385                 return $this->scoped;
1386             }
1387         } else if (self::is_decimal($id)) {
1388             return Profile::getKV($id);
1389         } else {
1390             $nickname = common_canonical_nickname($id);
1391             $user = User::getKV('nickname', $nickname);
1392             return $user ? $user->getProfile() : null;
1393         }
1394     }
1395
1396     function getTargetGroup($id)
1397     {
1398         if (empty($id)) {
1399             if (self::is_decimal($this->arg('id'))) {
1400                 return User_group::getKV('id', $this->arg('id'));
1401             } else if ($this->arg('id')) {
1402                 return User_group::getForNickname($this->arg('id'));
1403             } else if ($this->arg('group_id')) {
1404                 // This is to ensure that a non-numeric group_id still
1405                 // overrides group_name even if it doesn't get used
1406                 if (self::is_decimal($this->arg('group_id'))) {
1407                     return User_group::getKV('id', $this->arg('group_id'));
1408                 }
1409             } else if ($this->arg('group_name')) {
1410                 return User_group::getForNickname($this->arg('group_name'));
1411             }
1412
1413         } else if (self::is_decimal($id)) {
1414             return User_group::getKV('id', $id);
1415         } else if ($this->arg('uri')) { // FIXME: move this into empty($id) check?
1416             return User_group::getKV('uri', urldecode($this->arg('uri')));
1417         } else {
1418             return User_group::getForNickname($id);
1419         }
1420     }
1421
1422     function getTargetList($user=null, $id=null)
1423     {
1424         $tagger = $this->getTargetUser($user);
1425         $list = null;
1426
1427         if (empty($id)) {
1428             $id = $this->arg('id');
1429         }
1430
1431         if($id) {
1432             if (is_numeric($id)) {
1433                 $list = Profile_list::getKV('id', $id);
1434
1435                 // only if the list with the id belongs to the tagger
1436                 if(empty($list) || $list->tagger != $tagger->id) {
1437                     $list = null;
1438                 }
1439             }
1440             if (empty($list)) {
1441                 $tag = common_canonical_tag($id);
1442                 $list = Profile_list::getByTaggerAndTag($tagger->id, $tag);
1443             }
1444
1445             if (!empty($list) && $list->private) {
1446                 if ($this->scoped->id == $list->tagger) {
1447                     return $list;
1448                 }
1449             } else {
1450                 return $list;
1451             }
1452         }
1453         return null;
1454     }
1455
1456     /**
1457      * Returns query argument or default value if not found. Certain
1458      * parameters used throughout the API are lightly scrubbed and
1459      * bounds checked.  This overrides Action::arg().
1460      *
1461      * @param string $key requested argument
1462      * @param string $def default value to return if $key is not provided
1463      *
1464      * @return var $var
1465      */
1466     function arg($key, $def=null)
1467     {
1468         // XXX: Do even more input validation/scrubbing?
1469
1470         if (array_key_exists($key, $this->args)) {
1471             switch($key) {
1472             case 'page':
1473                 $page = (int)$this->args['page'];
1474                 return ($page < 1) ? 1 : $page;
1475             case 'count':
1476                 $count = (int)$this->args['count'];
1477                 if ($count < 1) {
1478                     return 20;
1479                 } elseif ($count > 200) {
1480                     return 200;
1481                 } else {
1482                     return $count;
1483                 }
1484             case 'since_id':
1485                 $since_id = (int)$this->args['since_id'];
1486                 return ($since_id < 1) ? 0 : $since_id;
1487             case 'max_id':
1488                 $max_id = (int)$this->args['max_id'];
1489                 return ($max_id < 1) ? 0 : $max_id;
1490             default:
1491                 return parent::arg($key, $def);
1492             }
1493         } else {
1494             return $def;
1495         }
1496     }
1497
1498     /**
1499      * Calculate the complete URI that called up this action.  Used for
1500      * Atom rel="self" links.  Warning: this is funky.
1501      *
1502      * @return string URL    a URL suitable for rel="self" Atom links
1503      */
1504     function getSelfUri()
1505     {
1506         $action = mb_substr(get_class($this), 0, -6); // remove 'Action'
1507
1508         $id = $this->arg('id');
1509         $aargs = array('format' => $this->format);
1510         if (!empty($id)) {
1511             $aargs['id'] = $id;
1512         }
1513
1514         $user = $this->arg('user');
1515         if (!empty($user)) {
1516             $aargs['user'] = $user;
1517         }
1518
1519         $tag = $this->arg('tag');
1520         if (!empty($tag)) {
1521             $aargs['tag'] = $tag;
1522         }
1523
1524         parse_str($_SERVER['QUERY_STRING'], $params);
1525         $pstring = '';
1526         if (!empty($params)) {
1527             unset($params['p']);
1528             $pstring = http_build_query($params);
1529         }
1530
1531         $uri = common_local_url($action, $aargs);
1532
1533         if (!empty($pstring)) {
1534             $uri .= '?' . $pstring;
1535         }
1536
1537         return $uri;
1538     }
1539 }