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 }