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             //FIXME: make everything calling showJsonTimeline use only Notice objects
 799             $ids = array();
 800             foreach ($notice as $n) {
 801                 $ids[] = $n->getID();
 802             }
 803             $notice = Notice::multiGet('id', $ids);
 804         }
 805
 806         while ($notice->fetch()) {
 807             try {
 808                 $twitter_status = $this->twitterStatusArray($notice);
 809                 $this->showTwitterXmlStatus($twitter_status);
 810             } catch (Exception $e) {
 811                 common_log(LOG_ERR, $e->getMessage());
 812                 continue;
 813             }
 814         }
 815
 816         $this->elementEnd('statuses');
 817         $this->endDocument('xml');
 818     }
 819
 820     function showRssTimeline($notice, $title, $link, $subtitle, $suplink = null, $logo = null, $self = null)
 821     {
 822         $this->initDocument('rss');
 823
 824         $this->element('title', null, $title);
 825         $this->element('link', null, $link);
 826
 827         if (!is_null($self)) {
 828             $this->element(
 829                 'atom:link',
 830                 array(
 831                     'type' => 'application/rss+xml',
 832                     'href' => $self,
 833                     'rel'  => 'self'
 834                 )
 835            );
 836         }
 837
 838         if (!is_null($suplink)) {
 839             // For FriendFeed's SUP protocol
 840             $this->element('link', array('xmlns' => 'http://www.w3.org/2005/Atom',
 841                                          'rel' => 'http://api.friendfeed.com/2008/03#sup',
 842                                          'href' => $suplink,
 843                                          'type' => 'application/json'));
 844         }
 845
 846         if (!is_null($logo)) {
 847             $this->elementStart('image');
 848             $this->element('link', null, $link);
 849             $this->element('title', null, $title);
 850             $this->element('url', null, $logo);
 851             $this->elementEnd('image');
 852         }
 853
 854         $this->element('description', null, $subtitle);
 855         $this->element('language', null, 'en-us');
 856         $this->element('ttl', null, '40');
 857
 858         if (is_array($notice)) {
 859             //FIXME: make everything calling showJsonTimeline use only Notice objects
 860             $ids = array();
 861             foreach ($notice as $n) {
 862                 $ids[] = $n->getID();
 863             }
 864             $notice = Notice::multiGet('id', $ids);
 865         }
 866
 867         while ($notice->fetch()) {
 868             try {
 869                 $entry = $this->twitterRssEntryArray($notice);
 870                 $this->showTwitterRssItem($entry);
 871             } catch (Exception $e) {
 872                 common_log(LOG_ERR, $e->getMessage());
 873                 // continue on exceptions
 874             }
 875         }
 876
 877         $this->endTwitterRss();
 878     }
 879
 880     function showAtomTimeline($notice, $title, $id, $link, $subtitle=null, $suplink=null, $selfuri=null, $logo=null)
 881     {
 882         $this->initDocument('atom');
 883
 884         $this->element('title', null, $title);
 885         $this->element('id', null, $id);
 886         $this->element('link', array('href' => $link, 'rel' => 'alternate', 'type' => 'text/html'), null);
 887
 888         if (!is_null($logo)) {
 889             $this->element('logo',null,$logo);
 890         }
 891
 892         if (!is_null($suplink)) {
 893             // For FriendFeed's SUP protocol
 894             $this->element('link', array('rel' => 'http://api.friendfeed.com/2008/03#sup',
 895                                          'href' => $suplink,
 896                                          'type' => 'application/json'));
 897         }
 898
 899         if (!is_null($selfuri)) {
 900             $this->element('link', array('href' => $selfuri,
 901                 'rel' => 'self', 'type' => 'application/atom+xml'), null);
 902         }
 903
 904         $this->element('updated', null, common_date_iso8601('now'));
 905         $this->element('subtitle', null, $subtitle);
 906
 907         if (is_array($notice)) {
 908             //FIXME: make everything calling showJsonTimeline use only Notice objects
 909             $ids = array();
 910             foreach ($notice as $n) {
 911                 $ids[] = $n->getID();
 912             }
 913             $notice = Notice::multiGet('id', $ids);
 914         }
 915
 916         while ($notice->fetch()) {
 917             try {
 918                 $this->raw($notice->asAtomEntry());
 919             } catch (Exception $e) {
 920                 common_log(LOG_ERR, $e->getMessage());
 921                 continue;
 922             }
 923         }
 924
 925         $this->endDocument('atom');
 926     }
 927
 928     function showRssGroups($group, $title, $link, $subtitle)
 929     {
 930         $this->initDocument('rss');
 931
 932         $this->element('title', null, $title);
 933         $this->element('link', null, $link);
 934         $this->element('description', null, $subtitle);
 935         $this->element('language', null, 'en-us');
 936         $this->element('ttl', null, '40');
 937
 938         if (is_array($group)) {
 939             foreach ($group as $g) {
 940                 $twitter_group = $this->twitterRssGroupArray($g);
 941                 $this->showTwitterRssItem($twitter_group);
 942             }
 943         } else {
 944             while ($group->fetch()) {
 945                 $twitter_group = $this->twitterRssGroupArray($group);
 946                 $this->showTwitterRssItem($twitter_group);
 947             }
 948         }
 949
 950         $this->endTwitterRss();
 951     }
 952
 953     function showTwitterAtomEntry($entry)
 954     {
 955         $this->elementStart('entry');
 956         $this->element('title', null, common_xml_safe_str($entry['title']));
 957         $this->element(
 958             'content',
 959             array('type' => 'html'),
 960             common_xml_safe_str($entry['content'])
 961         );
 962         $this->element('id', null, $entry['id']);
 963         $this->element('published', null, $entry['published']);
 964         $this->element('updated', null, $entry['updated']);
 965         $this->element('link', array('type' => 'text/html',
 966                                      'href' => $entry['link'],
 967                                      'rel' => 'alternate'));
 968         $this->element('link', array('type' => $entry['avatar-type'],
 969                                      'href' => $entry['avatar'],
 970                                      'rel' => 'image'));
 971         $this->elementStart('author');
 972
 973         $this->element('name', null, $entry['author-name']);
 974         $this->element('uri', null, $entry['author-uri']);
 975
 976         $this->elementEnd('author');
 977         $this->elementEnd('entry');
 978     }
 979
 980     function showAtomGroups($group, $title, $id, $link, $subtitle=null, $selfuri=null)
 981     {
 982         $this->initDocument('atom');
 983
 984         $this->element('title', null, common_xml_safe_str($title));
 985         $this->element('id', null, $id);
 986         $this->element('link', array('href' => $link, 'rel' => 'alternate', 'type' => 'text/html'), null);
 987
 988         if (!is_null($selfuri)) {
 989             $this->element('link', array('href' => $selfuri,
 990                 'rel' => 'self', 'type' => 'application/atom+xml'), null);
 991         }
 992
 993         $this->element('updated', null, common_date_iso8601('now'));
 994         $this->element('subtitle', null, common_xml_safe_str($subtitle));
 995
 996         if (is_array($group)) {
 997             foreach ($group as $g) {
 998                 $this->raw($g->asAtomEntry());
 999             }
1000         } else {
1001             while ($group->fetch()) {
1002                 $this->raw($group->asAtomEntry());
1003             }
1004         }
1005
1006         $this->endDocument('atom');
1007
1008     }
1009
1010     function showJsonTimeline($notice)
1011     {
1012         $this->initDocument('json');
1013
1014         $statuses = array();
1015
1016         if (is_array($notice)) {
1017             //FIXME: make everything calling showJsonTimeline use only Notice objects
1018             $ids = array();
1019             foreach ($notice as $n) {
1020                 $ids[] = $n->getID();
1021             }
1022             $notice = Notice::multiGet('id', $ids);
1023         }
1024
1025         while ($notice->fetch()) {
1026             try {
1027                 $twitter_status = $this->twitterStatusArray($notice);
1028                 array_push($statuses, $twitter_status);
1029             } catch (Exception $e) {
1030                 common_log(LOG_ERR, $e->getMessage());
1031                 continue;
1032             }
1033         }
1034
1035         $this->showJsonObjects($statuses);
1036
1037         $this->endDocument('json');
1038     }
1039
1040     function showJsonGroups($group)
1041     {
1042         $this->initDocument('json');
1043
1044         $groups = array();
1045
1046         if (is_array($group)) {
1047             foreach ($group as $g) {
1048                 $twitter_group = $this->twitterGroupArray($g);
1049                 array_push($groups, $twitter_group);
1050             }
1051         } else {
1052             while ($group->fetch()) {
1053                 $twitter_group = $this->twitterGroupArray($group);
1054                 array_push($groups, $twitter_group);
1055             }
1056         }
1057
1058         $this->showJsonObjects($groups);
1059
1060         $this->endDocument('json');
1061     }
1062
1063     function showXmlGroups($group)
1064     {
1065
1066         $this->initDocument('xml');
1067         $this->elementStart('groups', array('type' => 'array'));
1068
1069         if (is_array($group)) {
1070             foreach ($group as $g) {
1071                 $twitter_group = $this->twitterGroupArray($g);
1072                 $this->showTwitterXmlGroup($twitter_group);
1073             }
1074         } else {
1075             while ($group->fetch()) {
1076                 $twitter_group = $this->twitterGroupArray($group);
1077                 $this->showTwitterXmlGroup($twitter_group);
1078             }
1079         }
1080
1081         $this->elementEnd('groups');
1082         $this->endDocument('xml');
1083     }
1084
1085     function showXmlLists($list, $next_cursor=0, $prev_cursor=0)
1086     {
1087
1088         $this->initDocument('xml');
1089         $this->elementStart('lists_list');
1090         $this->elementStart('lists', array('type' => 'array'));
1091
1092         if (is_array($list)) {
1093             foreach ($list as $l) {
1094                 $twitter_list = $this->twitterListArray($l);
1095                 $this->showTwitterXmlList($twitter_list);
1096             }
1097         } else {
1098             while ($list->fetch()) {
1099                 $twitter_list = $this->twitterListArray($list);
1100                 $this->showTwitterXmlList($twitter_list);
1101             }
1102         }
1103
1104         $this->elementEnd('lists');
1105
1106         $this->element('next_cursor', null, $next_cursor);
1107         $this->element('previous_cursor', null, $prev_cursor);
1108
1109         $this->elementEnd('lists_list');
1110         $this->endDocument('xml');
1111     }
1112
1113     function showJsonLists($list, $next_cursor=0, $prev_cursor=0)
1114     {
1115         $this->initDocument('json');
1116
1117         $lists = array();
1118
1119         if (is_array($list)) {
1120             foreach ($list as $l) {
1121                 $twitter_list = $this->twitterListArray($l);
1122                 array_push($lists, $twitter_list);
1123             }
1124         } else {
1125             while ($list->fetch()) {
1126                 $twitter_list = $this->twitterListArray($list);
1127                 array_push($lists, $twitter_list);
1128             }
1129         }
1130
1131         $lists_list = array(
1132             'lists' => $lists,
1133             'next_cursor' => $next_cursor,
1134             'next_cursor_str' => strval($next_cursor),
1135             'previous_cursor' => $prev_cursor,
1136             'previous_cursor_str' => strval($prev_cursor)
1137         );
1138
1139         $this->showJsonObjects($lists_list);
1140
1141         $this->endDocument('json');
1142     }
1143
1144     function showTwitterXmlUsers($user)
1145     {
1146         $this->initDocument('xml');
1147         $this->elementStart('users', array('type' => 'array',
1148                                            'xmlns:statusnet' => 'http://status.net/schema/api/1/'));
1149
1150         if (is_array($user)) {
1151             foreach ($user as $u) {
1152                 $twitter_user = $this->twitterUserArray($u);
1153                 $this->showTwitterXmlUser($twitter_user);
1154             }
1155         } else {
1156             while ($user->fetch()) {
1157                 $twitter_user = $this->twitterUserArray($user);
1158                 $this->showTwitterXmlUser($twitter_user);
1159             }
1160         }
1161
1162         $this->elementEnd('users');
1163         $this->endDocument('xml');
1164     }
1165
1166     function showJsonUsers($user)
1167     {
1168         $this->initDocument('json');
1169
1170         $users = array();
1171
1172         if (is_array($user)) {
1173             foreach ($user as $u) {
1174                 $twitter_user = $this->twitterUserArray($u);
1175                 array_push($users, $twitter_user);
1176             }
1177         } else {
1178             while ($user->fetch()) {
1179                 $twitter_user = $this->twitterUserArray($user);
1180                 array_push($users, $twitter_user);
1181             }
1182         }
1183
1184         $this->showJsonObjects($users);
1185
1186         $this->endDocument('json');
1187     }
1188
1189     function showSingleJsonGroup($group)
1190     {
1191         $this->initDocument('json');
1192         $twitter_group = $this->twitterGroupArray($group);
1193         $this->showJsonObjects($twitter_group);
1194         $this->endDocument('json');
1195     }
1196
1197     function showSingleXmlGroup($group)
1198     {
1199         $this->initDocument('xml');
1200         $twitter_group = $this->twitterGroupArray($group);
1201         $this->showTwitterXmlGroup($twitter_group);
1202         $this->endDocument('xml');
1203     }
1204
1205     function showSingleJsonList($list)
1206     {
1207         $this->initDocument('json');
1208         $twitter_list = $this->twitterListArray($list);
1209         $this->showJsonObjects($twitter_list);
1210         $this->endDocument('json');
1211     }
1212
1213     function showSingleXmlList($list)
1214     {
1215         $this->initDocument('xml');
1216         $twitter_list = $this->twitterListArray($list);
1217         $this->showTwitterXmlList($twitter_list);
1218         $this->endDocument('xml');
1219     }
1220
1221     static function dateTwitter($dt)
1222     {
1223         $dateStr = date('d F Y H:i:s', strtotime($dt));
1224         $d = new DateTime($dateStr, new DateTimeZone('UTC'));
1225         $d->setTimezone(new DateTimeZone(common_timezone()));
1226         return $d->format('D M d H:i:s O Y');
1227     }
1228
1229     function initDocument($type='xml')
1230     {
1231         switch ($type) {
1232         case 'xml':
1233             header('Content-Type: application/xml; charset=utf-8');
1234             $this->startXML();
1235             break;
1236         case 'json':
1237             header('Content-Type: application/json; charset=utf-8');
1238
1239             // Check for JSONP callback
1240             if (isset($this->callback)) {
1241                 print $this->callback . '(';
1242             }
1243             break;
1244         case 'rss':
1245             header("Content-Type: application/rss+xml; charset=utf-8");
1246             $this->initTwitterRss();
1247             break;
1248         case 'atom':
1249             header('Content-Type: application/atom+xml; charset=utf-8');
1250             $this->initTwitterAtom();
1251             break;
1252         default:
1253             // TRANS: Client error on an API request with an unsupported data format.
1254             $this->clientError(_('Not a supported data format.'));
1255         }
1256
1257         return;
1258     }
1259
1260     function endDocument($type='xml')
1261     {
1262         switch ($type) {
1263         case 'xml':
1264             $this->endXML();
1265             break;
1266         case 'json':
1267             // Check for JSONP callback
1268             if (isset($this->callback)) {
1269                 print ')';
1270             }
1271             break;
1272         case 'rss':
1273             $this->endTwitterRss();
1274             break;
1275         case 'atom':
1276             $this->endTwitterRss();
1277             break;
1278         default:
1279             // TRANS: Client error on an API request with an unsupported data format.
1280             $this->clientError(_('Not a supported data format.'));
1281         }
1282         return;
1283     }
1284
1285     function initTwitterRss()
1286     {
1287         $this->startXML();
1288         $this->elementStart(
1289             'rss',
1290             array(
1291                 'version'      => '2.0',
1292                 'xmlns:atom'   => 'http://www.w3.org/2005/Atom',
1293                 'xmlns:georss' => 'http://www.georss.org/georss'
1294             )
1295         );
1296         $this->elementStart('channel');
1297         Event::handle('StartApiRss', array($this));
1298     }
1299
1300     function endTwitterRss()
1301     {
1302         $this->elementEnd('channel');
1303         $this->elementEnd('rss');
1304         $this->endXML();
1305     }
1306
1307     function initTwitterAtom()
1308     {
1309         $this->startXML();
1310         // FIXME: don't hardcode the language here!
1311         $this->elementStart('feed', array('xmlns' => 'http://www.w3.org/2005/Atom',
1312                                           'xml:lang' => 'en-US',
1313                                           'xmlns:thr' => 'http://purl.org/syndication/thread/1.0'));
1314     }
1315
1316     function endTwitterAtom()
1317     {
1318         $this->elementEnd('feed');
1319         $this->endXML();
1320     }
1321
1322     function showProfile($profile, $content_type='xml', $notice=null, $includeStatuses=true)
1323     {
1324         $profile_array = $this->twitterUserArray($profile, $includeStatuses);
1325         switch ($content_type) {
1326         case 'xml':
1327             $this->showTwitterXmlUser($profile_array);
1328             break;
1329         case 'json':
1330             $this->showJsonObjects($profile_array);
1331             break;
1332         default:
1333             // TRANS: Client error on an API request with an unsupported data format.
1334             $this->clientError(_('Not a supported data format.'));
1335         }
1336         return;
1337     }
1338
1339     private static function is_decimal($str)
1340     {
1341         return preg_match('/^[0-9]+$/', $str);
1342     }
1343
1344     function getTargetUser($id)
1345     {
1346         if (empty($id)) {
1347             // Twitter supports these other ways of passing the user ID
1348             if (self::is_decimal($this->arg('id'))) {
1349                 return User::getKV($this->arg('id'));
1350             } else if ($this->arg('id')) {
1351                 $nickname = common_canonical_nickname($this->arg('id'));
1352                 return User::getKV('nickname', $nickname);
1353             } else if ($this->arg('user_id')) {
1354                 // This is to ensure that a non-numeric user_id still
1355                 // overrides screen_name even if it doesn't get used
1356                 if (self::is_decimal($this->arg('user_id'))) {
1357                     return User::getKV('id', $this->arg('user_id'));
1358                 }
1359             } else if ($this->arg('screen_name')) {
1360                 $nickname = common_canonical_nickname($this->arg('screen_name'));
1361                 return User::getKV('nickname', $nickname);
1362             } else {
1363                 // Fall back to trying the currently authenticated user
1364                 return $this->scoped->getUser();
1365             }
1366
1367         } else if (self::is_decimal($id)) {
1368             return User::getKV($id);
1369         } else {
1370             $nickname = common_canonical_nickname($id);
1371             return User::getKV('nickname', $nickname);
1372         }
1373     }
1374
1375     function getTargetProfile($id)
1376     {
1377         if (empty($id)) {
1378
1379             // Twitter supports these other ways of passing the user ID
1380             if (self::is_decimal($this->arg('id'))) {
1381                 return Profile::getKV($this->arg('id'));
1382             } else if ($this->arg('id')) {
1383                 // Screen names currently can only uniquely identify a local user.
1384                 $nickname = common_canonical_nickname($this->arg('id'));
1385                 $user = User::getKV('nickname', $nickname);
1386                 return $user ? $user->getProfile() : null;
1387             } else if ($this->arg('user_id')) {
1388                 // This is to ensure that a non-numeric user_id still
1389                 // overrides screen_name even if it doesn't get used
1390                 if (self::is_decimal($this->arg('user_id'))) {
1391                     return Profile::getKV('id', $this->arg('user_id'));
1392                 }
1393             } else if ($this->arg('screen_name')) {
1394                 $nickname = common_canonical_nickname($this->arg('screen_name'));
1395                 $user = User::getKV('nickname', $nickname);
1396                 return $user instanceof User ? $user->getProfile() : null;
1397             } else {
1398                 // Fall back to trying the currently authenticated user
1399                 return $this->scoped;
1400             }
1401         } else if (self::is_decimal($id)) {
1402             return Profile::getKV($id);
1403         } else {
1404             $nickname = common_canonical_nickname($id);
1405             $user = User::getKV('nickname', $nickname);
1406             return $user ? $user->getProfile() : null;
1407         }
1408     }
1409
1410     function getTargetGroup($id)
1411     {
1412         if (empty($id)) {
1413             if (self::is_decimal($this->arg('id'))) {
1414                 return User_group::getKV('id', $this->arg('id'));
1415             } else if ($this->arg('id')) {
1416                 return User_group::getForNickname($this->arg('id'));
1417             } else if ($this->arg('group_id')) {
1418                 // This is to ensure that a non-numeric group_id still
1419                 // overrides group_name even if it doesn't get used
1420                 if (self::is_decimal($this->arg('group_id'))) {
1421                     return User_group::getKV('id', $this->arg('group_id'));
1422                 }
1423             } else if ($this->arg('group_name')) {
1424                 return User_group::getForNickname($this->arg('group_name'));
1425             }
1426
1427         } else if (self::is_decimal($id)) {
1428             return User_group::getKV('id', $id);
1429         } else if ($this->arg('uri')) { // FIXME: move this into empty($id) check?
1430             return User_group::getKV('uri', urldecode($this->arg('uri')));
1431         } else {
1432             return User_group::getForNickname($id);
1433         }
1434     }
1435
1436     function getTargetList($user=null, $id=null)
1437     {
1438         $tagger = $this->getTargetUser($user);
1439         $list = null;
1440
1441         if (empty($id)) {
1442             $id = $this->arg('id');
1443         }
1444
1445         if($id) {
1446             if (is_numeric($id)) {
1447                 $list = Profile_list::getKV('id', $id);
1448
1449                 // only if the list with the id belongs to the tagger
1450                 if(empty($list) || $list->tagger != $tagger->id) {
1451                     $list = null;
1452                 }
1453             }
1454             if (empty($list)) {
1455                 $tag = common_canonical_tag($id);
1456                 $list = Profile_list::getByTaggerAndTag($tagger->id, $tag);
1457             }
1458
1459             if (!empty($list) && $list->private) {
1460                 if ($this->scoped->id == $list->tagger) {
1461                     return $list;
1462                 }
1463             } else {
1464                 return $list;
1465             }
1466         }
1467         return null;
1468     }
1469
1470     /**
1471      * Returns query argument or default value if not found. Certain
1472      * parameters used throughout the API are lightly scrubbed and
1473      * bounds checked.  This overrides Action::arg().
1474      *
1475      * @param string $key requested argument
1476      * @param string $def default value to return if $key is not provided
1477      *
1478      * @return var $var
1479      */
1480     function arg($key, $def=null)
1481     {
1482         // XXX: Do even more input validation/scrubbing?
1483
1484         if (array_key_exists($key, $this->args)) {
1485             switch($key) {
1486             case 'page':
1487                 $page = (int)$this->args['page'];
1488                 return ($page < 1) ? 1 : $page;
1489             case 'count':
1490                 $count = (int)$this->args['count'];
1491                 if ($count < 1) {
1492                     return 20;
1493                 } elseif ($count > 200) {
1494                     return 200;
1495                 } else {
1496                     return $count;
1497                 }
1498             case 'since_id':
1499                 $since_id = (int)$this->args['since_id'];
1500                 return ($since_id < 1) ? 0 : $since_id;
1501             case 'max_id':
1502                 $max_id = (int)$this->args['max_id'];
1503                 return ($max_id < 1) ? 0 : $max_id;
1504             default:
1505                 return parent::arg($key, $def);
1506             }
1507         } else {
1508             return $def;
1509         }
1510     }
1511
1512     /**
1513      * Calculate the complete URI that called up this action.  Used for
1514      * Atom rel="self" links.  Warning: this is funky.
1515      *
1516      * @return string URL    a URL suitable for rel="self" Atom links
1517      */
1518     function getSelfUri()
1519     {
1520         $action = mb_substr(get_class($this), 0, -6); // remove 'Action'
1521
1522         $id = $this->arg('id');
1523         $aargs = array('format' => $this->format);
1524         if (!empty($id)) {
1525             $aargs['id'] = $id;
1526         }
1527
1528         $user = $this->arg('user');
1529         if (!empty($user)) {
1530             $aargs['user'] = $user;
1531         }
1532
1533         $tag = $this->arg('tag');
1534         if (!empty($tag)) {
1535             $aargs['tag'] = $tag;
1536         }
1537
1538         parse_str($_SERVER['QUERY_STRING'], $params);
1539         $pstring = '';
1540         if (!empty($params)) {
1541             unset($params['p']);
1542             $pstring = http_build_query($params);
1543         }
1544
1545         $uri = common_local_url($action, $aargs);
1546
1547         if (!empty($pstring)) {
1548             $uri .= '?' . $pstring;
1549         }
1550
1551         return $uri;
1552     }
1553 }