lib/activity.php

   1 <?php
   2 /**
   3  * StatusNet, the distributed open-source microblogging tool
   4  *
   5  * An activity
   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  Feed
  23  * @package   StatusNet
  24  * @author    Evan Prodromou <evan@status.net>
  25  * @author    Zach Copley <zach@status.net>
  26  * @copyright 2010 StatusNet, Inc.
  27  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html AGPLv3
  28  * @link      http://status.net/
  29  */
  30
  31 if (!defined('STATUSNET')) {
  32     exit(1);
  33 }
  34
  35 class PoCoURL
  36 {
  37     const URLS      = 'urls';
  38     const TYPE      = 'type';
  39     const VALUE     = 'value';
  40     const PRIMARY   = 'primary';
  41
  42     public $type;
  43     public $value;
  44     public $primary;
  45
  46     function __construct($type, $value, $primary = false)
  47     {
  48         $this->type    = $type;
  49         $this->value   = $value;
  50         $this->primary = $primary;
  51     }
  52
  53     function asString()
  54     {
  55         $xs = new XMLStringer(true);
  56         $xs->elementStart('poco:urls');
  57         $xs->element('poco:type', null, $this->type);
  58         $xs->element('poco:value', null, $this->value);
  59         if (!empty($this->primary)) {
  60             $xs->element('poco:primary', null, 'true');
  61         }
  62         $xs->elementEnd('poco:urls');
  63         return $xs->getString();
  64     }
  65 }
  66
  67 class PoCoAddress
  68 {
  69     const ADDRESS   = 'address';
  70     const FORMATTED = 'formatted';
  71
  72     public $formatted;
  73
  74     // @todo Other address fields
  75
  76     function asString()
  77     {
  78         if (!empty($this->formatted)) {
  79             $xs = new XMLStringer(true);
  80             $xs->elementStart('poco:address');
  81             $xs->element('poco:formatted', null, common_xml_safe_str($this->formatted));
  82             $xs->elementEnd('poco:address');
  83             return $xs->getString();
  84         }
  85
  86         return null;
  87     }
  88 }
  89
  90 class PoCo
  91 {
  92     const NS = 'http://portablecontacts.net/spec/1.0';
  93
  94     const USERNAME     = 'preferredUsername';
  95     const DISPLAYNAME  = 'displayName';
  96     const NOTE         = 'note';
  97
  98     public $preferredUsername;
  99     public $displayName;
 100     public $note;
 101     public $address;
 102     public $urls = array();
 103
 104     function __construct($element = null)
 105     {
 106         if (empty($element)) {
 107             return;
 108         }
 109
 110         $this->preferredUsername = ActivityUtils::childContent(
 111             $element,
 112             self::USERNAME,
 113             self::NS
 114         );
 115
 116         $this->displayName = ActivityUtils::childContent(
 117             $element,
 118             self::DISPLAYNAME,
 119             self::NS
 120         );
 121
 122         $this->note = ActivityUtils::childContent(
 123             $element,
 124             self::NOTE,
 125             self::NS
 126         );
 127
 128         $this->address = $this->_getAddress($element);
 129         $this->urls = $this->_getURLs($element);
 130     }
 131
 132     private function _getURLs($element)
 133     {
 134         $urlEls = $element->getElementsByTagnameNS(self::NS, PoCoURL::URLS);
 135         $urls = array();
 136
 137         foreach ($urlEls as $urlEl) {
 138
 139             $type = ActivityUtils::childContent(
 140                 $urlEl,
 141                 PoCoURL::TYPE,
 142                 PoCo::NS
 143             );
 144
 145             $value = ActivityUtils::childContent(
 146                 $urlEl,
 147                 PoCoURL::VALUE,
 148                 PoCo::NS
 149             );
 150
 151             $primary = ActivityUtils::childContent(
 152                 $urlEl,
 153                 PoCoURL::PRIMARY,
 154                 PoCo::NS
 155             );
 156
 157             $isPrimary = false;
 158
 159             if (isset($primary) && $primary == 'true') {
 160                 $isPrimary = true;
 161             }
 162
 163             // @todo check to make sure a primary hasn't already been added
 164
 165             array_push($urls, new PoCoURL($type, $value, $isPrimary));
 166         }
 167         return $urls;
 168     }
 169
 170     private function _getAddress($element)
 171     {
 172         $addressEl = ActivityUtils::child(
 173             $element,
 174             PoCoAddress::ADDRESS,
 175             PoCo::NS
 176         );
 177
 178         if (!empty($addressEl)) {
 179             $formatted = ActivityUtils::childContent(
 180                 $addressEl,
 181                 PoCoAddress::FORMATTED,
 182                 self::NS
 183             );
 184
 185             if (!empty($formatted)) {
 186                 $address = new PoCoAddress();
 187                 $address->formatted = $formatted;
 188                 return $address;
 189             }
 190         }
 191
 192         return null;
 193     }
 194
 195     function fromProfile($profile)
 196     {
 197         if (empty($profile)) {
 198             return null;
 199         }
 200
 201         $poco = new PoCo();
 202
 203         $poco->preferredUsername = $profile->nickname;
 204         $poco->displayName       = $profile->getBestName();
 205
 206         $poco->note = $profile->bio;
 207
 208         $paddy = new PoCoAddress();
 209         $paddy->formatted = $profile->location;
 210         $poco->address = $paddy;
 211
 212         if (!empty($profile->homepage)) {
 213             array_push(
 214                 $poco->urls,
 215                 new PoCoURL(
 216                     'homepage',
 217                     $profile->homepage,
 218                     true
 219                 )
 220             );
 221         }
 222
 223         return $poco;
 224     }
 225
 226     function fromGroup($group)
 227     {
 228         if (empty($group)) {
 229             return null;
 230         }
 231
 232         $poco = new PoCo();
 233
 234         $poco->preferredUsername = $group->nickname;
 235         $poco->displayName       = $group->getBestName();
 236
 237         $poco->note = $group->description;
 238
 239         $paddy = new PoCoAddress();
 240         $paddy->formatted = $group->location;
 241         $poco->address = $paddy;
 242
 243         if (!empty($group->homepage)) {
 244             array_push(
 245                 $poco->urls,
 246                 new PoCoURL(
 247                     'homepage',
 248                     $group->homepage,
 249                     true
 250                 )
 251             );
 252         }
 253
 254         return $poco;
 255     }
 256
 257     function getPrimaryURL()
 258     {
 259         foreach ($this->urls as $url) {
 260             if ($url->primary) {
 261                 return $url;
 262             }
 263         }
 264     }
 265
 266     function asString()
 267     {
 268         $xs = new XMLStringer(true);
 269         $xs->element(
 270             'poco:preferredUsername',
 271             null,
 272             $this->preferredUsername
 273         );
 274
 275         $xs->element(
 276             'poco:displayName',
 277             null,
 278             $this->displayName
 279         );
 280
 281         if (!empty($this->note)) {
 282             $xs->element('poco:note', null, common_xml_safe_str($this->note));
 283         }
 284
 285         if (!empty($this->address)) {
 286             $xs->raw($this->address->asString());
 287         }
 288
 289         foreach ($this->urls as $url) {
 290             $xs->raw($url->asString());
 291         }
 292
 293         return $xs->getString();
 294     }
 295 }
 296
 297 /**
 298  * Utilities for turning DOMish things into Activityish things
 299  *
 300  * Some common functions that I didn't have the bandwidth to try to factor
 301  * into some kind of reasonable superclass, so just dumped here. Might
 302  * be useful to have an ActivityObject parent class or something.
 303  *
 304  * @category  OStatus
 305  * @package   StatusNet
 306  * @author    Evan Prodromou <evan@status.net>
 307  * @copyright 2010 StatusNet, Inc.
 308  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html AGPLv3
 309  * @link      http://status.net/
 310  */
 311
 312 class ActivityUtils
 313 {
 314     const ATOM = 'http://www.w3.org/2005/Atom';
 315
 316     const LINK = 'link';
 317     const REL  = 'rel';
 318     const TYPE = 'type';
 319     const HREF = 'href';
 320
 321     const CONTENT = 'content';
 322     const SRC     = 'src';
 323
 324     /**
 325      * Get the permalink for an Activity object
 326      *
 327      * @param DOMElement $element A DOM element
 328      *
 329      * @return string related link, if any
 330      */
 331
 332     static function getPermalink($element)
 333     {
 334         return self::getLink($element, 'alternate', 'text/html');
 335     }
 336
 337     /**
 338      * Get the permalink for an Activity object
 339      *
 340      * @param DOMElement $element A DOM element
 341      *
 342      * @return string related link, if any
 343      */
 344
 345     static function getLink(DOMNode $element, $rel, $type=null)
 346     {
 347         $els = $element->childNodes;
 348
 349         foreach ($els as $link) {
 350             if ($link->localName == self::LINK && $link->namespaceURI == self::ATOM) {
 351
 352                 $linkRel = $link->getAttribute(self::REL);
 353                 $linkType = $link->getAttribute(self::TYPE);
 354
 355                 if ($linkRel == $rel &&
 356                     (is_null($type) || $linkType == $type)) {
 357                     return $link->getAttribute(self::HREF);
 358                 }
 359             }
 360         }
 361
 362         return null;
 363     }
 364
 365     static function getLinks(DOMNode $element, $rel, $type=null)
 366     {
 367         $els = $element->childNodes;
 368         $out = array();
 369
 370         foreach ($els as $link) {
 371             if ($link->localName == self::LINK && $link->namespaceURI == self::ATOM) {
 372
 373                 $linkRel = $link->getAttribute(self::REL);
 374                 $linkType = $link->getAttribute(self::TYPE);
 375
 376                 if ($linkRel == $rel &&
 377                     (is_null($type) || $linkType == $type)) {
 378                     $out[] = $link;
 379                 }
 380             }
 381         }
 382
 383         return $out;
 384     }
 385
 386     /**
 387      * Gets the first child element with the given tag
 388      *
 389      * @param DOMElement $element   element to pick at
 390      * @param string     $tag       tag to look for
 391      * @param string     $namespace Namespace to look under
 392      *
 393      * @return DOMElement found element or null
 394      */
 395
 396     static function child(DOMNode $element, $tag, $namespace=self::ATOM)
 397     {
 398         $els = $element->childNodes;
 399         if (empty($els) || $els->length == 0) {
 400             return null;
 401         } else {
 402             for ($i = 0; $i < $els->length; $i++) {
 403                 $el = $els->item($i);
 404                 if ($el->localName == $tag && $el->namespaceURI == $namespace) {
 405                     return $el;
 406                 }
 407             }
 408         }
 409     }
 410
 411     /**
 412      * Grab the text content of a DOM element child of the current element
 413      *
 414      * @param DOMElement $element   Element whose children we examine
 415      * @param string     $tag       Tag to look up
 416      * @param string     $namespace Namespace to use, defaults to Atom
 417      *
 418      * @return string content of the child
 419      */
 420
 421     static function childContent(DOMNode $element, $tag, $namespace=self::ATOM)
 422     {
 423         $el = self::child($element, $tag, $namespace);
 424
 425         if (empty($el)) {
 426             return null;
 427         } else {
 428             return $el->textContent;
 429         }
 430     }
 431
 432     /**
 433      * Get the content of an atom:entry-like object
 434      *
 435      * @param DOMElement $element The element to examine.
 436      *
 437      * @return string unencoded HTML content of the element, like "This -&lt; is <b>HTML</b>."
 438      *
 439      * @todo handle remote content
 440      * @todo handle embedded XML mime types
 441      * @todo handle base64-encoded non-XML and non-text mime types
 442      */
 443
 444     static function getContent($element)
 445     {
 446         $contentEl = ActivityUtils::child($element, self::CONTENT);
 447
 448         if (!empty($contentEl)) {
 449
 450             $src  = $contentEl->getAttribute(self::SRC);
 451
 452             if (!empty($src)) {
 453                 throw new ClientException(_("Can't handle remote content yet."));
 454             }
 455
 456             $type = $contentEl->getAttribute(self::TYPE);
 457
 458             // slavishly following http://atompub.org/rfc4287.html#rfc.section.4.1.3.3
 459
 460             if (empty($type) || $type == 'text') {
 461                 // Plain text source -- let's turn it into HTML!
 462                 return htmlspecialchars($contentEl->textContent);
 463             } else if ($type == 'html') {
 464                 // The XML text decoding gives us an HTML string ready to roll.
 465                 return $contentEl->textContent, ENT_QUOTES;
 466             } else if ($type == 'xhtml') {
 467                 // Embedded XHTML; we have to pull it out of the document tree,
 468                 // then serialize it back out to an HTML fragment string.
 469                 $divEl = ActivityUtils::child($contentEl, 'div', 'http://www.w3.org/1999/xhtml');
 470                 if (empty($divEl)) {
 471                     return null;
 472                 }
 473                 $doc = $divEl->ownerDocument;
 474                 $text = '';
 475                 $children = $divEl->childNodes;
 476
 477                 for ($i = 0; $i < $children->length; $i++) {
 478                     $child = $children->item($i);
 479                     $text .= $doc->saveXML($child);
 480                 }
 481                 return trim($text);
 482             } else if (in_array($type, array('text/xml', 'application/xml')) ||
 483                        preg_match('#(+|/)xml$#', $type)) {
 484                 throw new ClientException(_("Can't handle embedded XML content yet."));
 485             } else if (strncasecmp($type, 'text/', 5)) {
 486                 return $contentEl->textContent;
 487             } else {
 488                 throw new ClientException(_("Can't handle embedded Base64 content yet."));
 489             }
 490         }
 491     }
 492 }
 493
 494 // XXX: Arg! This wouldn't be necessary if we used Avatars conistently
 495 class AvatarLink
 496 {
 497     public $url;
 498     public $type;
 499     public $size;
 500     public $width;
 501     public $height;
 502
 503     function __construct($element=null)
 504     {
 505         if ($element) {
 506             // @fixme use correct namespaces
 507             $this->url = $element->getAttribute('href');
 508             $this->type = $element->getAttribute('type');
 509             $width = $element->getAttribute('media:width');
 510             if ($width != null) {
 511                 $this->width = intval($width);
 512             }
 513             $height = $element->getAttribute('media:height');
 514             if ($height != null) {
 515                 $this->height = intval($height);
 516             }
 517         }
 518     }
 519
 520     static function fromAvatar($avatar)
 521     {
 522         if (empty($avatar)) {
 523             return null;
 524         }
 525         $alink = new AvatarLink();
 526         $alink->type   = $avatar->mediatype;
 527         $alink->height = $avatar->height;
 528         $alink->width  = $avatar->width;
 529         $alink->url    = $avatar->displayUrl();
 530         return $alink;
 531     }
 532
 533     static function fromFilename($filename, $size)
 534     {
 535         $alink = new AvatarLink();
 536         $alink->url    = $filename;
 537         $alink->height = $size;
 538         if (!empty($filename)) {
 539             $alink->width  = $size;
 540             $alink->type   = self::mediatype($filename);
 541         } else {
 542             $alink->url    = User_group::defaultLogo($size);
 543             $alink->type   = 'image/png';
 544         }
 545         return $alink;
 546     }
 547
 548     // yuck!
 549     static function mediatype($filename) {
 550         $ext = strtolower(end(explode('.', $filename)));
 551         if ($ext == 'jpeg') {
 552             $ext = 'jpg';
 553         }
 554         // hope we don't support any others
 555         $types = array('png', 'gif', 'jpg', 'jpeg');
 556         if (in_array($ext, $types)) {
 557             return 'image/' . $ext;
 558         }
 559         return null;
 560     }
 561 }
 562
 563 /**
 564  * A noun-ish thing in the activity universe
 565  *
 566  * The activity streams spec talks about activity objects, while also having
 567  * a tag activity:object, which is in fact an activity object. Aaaaaah!
 568  *
 569  * This is just a thing in the activity universe. Can be the subject, object,
 570  * or indirect object (target!) of an activity verb. Rotten name, and I'm
 571  * propagating it. *sigh*
 572  *
 573  * @category  OStatus
 574  * @package   StatusNet
 575  * @author    Evan Prodromou <evan@status.net>
 576  * @copyright 2010 StatusNet, Inc.
 577  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html AGPLv3
 578  * @link      http://status.net/
 579  */
 580
 581 class ActivityObject
 582 {
 583     const ARTICLE   = 'http://activitystrea.ms/schema/1.0/article';
 584     const BLOGENTRY = 'http://activitystrea.ms/schema/1.0/blog-entry';
 585     const NOTE      = 'http://activitystrea.ms/schema/1.0/note';
 586     const STATUS    = 'http://activitystrea.ms/schema/1.0/status';
 587     const FILE      = 'http://activitystrea.ms/schema/1.0/file';
 588     const PHOTO     = 'http://activitystrea.ms/schema/1.0/photo';
 589     const ALBUM     = 'http://activitystrea.ms/schema/1.0/photo-album';
 590     const PLAYLIST  = 'http://activitystrea.ms/schema/1.0/playlist';
 591     const VIDEO     = 'http://activitystrea.ms/schema/1.0/video';
 592     const AUDIO     = 'http://activitystrea.ms/schema/1.0/audio';
 593     const BOOKMARK  = 'http://activitystrea.ms/schema/1.0/bookmark';
 594     const PERSON    = 'http://activitystrea.ms/schema/1.0/person';
 595     const GROUP     = 'http://activitystrea.ms/schema/1.0/group';
 596     const PLACE     = 'http://activitystrea.ms/schema/1.0/place';
 597     const COMMENT   = 'http://activitystrea.ms/schema/1.0/comment';
 598     // ^^^^^^^^^^ tea!
 599
 600     // Atom elements we snarf
 601
 602     const TITLE   = 'title';
 603     const SUMMARY = 'summary';
 604     const ID      = 'id';
 605     const SOURCE  = 'source';
 606
 607     const NAME  = 'name';
 608     const URI   = 'uri';
 609     const EMAIL = 'email';
 610
 611     public $element;
 612     public $type;
 613     public $id;
 614     public $title;
 615     public $summary;
 616     public $content;
 617     public $link;
 618     public $source;
 619     public $avatarLinks = array();
 620     public $geopoint;
 621     public $poco;
 622     public $displayName;
 623
 624     /**
 625      * Constructor
 626      *
 627      * This probably needs to be refactored
 628      * to generate a local class (ActivityPerson, ActivityFile, ...)
 629      * based on the object type.
 630      *
 631      * @param DOMElement $element DOM thing to turn into an Activity thing
 632      */
 633
 634     function __construct($element = null)
 635     {
 636         if (empty($element)) {
 637             return;
 638         }
 639
 640         $this->element = $element;
 641
 642         $this->geopoint = $this->_childContent(
 643             $element,
 644             ActivityContext::POINT,
 645             ActivityContext::GEORSS
 646         );
 647
 648         if ($element->tagName == 'author') {
 649
 650             $this->type  = self::PERSON; // XXX: is this fair?
 651             $this->title = $this->_childContent($element, self::NAME);
 652             $this->id    = $this->_childContent($element, self::URI);
 653
 654             if (empty($this->id)) {
 655                 $email = $this->_childContent($element, self::EMAIL);
 656                 if (!empty($email)) {
 657                     // XXX: acct: ?
 658                     $this->id = 'mailto:'.$email;
 659                 }
 660             }
 661
 662         } else {
 663
 664             $this->type = $this->_childContent($element, Activity::OBJECTTYPE,
 665                                                Activity::SPEC);
 666
 667             if (empty($this->type)) {
 668                 $this->type = ActivityObject::NOTE;
 669             }
 670
 671             $this->id      = $this->_childContent($element, self::ID);
 672             $this->title   = $this->_childContent($element, self::TITLE);
 673             $this->summary = $this->_childContent($element, self::SUMMARY);
 674
 675             $this->source  = $this->_getSource($element);
 676
 677             $this->content = ActivityUtils::getContent($element);
 678
 679             $this->link = ActivityUtils::getPermalink($element);
 680
 681         }
 682
 683         // Some per-type attributes...
 684         if ($this->type == self::PERSON || $this->type == self::GROUP) {
 685             $this->displayName = $this->title;
 686
 687             $photos = ActivityUtils::getLinks($element, 'photo');
 688             if (count($photos)) {
 689                 foreach ($photos as $link) {
 690                     $this->avatarLinks[] = new AvatarLink($link);
 691                 }
 692             } else {
 693                 $avatars = ActivityUtils::getLinks($element, 'avatar');
 694                 foreach ($avatars as $link) {
 695                     $this->avatarLinks[] = new AvatarLink($link);
 696                 }
 697             }
 698
 699             $this->poco = new PoCo($element);
 700         }
 701     }
 702
 703     private function _childContent($element, $tag, $namespace=ActivityUtils::ATOM)
 704     {
 705         return ActivityUtils::childContent($element, $tag, $namespace);
 706     }
 707
 708     // Try to get a unique id for the source feed
 709
 710     private function _getSource($element)
 711     {
 712         $sourceEl = ActivityUtils::child($element, 'source');
 713
 714         if (empty($sourceEl)) {
 715             return null;
 716         } else {
 717             $href = ActivityUtils::getLink($sourceEl, 'self');
 718             if (!empty($href)) {
 719                 return $href;
 720             } else {
 721                 return ActivityUtils::childContent($sourceEl, 'id');
 722             }
 723         }
 724     }
 725
 726     static function fromNotice($notice)
 727     {
 728         $object = new ActivityObject();
 729
 730         $object->type    = ActivityObject::NOTE;
 731
 732         $object->id      = $notice->uri;
 733         $object->title   = $notice->content;
 734         $object->content = $notice->rendered;
 735         $object->link    = $notice->bestUrl();
 736
 737         return $object;
 738     }
 739
 740     static function fromProfile($profile)
 741     {
 742         $object = new ActivityObject();
 743
 744         $object->type   = ActivityObject::PERSON;
 745         $object->id     = $profile->getUri();
 746         $object->title  = $profile->getBestName();
 747         $object->link   = $profile->profileurl;
 748
 749         $orig = $profile->getOriginalAvatar();
 750
 751         if (!empty($orig)) {
 752             $object->avatarLinks[] = AvatarLink::fromAvatar($orig);
 753         }
 754
 755         $sizes = array(
 756             AVATAR_PROFILE_SIZE,
 757             AVATAR_STREAM_SIZE,
 758             AVATAR_MINI_SIZE
 759         );
 760
 761         foreach ($sizes as $size) {
 762
 763             $alink  = null;
 764             $avatar = $profile->getAvatar($size);
 765
 766             if (!empty($avatar)) {
 767                 $alink = AvatarLink::fromAvatar($avatar);
 768             } else {
 769                 $alink = new AvatarLink();
 770                 $alink->type   = 'image/png';
 771                 $alink->height = $size;
 772                 $alink->width  = $size;
 773                 $alink->url    = Avatar::defaultImage($size);
 774             }
 775
 776             $object->avatarLinks[] = $alink;
 777         }
 778
 779         if (isset($profile->lat) && isset($profile->lon)) {
 780             $object->geopoint = (float)$profile->lat
 781                 . ' ' . (float)$profile->lon;
 782         }
 783
 784         $object->poco = PoCo::fromProfile($profile);
 785
 786         return $object;
 787     }
 788
 789     static function fromGroup($group)
 790     {
 791         $object = new ActivityObject();
 792
 793         $object->type   = ActivityObject::GROUP;
 794         $object->id     = $group->getUri();
 795         $object->title  = $group->getBestName();
 796         $object->link   = $group->getUri();
 797
 798         $object->avatarLinks[] = AvatarLink::fromFilename(
 799             $group->homepage_logo,
 800             AVATAR_PROFILE_SIZE
 801         );
 802
 803         $object->avatarLinks[] = AvatarLink::fromFilename(
 804             $group->stream_logo,
 805             AVATAR_STREAM_SIZE
 806         );
 807
 808         $object->avatarLinks[] = AvatarLink::fromFilename(
 809             $group->mini_logo,
 810             AVATAR_MINI_SIZE
 811         );
 812
 813         $object->poco = PoCo::fromGroup($group);
 814
 815         return $object;
 816     }
 817
 818     function asString($tag='activity:object')
 819     {
 820         $xs = new XMLStringer(true);
 821
 822         $xs->elementStart($tag);
 823
 824         $xs->element('activity:object-type', null, $this->type);
 825
 826         $xs->element(self::ID, null, $this->id);
 827
 828         if (!empty($this->title)) {
 829             $xs->element(
 830                 self::TITLE,
 831                 null,
 832                 common_xml_safe_str($this->title)
 833             );
 834         }
 835
 836         if (!empty($this->summary)) {
 837             $xs->element(
 838                 self::SUMMARY,
 839                 null,
 840                 common_xml_safe_str($this->summary)
 841             );
 842         }
 843
 844         if (!empty($this->content)) {
 845             // XXX: assuming HTML content here
 846             $xs->element(
 847                 ActivityUtils::CONTENT,
 848                 array('type' => 'html'),
 849                 common_xml_safe_str($this->content)
 850             );
 851         }
 852
 853         if (!empty($this->link)) {
 854             $xs->element(
 855                 'link',
 856                 array(
 857                     'rel' => 'alternate',
 858                     'type' => 'text/html',
 859                     'href' => $this->link
 860                 ),
 861                 null
 862             );
 863         }
 864
 865         if ($this->type == ActivityObject::PERSON
 866             || $this->type == ActivityObject::GROUP) {
 867
 868             foreach ($this->avatarLinks as $avatar) {
 869                 $xs->element(
 870                     'link', array(
 871                         'rel'  => 'avatar',
 872                         'type'         => $avatar->type,
 873                         'media:width'  => $avatar->width,
 874                         'media:height' => $avatar->height,
 875                         'href' => $avatar->url
 876                     ),
 877                     null
 878                 );
 879             }
 880         }
 881
 882         if (!empty($this->geopoint)) {
 883             $xs->element(
 884                 'georss:point',
 885                 null,
 886                 $this->geopoint
 887             );
 888         }
 889
 890         if (!empty($this->poco)) {
 891             $xs->raw($this->poco->asString());
 892         }
 893
 894         $xs->elementEnd($tag);
 895
 896         return $xs->getString();
 897     }
 898 }
 899
 900 /**
 901  * Utility class to hold a bunch of constant defining default verb types
 902  *
 903  * @category  OStatus
 904  * @package   StatusNet
 905  * @author    Evan Prodromou <evan@status.net>
 906  * @copyright 2010 StatusNet, Inc.
 907  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html AGPLv3
 908  * @link      http://status.net/
 909  */
 910
 911 class ActivityVerb
 912 {
 913     const POST     = 'http://activitystrea.ms/schema/1.0/post';
 914     const SHARE    = 'http://activitystrea.ms/schema/1.0/share';
 915     const SAVE     = 'http://activitystrea.ms/schema/1.0/save';
 916     const FAVORITE = 'http://activitystrea.ms/schema/1.0/favorite';
 917     const PLAY     = 'http://activitystrea.ms/schema/1.0/play';
 918     const FOLLOW   = 'http://activitystrea.ms/schema/1.0/follow';
 919     const FRIEND   = 'http://activitystrea.ms/schema/1.0/make-friend';
 920     const JOIN     = 'http://activitystrea.ms/schema/1.0/join';
 921     const TAG      = 'http://activitystrea.ms/schema/1.0/tag';
 922
 923     // Custom OStatus verbs for the flipside until they're standardized
 924     const DELETE     = 'http://ostatus.org/schema/1.0/unfollow';
 925     const UNFAVORITE = 'http://ostatus.org/schema/1.0/unfavorite';
 926     const UNFOLLOW   = 'http://ostatus.org/schema/1.0/unfollow';
 927     const LEAVE      = 'http://ostatus.org/schema/1.0/leave';
 928
 929     // For simple profile-update pings; no content to share.
 930     const UPDATE_PROFILE = 'http://ostatus.org/schema/1.0/update-profile';
 931 }
 932
 933 class ActivityContext
 934 {
 935     public $replyToID;
 936     public $replyToUrl;
 937     public $location;
 938     public $attention = array();
 939     public $conversation;
 940
 941     const THR     = 'http://purl.org/syndication/thread/1.0';
 942     const GEORSS  = 'http://www.georss.org/georss';
 943     const OSTATUS = 'http://ostatus.org/schema/1.0';
 944
 945     const INREPLYTO = 'in-reply-to';
 946     const REF       = 'ref';
 947     const HREF      = 'href';
 948
 949     const POINT     = 'point';
 950
 951     const ATTENTION    = 'ostatus:attention';
 952     const CONVERSATION = 'ostatus:conversation';
 953
 954     function __construct($element)
 955     {
 956         $replyToEl = ActivityUtils::child($element, self::INREPLYTO, self::THR);
 957
 958         if (!empty($replyToEl)) {
 959             $this->replyToID  = $replyToEl->getAttribute(self::REF);
 960             $this->replyToUrl = $replyToEl->getAttribute(self::HREF);
 961         }
 962
 963         $this->location = $this->getLocation($element);
 964
 965         $this->conversation = ActivityUtils::getLink($element, self::CONVERSATION);
 966
 967         // Multiple attention links allowed
 968
 969         $links = $element->getElementsByTagNameNS(ActivityUtils::ATOM, ActivityUtils::LINK);
 970
 971         for ($i = 0; $i < $links->length; $i++) {
 972
 973             $link = $links->item($i);
 974
 975             $linkRel = $link->getAttribute(ActivityUtils::REL);
 976
 977             if ($linkRel == self::ATTENTION) {
 978                 $this->attention[] = $link->getAttribute(self::HREF);
 979             }
 980         }
 981     }
 982
 983     /**
 984      * Parse location given as a GeoRSS-simple point, if provided.
 985      * http://www.georss.org/simple
 986      *
 987      * @param feed item $entry
 988      * @return mixed Location or false
 989      */
 990     function getLocation($dom)
 991     {
 992         $points = $dom->getElementsByTagNameNS(self::GEORSS, self::POINT);
 993
 994         for ($i = 0; $i < $points->length; $i++) {
 995             $point = $points->item($i)->textContent;
 996             return self::locationFromPoint($point);
 997         }
 998
 999         return null;
1000     }
1001
1002     // XXX: Move to ActivityUtils or Location?
1003     static function locationFromPoint($point)
1004     {
1005         $point = str_replace(',', ' ', $point); // per spec "treat commas as whitespace"
1006         $point = preg_replace('/\s+/', ' ', $point);
1007         $point = trim($point);
1008         $coords = explode(' ', $point);
1009         if (count($coords) == 2) {
1010             list($lat, $lon) = $coords;
1011             if (is_numeric($lat) && is_numeric($lon)) {
1012                 common_log(LOG_INFO, "Looking up location for $lat $lon from georss point");
1013                 return Location::fromLatLon($lat, $lon);
1014             }
1015         }
1016         common_log(LOG_ERR, "Ignoring bogus georss:point value $point");
1017         return null;
1018     }
1019 }
1020
1021 /**
1022  * An activity in the ActivityStrea.ms world
1023  *
1024  * An activity is kind of like a sentence: someone did something
1025  * to something else.
1026  *
1027  * 'someone' is the 'actor'; 'did something' is the verb;
1028  * 'something else' is the object.
1029  *
1030  * @category  OStatus
1031  * @package   StatusNet
1032  * @author    Evan Prodromou <evan@status.net>
1033  * @copyright 2010 StatusNet, Inc.
1034  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html AGPLv3
1035  * @link      http://status.net/
1036  */
1037
1038 class Activity
1039 {
1040     const SPEC   = 'http://activitystrea.ms/spec/1.0/';
1041     const SCHEMA = 'http://activitystrea.ms/schema/1.0/';
1042
1043     const VERB       = 'verb';
1044     const OBJECT     = 'object';
1045     const ACTOR      = 'actor';
1046     const SUBJECT    = 'subject';
1047     const OBJECTTYPE = 'object-type';
1048     const CONTEXT    = 'context';
1049     const TARGET     = 'target';
1050
1051     const ATOM = 'http://www.w3.org/2005/Atom';
1052
1053     const AUTHOR    = 'author';
1054     const PUBLISHED = 'published';
1055     const UPDATED   = 'updated';
1056
1057     public $actor;   // an ActivityObject
1058     public $verb;    // a string (the URL)
1059     public $object;  // an ActivityObject
1060     public $target;  // an ActivityObject
1061     public $context; // an ActivityObject
1062     public $time;    // Time of the activity
1063     public $link;    // an ActivityObject
1064     public $entry;   // the source entry
1065     public $feed;    // the source feed
1066
1067     public $summary; // summary of activity
1068     public $content; // HTML content of activity
1069     public $id;      // ID of the activity
1070     public $title;   // title of the activity
1071     public $categories = array(); // list of AtomCategory objects
1072     public $enclosures = array(); // list of enclosure URL references
1073
1074     /**
1075      * Turns a regular old Atom <entry> into a magical activity
1076      *
1077      * @param DOMElement $entry Atom entry to poke at
1078      * @param DOMElement $feed  Atom feed, for context
1079      */
1080
1081     function __construct($entry = null, $feed = null)
1082     {
1083         if (is_null($entry)) {
1084             return;
1085         }
1086
1087         $this->entry = $entry;
1088
1089         // Insist on a feed's root DOMElement; don't allow a DOMDocument
1090         if ($feed instanceof DOMDocument) {
1091             throw new ClientException(
1092                 _("Expecting a root feed element but got a whole XML document.")
1093             );
1094         }
1095
1096         $this->feed  = $feed;
1097
1098         $pubEl = $this->_child($entry, self::PUBLISHED, self::ATOM);
1099
1100         if (!empty($pubEl)) {
1101             $this->time = strtotime($pubEl->textContent);
1102         } else {
1103             // XXX technically an error; being liberal. Good idea...?
1104             $updateEl = $this->_child($entry, self::UPDATED, self::ATOM);
1105             if (!empty($updateEl)) {
1106                 $this->time = strtotime($updateEl->textContent);
1107             } else {
1108                 $this->time = null;
1109             }
1110         }
1111
1112         $this->link = ActivityUtils::getPermalink($entry);
1113
1114         $verbEl = $this->_child($entry, self::VERB);
1115
1116         if (!empty($verbEl)) {
1117             $this->verb = trim($verbEl->textContent);
1118         } else {
1119             $this->verb = ActivityVerb::POST;
1120             // XXX: do other implied stuff here
1121         }
1122
1123         $objectEl = $this->_child($entry, self::OBJECT);
1124
1125         if (!empty($objectEl)) {
1126             $this->object = new ActivityObject($objectEl);
1127         } else {
1128             $this->object = new ActivityObject($entry);
1129         }
1130
1131         $actorEl = $this->_child($entry, self::ACTOR);
1132
1133         if (!empty($actorEl)) {
1134
1135             $this->actor = new ActivityObject($actorEl);
1136
1137         } else if (!empty($feed) &&
1138                    $subjectEl = $this->_child($feed, self::SUBJECT)) {
1139
1140             $this->actor = new ActivityObject($subjectEl);
1141
1142         } else if ($authorEl = $this->_child($entry, self::AUTHOR, self::ATOM)) {
1143
1144             $this->actor = new ActivityObject($authorEl);
1145
1146         } else if (!empty($feed) && $authorEl = $this->_child($feed, self::AUTHOR,
1147                                                               self::ATOM)) {
1148
1149             $this->actor = new ActivityObject($authorEl);
1150         }
1151
1152         $contextEl = $this->_child($entry, self::CONTEXT);
1153
1154         if (!empty($contextEl)) {
1155             $this->context = new ActivityContext($contextEl);
1156         } else {
1157             $this->context = new ActivityContext($entry);
1158         }
1159
1160         $targetEl = $this->_child($entry, self::TARGET);
1161
1162         if (!empty($targetEl)) {
1163             $this->target = new ActivityObject($targetEl);
1164         }
1165
1166         $this->summary = ActivityUtils::childContent($entry, 'summary');
1167         $this->id      = ActivityUtils::childContent($entry, 'id');
1168         $this->content = ActivityUtils::getContent($entry);
1169
1170         $catEls = $entry->getElementsByTagNameNS(self::ATOM, 'category');
1171         if ($catEls) {
1172             for ($i = 0; $i < $catEls->length; $i++) {
1173                 $catEl = $catEls->item($i);
1174                 $this->categories[] = new AtomCategory($catEl);
1175             }
1176         }
1177
1178         foreach (ActivityUtils::getLinks($entry, 'enclosure') as $link) {
1179             $this->enclosures[] = $link->getAttribute('href');
1180         }
1181     }
1182
1183     /**
1184      * Returns an Atom <entry> based on this activity
1185      *
1186      * @return DOMElement Atom entry
1187      */
1188
1189     function toAtomEntry()
1190     {
1191         return null;
1192     }
1193
1194     function asString($namespace=false)
1195     {
1196         $xs = new XMLStringer(true);
1197
1198         if ($namespace) {
1199             $attrs = array('xmlns' => 'http://www.w3.org/2005/Atom',
1200                            'xmlns:activity' => 'http://activitystrea.ms/spec/1.0/',
1201                            'xmlns:georss' => 'http://www.georss.org/georss',
1202                            'xmlns:ostatus' => 'http://ostatus.org/schema/1.0',
1203                            'xmlns:poco' => 'http://portablecontacts.net/spec/1.0',
1204                            'xmlns:media' => 'http://purl.org/syndication/atommedia');
1205         } else {
1206             $attrs = array();
1207         }
1208
1209         $xs->elementStart('entry', $attrs);
1210
1211         $xs->element('id', null, $this->id);
1212         $xs->element('title', null, $this->title);
1213         $xs->element('published', null, common_date_iso8601($this->time));
1214         $xs->element('content', array('type' => 'html'), $this->content);
1215
1216         if (!empty($this->summary)) {
1217             $xs->element('summary', null, $this->summary);
1218         }
1219
1220         if (!empty($this->link)) {
1221             $xs->element('link', array('rel' => 'alternate',
1222                                        'type' => 'text/html'),
1223                          $this->link);
1224         }
1225
1226         // XXX: add context
1227
1228         $xs->elementStart('author');
1229         $xs->element('uri', array(), $this->actor->id);
1230         if ($this->actor->title) {
1231             $xs->element('name', array(), $this->actor->title);
1232         }
1233         $xs->elementEnd('author');
1234         $xs->raw($this->actor->asString('activity:actor'));
1235
1236         $xs->element('activity:verb', null, $this->verb);
1237
1238         if ($this->object) {
1239             $xs->raw($this->object->asString());
1240         }
1241
1242         if ($this->target) {
1243             $xs->raw($this->target->asString('activity:target'));
1244         }
1245
1246         foreach ($this->categories as $cat) {
1247             $xs->raw($cat->asString());
1248         }
1249
1250         $xs->elementEnd('entry');
1251
1252         return $xs->getString();
1253     }
1254
1255     private function _child($element, $tag, $namespace=self::SPEC)
1256     {
1257         return ActivityUtils::child($element, $tag, $namespace);
1258     }
1259 }
1260
1261 class AtomCategory
1262 {
1263     public $term;
1264     public $scheme;
1265     public $label;
1266
1267     function __construct($element=null)
1268     {
1269         if ($element && $element->attributes) {
1270             $this->term = $this->extract($element, 'term');
1271             $this->scheme = $this->extract($element, 'scheme');
1272             $this->label = $this->extract($element, 'label');
1273         }
1274     }
1275
1276     protected function extract($element, $attrib)
1277     {
1278         $node = $element->attributes->getNamedItemNS(Activity::ATOM, $attrib);
1279         if ($node) {
1280             return trim($node->textContent);
1281         }
1282         $node = $element->attributes->getNamedItem($attrib);
1283         if ($node) {
1284             return trim($node->textContent);
1285         }
1286         return null;
1287     }
1288
1289     function asString()
1290     {
1291         $attribs = array();
1292         if ($this->term !== null) {
1293             $attribs['term'] = $this->term;
1294         }
1295         if ($this->scheme !== null) {
1296             $attribs['scheme'] = $this->scheme;
1297         }
1298         if ($this->label !== null) {
1299             $attribs['label'] = $this->label;
1300         }
1301         $xs = new XMLStringer();
1302         $xs->element('category', $attribs);
1303         return $xs->asString();
1304     }
1305 }