plugins/OStatus/classes/Ostatus_profile.php

   1 <?php
   2 /*
   3  * StatusNet - the distributed open-source microblogging tool
   4  * Copyright (C) 2009-2010, StatusNet, Inc.
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU Affero General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Affero General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Affero General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /**
  21  * @package OStatusPlugin
  22  * @maintainer Brion Vibber <brion@status.net>
  23  */
  24
  25 class Ostatus_profile extends Memcached_DataObject
  26 {
  27     public $__table = 'ostatus_profile';
  28
  29     public $uri;
  30
  31     public $profile_id;
  32     public $group_id;
  33
  34     public $feeduri;
  35     public $salmonuri;
  36     public $avatar; // remote URL of the last avatar we saved
  37
  38     public $created;
  39     public $modified;
  40
  41     public /*static*/ function staticGet($k, $v=null)
  42     {
  43         return parent::staticGet(__CLASS__, $k, $v);
  44     }
  45
  46     /**
  47      * return table definition for DB_DataObject
  48      *
  49      * DB_DataObject needs to know something about the table to manipulate
  50      * instances. This method provides all the DB_DataObject needs to know.
  51      *
  52      * @return array array of column definitions
  53      */
  54
  55     function table()
  56     {
  57         return array('uri' => DB_DATAOBJECT_STR + DB_DATAOBJECT_NOTNULL,
  58                      'profile_id' => DB_DATAOBJECT_INT,
  59                      'group_id' => DB_DATAOBJECT_INT,
  60                      'feeduri' => DB_DATAOBJECT_STR,
  61                      'salmonuri' =>  DB_DATAOBJECT_STR,
  62                      'avatar' =>  DB_DATAOBJECT_STR,
  63                      'created' => DB_DATAOBJECT_STR + DB_DATAOBJECT_DATE + DB_DATAOBJECT_TIME + DB_DATAOBJECT_NOTNULL,
  64                      'modified' => DB_DATAOBJECT_STR + DB_DATAOBJECT_DATE + DB_DATAOBJECT_TIME + DB_DATAOBJECT_NOTNULL);
  65     }
  66
  67     static function schemaDef()
  68     {
  69         return array(new ColumnDef('uri', 'varchar',
  70                                    255, false, 'PRI'),
  71                      new ColumnDef('profile_id', 'integer',
  72                                    null, true, 'UNI'),
  73                      new ColumnDef('group_id', 'integer',
  74                                    null, true, 'UNI'),
  75                      new ColumnDef('feeduri', 'varchar',
  76                                    255, true, 'UNI'),
  77                      new ColumnDef('salmonuri', 'text',
  78                                    null, true),
  79                      new ColumnDef('avatar', 'text',
  80                                    null, true),
  81                      new ColumnDef('created', 'datetime',
  82                                    null, false),
  83                      new ColumnDef('modified', 'datetime',
  84                                    null, false));
  85     }
  86
  87     /**
  88      * return key definitions for DB_DataObject
  89      *
  90      * DB_DataObject needs to know about keys that the table has; this function
  91      * defines them.
  92      *
  93      * @return array key definitions
  94      */
  95
  96     function keys()
  97     {
  98         return array_keys($this->keyTypes());
  99     }
 100
 101     /**
 102      * return key definitions for Memcached_DataObject
 103      *
 104      * Our caching system uses the same key definitions, but uses a different
 105      * method to get them.
 106      *
 107      * @return array key definitions
 108      */
 109
 110     function keyTypes()
 111     {
 112         return array('uri' => 'K', 'profile_id' => 'U', 'group_id' => 'U', 'feeduri' => 'U');
 113     }
 114
 115     function sequenceKey()
 116     {
 117         return array(false, false, false);
 118     }
 119
 120     /**
 121      * Fetch the StatusNet-side profile for this feed
 122      * @return Profile
 123      */
 124     public function localProfile()
 125     {
 126         if ($this->profile_id) {
 127             return Profile::staticGet('id', $this->profile_id);
 128         }
 129         return null;
 130     }
 131
 132     /**
 133      * Fetch the StatusNet-side profile for this feed
 134      * @return Profile
 135      */
 136     public function localGroup()
 137     {
 138         if ($this->group_id) {
 139             return User_group::staticGet('id', $this->group_id);
 140         }
 141         return null;
 142     }
 143
 144     /**
 145      * Returns an ActivityObject describing this remote user or group profile.
 146      * Can then be used to generate Atom chunks.
 147      *
 148      * @return ActivityObject
 149      */
 150     function asActivityObject()
 151     {
 152         if ($this->isGroup()) {
 153             $object = new ActivityObject();
 154             $object->type = 'http://activitystrea.ms/schema/1.0/group';
 155             $object->id = $this->uri;
 156             $self = $this->localGroup();
 157
 158             // @fixme put a standard getAvatar() interface on groups too
 159             if ($self->homepage_logo) {
 160                 $object->avatar = $self->homepage_logo;
 161                 $map = array('png' => 'image/png',
 162                              'jpg' => 'image/jpeg',
 163                              'jpeg' => 'image/jpeg',
 164                              'gif' => 'image/gif');
 165                 $extension = pathinfo(parse_url($avatarHref, PHP_URL_PATH), PATHINFO_EXTENSION);
 166                 if (isset($map[$extension])) {
 167                     // @fixme this ain't used/saved yet
 168                     $object->avatarType = $map[$extension];
 169                 }
 170             }
 171
 172             $object->link = $this->uri; // @fixme accurate?
 173             return $object;
 174         } else {
 175             return ActivityObject::fromProfile($this->localProfile());
 176         }
 177     }
 178
 179     /**
 180      * Returns an XML string fragment with profile information as an
 181      * Activity Streams noun object with the given element type.
 182      *
 183      * Assumes that 'activity' namespace has been previously defined.
 184      *
 185      * @fixme replace with wrappers on asActivityObject when it's got everything.
 186      *
 187      * @param string $element one of 'actor', 'subject', 'object', 'target'
 188      * @return string
 189      */
 190     function asActivityNoun($element)
 191     {
 192         $xs = new XMLStringer(true);
 193         $avatarHref = Avatar::defaultImage(AVATAR_PROFILE_SIZE);
 194         $avatarType = 'image/png';
 195         if ($this->isGroup()) {
 196             $type = 'http://activitystrea.ms/schema/1.0/group';
 197             $self = $this->localGroup();
 198
 199             // @fixme put a standard getAvatar() interface on groups too
 200             if ($self->homepage_logo) {
 201                 $avatarHref = $self->homepage_logo;
 202                 $map = array('png' => 'image/png',
 203                              'jpg' => 'image/jpeg',
 204                              'jpeg' => 'image/jpeg',
 205                              'gif' => 'image/gif');
 206                 $extension = pathinfo(parse_url($avatarHref, PHP_URL_PATH), PATHINFO_EXTENSION);
 207                 if (isset($map[$extension])) {
 208                     $avatarType = $map[$extension];
 209                 }
 210             }
 211         } else {
 212             $type = 'http://activitystrea.ms/schema/1.0/person';
 213             $self = $this->localProfile();
 214             $avatar = $self->getAvatar(AVATAR_PROFILE_SIZE);
 215             if ($avatar) {
 216                   $avatarHref = $avatar->url;
 217                   $avatarType = $avatar->mediatype;
 218             }
 219         }
 220         $xs->elementStart('activity:' . $element);
 221         $xs->element(
 222             'activity:object-type',
 223             null,
 224             $type
 225         );
 226         $xs->element(
 227             'id',
 228             null,
 229             $this->uri); // ?
 230         $xs->element('title', null, $self->getBestName());
 231
 232         $xs->element(
 233             'link', array(
 234                 'type' => $avatarType,
 235                 'href' => $avatarHref
 236             ),
 237             ''
 238         );
 239
 240         $xs->elementEnd('activity:' . $element);
 241
 242         return $xs->getString();
 243     }
 244
 245     /**
 246      * @return boolean true if this is a remote group
 247      */
 248     function isGroup()
 249     {
 250         if ($this->profile_id && !$this->group_id) {
 251             return false;
 252         } else if ($this->group_id && !$this->profile_id) {
 253             return true;
 254         } else if ($this->group_id && $this->profile_id) {
 255             throw new ServerException("Invalid ostatus_profile state: both group and profile IDs set for $this->uri");
 256         } else {
 257             throw new ServerException("Invalid ostatus_profile state: both group and profile IDs empty for $this->uri");
 258         }
 259     }
 260
 261     /**
 262      * Subscribe a local user to this remote user.
 263      * PuSH subscription will be started if necessary, and we'll
 264      * send a Salmon notification to the remote server if available
 265      * notifying them of the sub.
 266      *
 267      * @param User $user
 268      * @return boolean success
 269      * @throws FeedException
 270      */
 271     public function subscribeLocalToRemote(User $user)
 272     {
 273         if ($this->isGroup()) {
 274             throw new ServerException("Can't subscribe to a remote group");
 275         }
 276
 277         if ($this->subscribe()) {
 278             if ($user->subscribeTo($this->localProfile())) {
 279                 $this->notify($user->getProfile(), ActivityVerb::FOLLOW, $this);
 280                 return true;
 281             }
 282         }
 283         return false;
 284     }
 285
 286     /**
 287      * Mark this remote profile as subscribing to the given local user,
 288      * and send appropriate notifications to the user.
 289      *
 290      * This will generally be in response to a subscription notification
 291      * from a foreign site to our local Salmon response channel.
 292      *
 293      * @param User $user
 294      * @return boolean success
 295      */
 296     public function subscribeRemoteToLocal(User $user)
 297     {
 298         if ($this->isGroup()) {
 299             throw new ServerException("Remote groups can't subscribe to local users");
 300         }
 301
 302         Subscription::start($this->localProfile(), $user->getProfile());
 303
 304         return true;
 305     }
 306
 307     /**
 308      * Send a subscription request to the hub for this feed.
 309      * The hub will later send us a confirmation POST to /main/push/callback.
 310      *
 311      * @return bool true on success, false on failure
 312      * @throws ServerException if feed state is not valid
 313      */
 314     public function subscribe()
 315     {
 316         $feedsub = FeedSub::ensureFeed($this->feeduri);
 317         if ($feedsub->sub_state == 'active' || $feedsub->sub_state == 'subscribe') {
 318             return true;
 319         } else if ($feedsub->sub_state == '' || $feedsub->sub_state == 'inactive') {
 320             return $feedsub->subscribe();
 321         } else if ('unsubscribe') {
 322             throw new FeedSubException("Unsub is pending, can't subscribe...");
 323         }
 324     }
 325
 326     /**
 327      * Send a PuSH unsubscription request to the hub for this feed.
 328      * The hub will later send us a confirmation POST to /main/push/callback.
 329      *
 330      * @return bool true on success, false on failure
 331      * @throws ServerException if feed state is not valid
 332      */
 333     public function unsubscribe() {
 334         $feedsub = FeedSub::staticGet('uri', $this->feeduri);
 335         if ($feedsub->sub_state == 'active') {
 336             return $feedsub->unsubscribe();
 337         } else if ($feedsub->sub_state == '' || $feedsub->sub_state == 'inactive' || $feedsub->sub_state == 'unsubscribe') {
 338             return true;
 339         } else if ($feedsub->sub_state == 'subscribe') {
 340             throw new FeedSubException("Feed is awaiting subscription, can't unsub...");
 341         }
 342     }
 343
 344     /**
 345      * Check if this remote profile has any active local subscriptions, and
 346      * if not drop the PuSH subscription feed.
 347      *
 348      * @return boolean
 349      */
 350     public function garbageCollect()
 351     {
 352         if ($this->isGroup()) {
 353             $members = $this->localGroup()->getMembers(0, 1);
 354             $count = $members->N;
 355         } else {
 356             $count = $this->localProfile()->subscriberCount();
 357         }
 358         if ($count == 0) {
 359             common_log(LOG_INFO, "Unsubscribing from now-unused remote feed $oprofile->feeduri");
 360             $this->unsubscribe();
 361             return true;
 362         } else {
 363             return false;
 364         }
 365     }
 366
 367     /**
 368      * Send an Activity Streams notification to the remote Salmon endpoint,
 369      * if so configured.
 370      *
 371      * @param Profile $actor  Actor who did the activity
 372      * @param string  $verb   Activity::SUBSCRIBE or Activity::JOIN
 373      * @param Object  $object object of the action; must define asActivityNoun($tag)
 374      */
 375     public function notify($actor, $verb, $object=null)
 376     {
 377         if (!($actor instanceof Profile)) {
 378             $type = gettype($actor);
 379             if ($type == 'object') {
 380                 $type = get_class($actor);
 381             }
 382             throw new ServerException("Invalid actor passed to " . __METHOD__ . ": " . $type);
 383         }
 384         if ($object == null) {
 385             $object = $this;
 386         }
 387         if ($this->salmonuri) {
 388
 389             $text = 'update';
 390             $id = TagURI::mint('%s:%s:%s',
 391                                $verb,
 392                                $actor->getURI(),
 393                                common_date_iso8601(time()));
 394
 395             // @fixme consolidate all these NS settings somewhere
 396             $attributes = array('xmlns' => Activity::ATOM,
 397                                 'xmlns:activity' => 'http://activitystrea.ms/spec/1.0/',
 398                                 'xmlns:thr' => 'http://purl.org/syndication/thread/1.0',
 399                                 'xmlns:georss' => 'http://www.georss.org/georss',
 400                                 'xmlns:ostatus' => 'http://ostatus.org/schema/1.0',
 401                                 'xmlns:poco' => 'http://portablecontacts.net/spec/1.0');
 402
 403             $entry = new XMLStringer();
 404             $entry->elementStart('entry', $attributes);
 405             $entry->element('id', null, $id);
 406             $entry->element('title', null, $text);
 407             $entry->element('summary', null, $text);
 408             $entry->element('published', null, common_date_w3dtf(common_sql_now()));
 409
 410             $entry->element('activity:verb', null, $verb);
 411             $entry->raw($actor->asAtomAuthor());
 412             $entry->raw($actor->asActivityActor());
 413             $entry->raw($object->asActivityNoun('object'));
 414             $entry->elementEnd('entry');
 415
 416             $xml = $entry->getString();
 417             common_log(LOG_INFO, "Posting to Salmon endpoint $this->salmonuri: $xml");
 418
 419             $salmon = new Salmon(); // ?
 420             return $salmon->post($this->salmonuri, $xml);
 421         }
 422         return false;
 423     }
 424
 425     /**
 426      * Send a Salmon notification ping immediately, and confirm that we got
 427      * an acceptable response from the remote site.
 428      *
 429      * @param mixed $entry XML string, Notice, or Activity
 430      * @return boolean success
 431      */
 432     public function notifyActivity($entry)
 433     {
 434         if ($this->salmonuri) {
 435             $salmon = new Salmon();
 436             return $salmon->post($this->salmonuri, $this->notifyPrepXml($entry));
 437         }
 438
 439         return false;
 440     }
 441
 442     /**
 443      * Queue a Salmon notification for later. If queues are disabled we'll
 444      * send immediately but won't get the return value.
 445      *
 446      * @param mixed $entry XML string, Notice, or Activity
 447      * @return boolean success
 448      */
 449     public function notifyDeferred($entry)
 450     {
 451         if ($this->salmonuri) {
 452             $data = array('salmonuri' => $this->salmonuri,
 453                           'entry' => $this->notifyPrepXml($entry));
 454
 455             $qm = QueueManager::get();
 456             return $qm->enqueue($data, 'salmon');
 457         }
 458
 459         return false;
 460     }
 461
 462     protected function notifyPrepXml($entry)
 463     {
 464         $preamble = '<?xml version="1.0" encoding="UTF-8" ?' . '>';
 465         if (is_string($entry)) {
 466             return $entry;
 467         } else if ($entry instanceof Activity) {
 468             return $preamble . $entry->asString(true);
 469         } else if ($entry instanceof Notice) {
 470             return $preamble . $entry->asAtomEntry(true, true);
 471         } else {
 472             throw new ServerException("Invalid type passed to Ostatus_profile::notify; must be XML string or Activity entry");
 473         }
 474     }
 475
 476     function getBestName()
 477     {
 478         if ($this->isGroup()) {
 479             return $this->localGroup()->getBestName();
 480         } else {
 481             return $this->localProfile()->getBestName();
 482         }
 483     }
 484
 485     function atomFeed($actor)
 486     {
 487         $feed = new Atom10Feed();
 488         // @fixme should these be set up somewhere else?
 489         $feed->addNamespace('activity', 'http://activitystrea.ms/spec/1.0/');
 490         $feed->addNamespace('thr', 'http://purl.org/syndication/thread/1.0');
 491         $feed->addNamespace('georss', 'http://www.georss.org/georss');
 492         $feed->addNamespace('ostatus', 'http://ostatus.org/schema/1.0');
 493
 494         $taguribase = common_config('integration', 'taguri');
 495         $feed->setId("tag:{$taguribase}:UserTimeline:{$actor->id}"); // ???
 496
 497         $feed->setTitle($actor->getBestName() . ' timeline'); // @fixme
 498         $feed->setUpdated(time());
 499         $feed->setPublished(time());
 500
 501         $feed->addLink(common_local_url('ApiTimelineUser',
 502                                         array('id' => $actor->id,
 503                                               'type' => 'atom')),
 504                        array('rel' => 'self',
 505                              'type' => 'application/atom+xml'));
 506
 507         $feed->addLink(common_local_url('userbyid',
 508                                         array('id' => $actor->id)),
 509                        array('rel' => 'alternate',
 510                              'type' => 'text/html'));
 511
 512         return $feed;
 513     }
 514
 515     /**
 516      * Read and post notices for updates from the feed.
 517      * Currently assumes that all items in the feed are new,
 518      * coming from a PuSH hub.
 519      *
 520      * @param DOMDocument $feed
 521      */
 522     public function processFeed($feed, $source)
 523     {
 524         $entries = $feed->getElementsByTagNameNS(Activity::ATOM, 'entry');
 525         if ($entries->length == 0) {
 526             common_log(LOG_ERR, __METHOD__ . ": no entries in feed update, ignoring");
 527             return;
 528         }
 529
 530         for ($i = 0; $i < $entries->length; $i++) {
 531             $entry = $entries->item($i);
 532             $this->processEntry($entry, $feed, $source);
 533         }
 534     }
 535
 536     /**
 537      * Process a posted entry from this feed source.
 538      *
 539      * @param DOMElement $entry
 540      * @param DOMElement $feed for context
 541      */
 542     public function processEntry($entry, $feed, $source)
 543     {
 544         $activity = new Activity($entry, $feed);
 545
 546         if ($activity->verb == ActivityVerb::POST) {
 547             $this->processPost($activity, $source);
 548         } else {
 549             common_log(LOG_INFO, "Ignoring activity with unrecognized verb $activity->verb");
 550         }
 551     }
 552
 553     /**
 554      * Process an incoming post activity from this remote feed.
 555      * @param Activity $activity
 556      * @param string $method 'push' or 'salmon'
 557      * @return mixed saved Notice or false
 558      * @fixme break up this function, it's getting nasty long
 559      */
 560     public function processPost($activity, $method)
 561     {
 562         if ($this->isGroup()) {
 563             // A group feed will contain posts from multiple authors.
 564             // @fixme validate these profiles in some way!
 565             $oprofile = self::ensureActorProfile($activity);
 566             if ($oprofile->isGroup()) {
 567                 // Groups can't post notices in StatusNet.
 568                 common_log(LOG_WARNING, "OStatus: skipping post with group listed as author: $oprofile->uri in feed from $this->uri");
 569                 return false;
 570             }
 571         } else {
 572             // Individual user feeds may contain only posts from themselves.
 573             // Authorship is validated against the profile URI on upper layers,
 574             // through PuSH setup or Salmon signature checks.
 575             $actorUri = self::getActorProfileURI($activity);
 576             if ($actorUri == $this->uri) {
 577                 // Check if profile info has changed and update it
 578                 $this->updateFromActivityObject($activity->actor);
 579             } else {
 580                 common_log(LOG_WARNING, "OStatus: skipping post with bad author: got $actorUri expected $this->uri");
 581                 return false;
 582             }
 583             $oprofile = $this;
 584         }
 585
 586         // The id URI will be used as a unique identifier for for the notice,
 587         // protecting against duplicate saves. It isn't required to be a URL;
 588         // tag: URIs for instance are found in Google Buzz feeds.
 589         $sourceUri = $activity->object->id;
 590         $dupe = Notice::staticGet('uri', $sourceUri);
 591         if ($dupe) {
 592             common_log(LOG_INFO, "OStatus: ignoring duplicate post: $sourceUri");
 593             return false;
 594         }
 595
 596         // We'll also want to save a web link to the original notice, if provided.
 597         $sourceUrl = null;
 598         if ($activity->object->link) {
 599             $sourceUrl = $activity->object->link;
 600         } else if ($activity->link) {
 601             $sourceUrl = $activity->link;
 602         } else if (preg_match('!^https?://!', $activity->object->id)) {
 603             $sourceUrl = $activity->object->id;
 604         }
 605
 606         // Get (safe!) HTML and text versions of the content
 607         $rendered = $this->purify($activity->object->content);
 608         $content = html_entity_decode(strip_tags($rendered));
 609
 610         $shortened = common_shorten_links($content);
 611
 612         // If it's too long, try using the summary, and make the
 613         // HTML an attachment.
 614
 615         $attachment = null;
 616
 617         if (Notice::contentTooLong($shortened)) {
 618             $attachment = $this->saveHTMLFile($activity->object->title, $rendered);
 619             $summary = $activity->object->summary;
 620             if (empty($summary)) {
 621                 $summary = $content;
 622             }
 623             $shortSummary = common_shorten_links($summary);
 624             if (Notice::contentTooLong($shortSummary)) {
 625                 $url = common_shorten_url(common_local_url('attachment',
 626                                                            array('attachment' => $attachment->id)));
 627                 $shortSummary = substr($shortSummary,
 628                                        0,
 629                                        Notice::maxContent() - (mb_strlen($url) + 2));
 630                 $shortSummary .= '… ' . $url;
 631                 $content = $shortSummary;
 632                 $rendered = common_render_text($content);
 633             }
 634         }
 635
 636         $options = array('is_local' => Notice::REMOTE_OMB,
 637                         'url' => $sourceUrl,
 638                         'uri' => $sourceUri,
 639                         'rendered' => $rendered,
 640                         'replies' => array(),
 641                         'groups' => array());
 642
 643         // Check for optional attributes...
 644
 645         if (!empty($activity->time)) {
 646             $options['created'] = common_sql_date($activity->time);
 647         }
 648
 649         if ($activity->context) {
 650             // Any individual or group attn: targets?
 651             $replies = $activity->context->attention;
 652             $options['groups'] = $this->filterReplies($oprofile, $replies);
 653             $options['replies'] = $replies;
 654
 655             // Maintain direct reply associations
 656             // @fixme what about conversation ID?
 657             if (!empty($activity->context->replyToID)) {
 658                 $orig = Notice::staticGet('uri',
 659                                           $activity->context->replyToID);
 660                 if (!empty($orig)) {
 661                     $options['reply_to'] = $orig->id;
 662                 }
 663             }
 664
 665             $location = $activity->context->location;
 666             if ($location) {
 667                 $options['lat'] = $location->lat;
 668                 $options['lon'] = $location->lon;
 669                 if ($location->location_id) {
 670                     $options['location_ns'] = $location->location_ns;
 671                     $options['location_id'] = $location->location_id;
 672                 }
 673             }
 674         }
 675
 676         try {
 677             $saved = Notice::saveNew($oprofile->profile_id,
 678                                      $content,
 679                                      'ostatus',
 680                                      $options);
 681             if ($saved) {
 682                 Ostatus_source::saveNew($saved, $this, $method);
 683                 if (!empty($attachment)) {
 684                     File_to_post::processNew($attachment->id, $saved->id);
 685                 }
 686             }
 687         } catch (Exception $e) {
 688             common_log(LOG_ERR, "OStatus save of remote message $sourceUri failed: " . $e->getMessage());
 689             throw $e;
 690         }
 691         common_log(LOG_INFO, "OStatus saved remote message $sourceUri as notice id $saved->id");
 692         return $saved;
 693     }
 694
 695     /**
 696      * Clean up HTML
 697      */
 698     protected function purify($html)
 699     {
 700         require_once INSTALLDIR.'/extlib/htmLawed/htmLawed.php';
 701         $config = array('safe' => 1);
 702         return htmLawed($html, $config);
 703     }
 704
 705     /**
 706      * Filters a list of recipient ID URIs to just those for local delivery.
 707      * @param Ostatus_profile local profile of sender
 708      * @param array in/out &$attention_uris set of URIs, will be pruned on output
 709      * @return array of group IDs
 710      */
 711     protected function filterReplies($sender, &$attention_uris)
 712     {
 713         common_log(LOG_DEBUG, "Original reply recipients: " . implode(', ', $attention_uris));
 714         $groups = array();
 715         $replies = array();
 716         foreach ($attention_uris as $recipient) {
 717             // Is the recipient a local user?
 718             $user = User::staticGet('uri', $recipient);
 719             if ($user) {
 720                 // @fixme sender verification, spam etc?
 721                 $replies[] = $recipient;
 722                 continue;
 723             }
 724
 725             // Is the recipient a remote group?
 726             $oprofile = Ostatus_profile::staticGet('uri', $recipient);
 727             if ($oprofile) {
 728                 if ($oprofile->isGroup()) {
 729                     // Deliver to local members of this remote group.
 730                     // @fixme sender verification?
 731                     $groups[] = $oprofile->group_id;
 732                 } else {
 733                     common_log(LOG_DEBUG, "Skipping reply to remote profile $recipient");
 734                 }
 735                 continue;
 736             }
 737
 738             // Is the recipient a local group?
 739             // @fixme we need a uri on user_group
 740             // $group = User_group::staticGet('uri', $recipient);
 741             $template = common_local_url('groupbyid', array('id' => '31337'));
 742             $template = preg_quote($template, '/');
 743             $template = str_replace('31337', '(\d+)', $template);
 744             if (preg_match("/$template/", $recipient, $matches)) {
 745                 $id = $matches[1];
 746                 $group = User_group::staticGet('id', $id);
 747                 if ($group) {
 748                     // Deliver to all members of this local group if allowed.
 749                     $profile = $sender->localProfile();
 750                     if ($profile->isMember($group)) {
 751                         $groups[] = $group->id;
 752                     } else {
 753                         common_log(LOG_DEBUG, "Skipping reply to local group $group->nickname as sender $profile->id is not a member");
 754                     }
 755                     continue;
 756                 } else {
 757                     common_log(LOG_DEBUG, "Skipping reply to bogus group $recipient");
 758                 }
 759             }
 760
 761             common_log(LOG_DEBUG, "Skipping reply to unrecognized profile $recipient");
 762
 763         }
 764         $attention_uris = $replies;
 765         common_log(LOG_DEBUG, "Local reply recipients: " . implode(', ', $replies));
 766         common_log(LOG_DEBUG, "Local group recipients: " . implode(', ', $groups));
 767         return $groups;
 768     }
 769
 770     /**
 771      * @param string $profile_url
 772      * @return Ostatus_profile
 773      * @throws FeedSubException
 774      */
 775     public static function ensureProfile($profile_uri, $hints=array())
 776     {
 777         // Get the canonical feed URI and check it
 778         $discover = new FeedDiscovery();
 779         $feeduri = $discover->discoverFromURL($profile_uri);
 780
 781         //$feedsub = FeedSub::ensureFeed($feeduri, $discover->feed);
 782         $huburi = $discover->getAtomLink('hub');
 783         $salmonuri = $discover->getAtomLink('salmon');
 784
 785         if (!$huburi) {
 786             // We can only deal with folks with a PuSH hub
 787             throw new FeedSubNoHubException();
 788         }
 789
 790         // Try to get a profile from the feed activity:subject
 791
 792         $feedEl = $discover->feed->documentElement;
 793
 794         $subject = ActivityUtils::child($feedEl, Activity::SUBJECT, Activity::SPEC);
 795
 796         if (!empty($subject)) {
 797             $subjObject = new ActivityObject($subject);
 798             return self::ensureActivityObjectProfile($subjObject, $feeduri, $salmonuri, $hints);
 799         }
 800
 801         // Otherwise, try the feed author
 802
 803         $author = ActivityUtils::child($feedEl, Activity::AUTHOR, Activity::ATOM);
 804
 805         if (!empty($author)) {
 806             $authorObject = new ActivityObject($author);
 807             return self::ensureActivityObjectProfile($authorObject, $feeduri, $salmonuri, $hints);
 808         }
 809
 810         // Sheesh. Not a very nice feed! Let's try fingerpoken in the
 811         // entries.
 812
 813         $entries = $discover->feed->getElementsByTagNameNS(Activity::ATOM, 'entry');
 814
 815         if (!empty($entries) && $entries->length > 0) {
 816
 817             $entry = $entries->item(0);
 818
 819             $actor = ActivityUtils::child($entry, Activity::ACTOR, Activity::SPEC);
 820
 821             if (!empty($actor)) {
 822                 $actorObject = new ActivityObject($actor);
 823                 return self::ensureActivityObjectProfile($actorObject, $feeduri, $salmonuri, $hints);
 824
 825             }
 826
 827             $author = ActivityUtils::child($entry, Activity::AUTHOR, Activity::ATOM);
 828
 829             if (!empty($author)) {
 830                 $authorObject = new ActivityObject($author);
 831                 return self::ensureActivityObjectProfile($authorObject, $feeduri, $salmonuri, $hints);
 832             }
 833         }
 834
 835         // XXX: make some educated guesses here
 836
 837         throw new FeedSubException("Can't find enough profile information to make a feed.");
 838     }
 839
 840     /**
 841      *
 842      * Download and update given avatar image
 843      * @param string $url
 844      * @throws Exception in various failure cases
 845      */
 846     protected function updateAvatar($url)
 847     {
 848         if ($url == $this->avatar) {
 849             // We've already got this one.
 850             return;
 851         }
 852
 853         if ($this->isGroup()) {
 854             $self = $this->localGroup();
 855         } else {
 856             $self = $this->localProfile();
 857         }
 858         if (!$self) {
 859             throw new ServerException(sprintf(
 860                 _m("Tried to update avatar for unsaved remote profile %s"),
 861                 $this->uri));
 862         }
 863
 864         // @fixme this should be better encapsulated
 865         // ripped from oauthstore.php (for old OMB client)
 866         $temp_filename = tempnam(sys_get_temp_dir(), 'listener_avatar');
 867         if (!copy($url, $temp_filename)) {
 868             throw new ServerException(sprintf(_m("Unable to fetch avatar from %s"), $url));
 869         }
 870
 871         if ($this->isGroup()) {
 872             $id = $this->group_id;
 873         } else {
 874             $id = $this->profile_id;
 875         }
 876         // @fixme should we be using different ids?
 877         $imagefile = new ImageFile($id, $temp_filename);
 878         $filename = Avatar::filename($id,
 879                                      image_type_to_extension($imagefile->type),
 880                                      null,
 881                                      common_timestamp());
 882         rename($temp_filename, Avatar::path($filename));
 883         $self->setOriginal($filename);
 884
 885         $orig = clone($this);
 886         $this->avatar = $url;
 887         $this->update($orig);
 888     }
 889
 890     /**
 891      * Pull avatar URL from ActivityObject or profile hints
 892      *
 893      * @param ActivityObject $object
 894      * @param array $hints
 895      * @return mixed URL string or false
 896      */
 897
 898     protected static function getActivityObjectAvatar($object, $hints=array())
 899     {
 900         if ($object->avatar) {
 901             return $object->avatar;
 902         } else if (array_key_exists('avatar', $hints)) {
 903             return $hints['avatar'];
 904         }
 905         return false;
 906     }
 907
 908     /**
 909      * Get an appropriate avatar image source URL, if available.
 910      *
 911      * @param ActivityObject $actor
 912      * @param DOMElement $feed
 913      * @return string
 914      */
 915
 916     protected static function getAvatar($actor, $feed)
 917     {
 918         $url = '';
 919         $icon = '';
 920         if ($actor->avatar) {
 921             $url = trim($actor->avatar);
 922         }
 923         if (!$url) {
 924             // Check <atom:logo> and <atom:icon> on the feed
 925             $els = $feed->childNodes();
 926             if ($els && $els->length) {
 927                 for ($i = 0; $i < $els->length; $i++) {
 928                     $el = $els->item($i);
 929                     if ($el->namespaceURI == Activity::ATOM) {
 930                         if (empty($url) && $el->localName == 'logo') {
 931                             $url = trim($el->textContent);
 932                             break;
 933                         }
 934                         if (empty($icon) && $el->localName == 'icon') {
 935                             // Use as a fallback
 936                             $icon = trim($el->textContent);
 937                         }
 938                     }
 939                 }
 940             }
 941             if ($icon && !$url) {
 942                 $url = $icon;
 943             }
 944         }
 945         if ($url) {
 946             $opts = array('allowed_schemes' => array('http', 'https'));
 947             if (Validate::uri($url, $opts)) {
 948                 return $url;
 949             }
 950         }
 951         return common_path('plugins/OStatus/images/96px-Feed-icon.svg.png');
 952     }
 953
 954     /**
 955      * Fetch, or build if necessary, an Ostatus_profile for the actor
 956      * in a given Activity Streams activity.
 957      *
 958      * @param Activity $activity
 959      * @param string $feeduri if we already know the canonical feed URI!
 960      * @param string $salmonuri if we already know the salmon return channel URI
 961      * @return Ostatus_profile
 962      */
 963
 964     public static function ensureActorProfile($activity, $feeduri=null, $salmonuri=null)
 965     {
 966         return self::ensureActivityObjectProfile($activity->actor, $feeduri, $salmonuri);
 967     }
 968
 969     public static function ensureActivityObjectProfile($object, $feeduri=null, $salmonuri=null, $hints=array())
 970     {
 971         $profile = self::getActivityObjectProfile($object);
 972         if ($profile) {
 973             $profile->updateFromActivityObject($object, $hints);
 974         } else {
 975             $profile = self::createActivityObjectProfile($object, $feeduri, $salmonuri, $hints);
 976         }
 977         return $profile;
 978     }
 979
 980     /**
 981      * @param Activity $activity
 982      * @return mixed matching Ostatus_profile or false if none known
 983      */
 984     public static function getActorProfile($activity)
 985     {
 986         return self::getActivityObjectProfile($activity->actor);
 987     }
 988
 989     protected static function getActivityObjectProfile($object)
 990     {
 991         $uri = self::getActivityObjectProfileURI($object);
 992         return Ostatus_profile::staticGet('uri', $uri);
 993     }
 994
 995     protected static function getActorProfileURI($activity)
 996     {
 997         return self::getActivityObjectProfileURI($activity->actor);
 998     }
 999
1000     /**
1001      * @param Activity $activity
1002      * @return string
1003      * @throws ServerException
1004      */
1005     protected static function getActivityObjectProfileURI($object)
1006     {
1007         $opts = array('allowed_schemes' => array('http', 'https'));
1008         if ($object->id && Validate::uri($object->id, $opts)) {
1009             return $object->id;
1010         }
1011         if ($object->link && Validate::uri($object->link, $opts)) {
1012             return $object->link;
1013         }
1014         throw new ServerException("No author ID URI found");
1015     }
1016
1017     /**
1018      * @fixme validate stuff somewhere
1019      */
1020
1021     protected static function createActorProfile($activity, $feeduri=null, $salmonuri=null)
1022     {
1023         $actor = $activity->actor;
1024
1025         self::createActivityObjectProfile($actor, $feeduri, $salmonuri);
1026     }
1027
1028     /**
1029      * Create local ostatus_profile and profile/user_group entries for
1030      * the provided remote user or group.
1031      *
1032      * @param ActivityObject $object
1033      * @param string $feeduri
1034      * @param string $salmonuri
1035      * @param array $hints
1036      *
1037      * @fixme fold $feeduri/$salmonuri into $hints
1038      * @return Ostatus_profile
1039      */
1040     protected static function createActivityObjectProfile($object, $feeduri=null, $salmonuri=null, $hints=array())
1041     {
1042         $homeuri  = $object->id;
1043
1044         if (!$homeuri) {
1045             common_log(LOG_DEBUG, __METHOD__ . " empty actor profile URI: " . var_export($activity, true));
1046             throw new ServerException("No profile URI");
1047         }
1048
1049         if (empty($feeduri)) {
1050             if (array_key_exists('feedurl', $hints)) {
1051                 $feeduri = $hints['feedurl'];
1052             }
1053         }
1054
1055         if (empty($salmonuri)) {
1056             if (array_key_exists('salmon', $hints)) {
1057                 $salmonuri = $hints['salmon'];
1058             }
1059         }
1060
1061         if (!$feeduri || !$salmonuri) {
1062             // Get the canonical feed URI and check it
1063             $discover = new FeedDiscovery();
1064             $feeduri = $discover->discoverFromURL($homeuri);
1065
1066             $huburi = $discover->getAtomLink('hub');
1067             $salmonuri = $discover->getAtomLink('salmon');
1068
1069             if (!$huburi) {
1070                 // We can only deal with folks with a PuSH hub
1071                 throw new FeedSubNoHubException();
1072             }
1073         }
1074
1075         $oprofile = new Ostatus_profile();
1076
1077         $oprofile->uri        = $homeuri;
1078         $oprofile->feeduri    = $feeduri;
1079         $oprofile->salmonuri  = $salmonuri;
1080
1081         $oprofile->created    = common_sql_now();
1082         $oprofile->modified   = common_sql_now();
1083
1084         if ($object->type == ActivityObject::PERSON) {
1085             $profile = new Profile();
1086             self::updateProfile($profile, $object, $hints);
1087             $profile->created  = common_sql_now();
1088
1089             $oprofile->profile_id = $profile->insert();
1090             if (!$oprofile->profile_id) {
1091                 throw new ServerException("Can't save local profile");
1092             }
1093         } else {
1094             $group = new User_group();
1095             $group->created = common_sql_now();
1096             self::updateGroup($group, $object, $hints);
1097
1098             $oprofile->group_id = $group->insert();
1099             if (!$oprofile->group_id) {
1100                 throw new ServerException("Can't save local profile");
1101             }
1102         }
1103
1104         $ok = $oprofile->insert();
1105
1106         if ($ok) {
1107             $avatar = self::getActivityObjectAvatar($object, $hints);
1108             if ($avatar) {
1109                 $oprofile->updateAvatar($avatar);
1110             }
1111             return $oprofile;
1112         } else {
1113             throw new ServerException("Can't save OStatus profile");
1114         }
1115     }
1116
1117     /**
1118      * Save any updated profile information to our local copy.
1119      * @param ActivityObject $object
1120      * @param array $hints
1121      */
1122     public function updateFromActivityObject($object, $hints=array())
1123     {
1124         if ($this->isGroup()) {
1125             $group = $this->localGroup();
1126             self::updateGroup($group, $object, $hints);
1127         } else {
1128             $profile = $this->localProfile();
1129             self::updateProfile($profile, $object, $hints);
1130         }
1131         $avatar = self::getActivityObjectAvatar($object, $hints);
1132         if ($avatar) {
1133             $this->updateAvatar($avatar);
1134         }
1135     }
1136
1137     protected static function updateProfile($profile, $object, $hints=array())
1138     {
1139         $orig = clone($profile);
1140
1141         $profile->nickname = self::getActivityObjectNickname($object, $hints);
1142         $profile->fullname = $object->title;
1143         if (!empty($object->link)) {
1144             $profile->profileurl = $object->link;
1145         } else if (array_key_exists('profileurl', $hints)) {
1146             $profile->profileurl = $hints['profileurl'];
1147         }
1148
1149         $profile->bio      = self::getActivityObjectBio($object, $hints);
1150         $profile->location = self::getActivityObjectLocation($object, $hints);
1151         $profile->homepage = self::getActivityObjectHomepage($object, $hints);
1152
1153         if (!empty($object->geopoint)) {
1154             $location = ActivityContext::locationFromPoint($object->geopoint);
1155             if (!empty($location)) {
1156                 $profile->lat = $location->lat;
1157                 $profile->lon = $location->lon;
1158             }
1159         }
1160
1161         // @fixme tags/categories
1162         // @todo tags from categories
1163
1164         if ($profile->id) {
1165             common_log(LOG_DEBUG, "Updating OStatus profile $profile->id from remote info $object->id: " . var_export($object, true) . var_export($hints, true));
1166             $profile->update($orig);
1167         }
1168     }
1169
1170     protected static function updateGroup($group, $object, $hints=array())
1171     {
1172         $orig = clone($group);
1173
1174         // @fixme need to make nick unique etc *hack hack*
1175         $group->nickname = self::getActivityObjectNickname($object, $hints);
1176         $group->fullname = $object->title;
1177
1178         // @fixme no canonical profileurl; using homepage instead for now
1179         $group->homepage = $object->id;
1180
1181         // @fixme homepage
1182         // @fixme bio
1183         // @fixme tags/categories
1184         // @fixme location?
1185         // @todo tags from categories
1186         // @todo lat/lon/location?
1187
1188         if ($group->id) {
1189             common_log(LOG_DEBUG, "Updating OStatus group $group->id from remote info $object->id: " . var_export($object, true) . var_export($hints, true));
1190             $group->update($orig);
1191         }
1192     }
1193
1194     protected static function getActivityObjectHomepage($object, $hints=array())
1195     {
1196         $homepage = null;
1197         $poco     = $object->poco;
1198
1199         if (!empty($poco)) {
1200             $url = $poco->getPrimaryURL();
1201             if ($url->type == 'homepage') {
1202                 $homepage = $url->value;
1203             }
1204         }
1205
1206         // @todo Try for a another PoCo URL?
1207
1208         return $homepage;
1209     }
1210
1211     protected static function getActivityObjectLocation($object, $hints=array())
1212     {
1213         $location = null;
1214
1215         if (!empty($object->poco)) {
1216             if (isset($object->poco->address->formatted)) {
1217                 $location = $object->poco->address->formatted;
1218                 if (mb_strlen($location) > 255) {
1219                     $location = mb_substr($note, 0, 255 - 3) . ' … ';
1220                 }
1221             }
1222         }
1223
1224         // @todo Try to find location some othe way? Via goerss point?
1225
1226         return $location;
1227     }
1228
1229     protected static function getActivityObjectBio($object, $hints=array())
1230     {
1231         $bio  = null;
1232
1233         if (!empty($object->poco)) {
1234             $note = $object->poco->note;
1235             if (!empty($note)) {
1236                 if (mb_strlen($note) > Profile::maxBio()) {
1237                     // XXX: truncate ok?
1238                     $bio = mb_substr($note, 0, Profile::maxBio() - 3) . ' … ';
1239                 } else {
1240                     $bio = $note;
1241                 }
1242             }
1243         }
1244
1245         // @todo Try to get bio info some other way?
1246
1247         return $bio;
1248     }
1249
1250     protected static function getActivityObjectNickname($object, $hints=array())
1251     {
1252         if ($object->poco) {
1253             if (!empty($object->poco->preferredUsername)) {
1254                 return common_nicknamize($object->poco->preferredUsername);
1255             }
1256         }
1257         if (!empty($object->nickname)) {
1258             return common_nicknamize($object->nickname);
1259         }
1260
1261         // Try the definitive ID
1262
1263         $nickname = self::nicknameFromURI($object->id);
1264
1265         // Try a Webfinger if one was passed (way) down
1266
1267         if (empty($nickname)) {
1268             if (array_key_exists('webfinger', $hints)) {
1269                 $nickname = self::nicknameFromURI($hints['webfinger']);
1270             }
1271         }
1272
1273         // Try the name
1274
1275         if (empty($nickname)) {
1276             $nickname = common_nicknamize($object->title);
1277         }
1278
1279         return $nickname;
1280     }
1281
1282     protected static function nicknameFromURI($uri)
1283     {
1284         preg_match('/(\w+):/', $uri, $matches);
1285
1286         $protocol = $matches[1];
1287
1288         switch ($protocol) {
1289         case 'acct':
1290         case 'mailto':
1291             if (preg_match("/^$protocol:(.*)?@.*\$/", $uri, $matches)) {
1292                 return common_canonical_nickname($matches[1]);
1293             }
1294             return null;
1295         case 'http':
1296             return common_url_to_nickname($uri);
1297             break;
1298         default:
1299             return null;
1300         }
1301     }
1302
1303     public static function ensureWebfinger($addr)
1304     {
1305         // First, look it up
1306
1307         $oprofile = Ostatus_profile::staticGet('uri', 'acct:'.$addr);
1308
1309         if (!empty($oprofile)) {
1310             return $oprofile;
1311         }
1312
1313         // Now, try some discovery
1314
1315         $wf = new Webfinger();
1316
1317         $result = $wf->lookup($addr);
1318
1319         if (!$result) {
1320             return null;
1321         }
1322
1323         foreach ($result->links as $link) {
1324             switch ($link['rel']) {
1325             case Webfinger::PROFILEPAGE:
1326                 $profileUrl = $link['href'];
1327                 break;
1328             case 'salmon':
1329                 $salmonEndpoint = $link['href'];
1330                 break;
1331             case Webfinger::UPDATESFROM:
1332                 $feedUrl = $link['href'];
1333                 break;
1334             default:
1335                 common_log(LOG_NOTICE, "Don't know what to do with rel = '{$link['rel']}'");
1336                 break;
1337             }
1338         }
1339
1340         $hints = array('webfinger' => $addr,
1341                        'profileurl' => $profileUrl,
1342                        'feedurl' => $feedUrl,
1343                        'salmon' => $salmonEndpoint);
1344
1345         // If we got a feed URL, try that
1346
1347         if (isset($feedUrl)) {
1348             try {
1349                 $oprofile = self::ensureProfile($feedUrl, $hints);
1350                 return $oprofile;
1351             } catch (Exception $e) {
1352                 common_log(LOG_WARNING, "Failed creating profile from feed URL '$feedUrl': " . $e->getMessage());
1353                 // keep looking
1354             }
1355         }
1356
1357         // If we got a profile page, try that!
1358
1359         if (isset($profileUrl)) {
1360             try {
1361                 $oprofile = self::ensureProfile($profileUrl, $hints);
1362                 return $oprofile;
1363             } catch (Exception $e) {
1364                 common_log(LOG_WARNING, "Failed creating profile from profile URL '$profileUrl': " . $e->getMessage());
1365                 // keep looking
1366             }
1367         }
1368
1369         // XXX: try hcard
1370         // XXX: try FOAF
1371
1372         if (isset($salmonEndpoint)) {
1373
1374             // An account URL, a salmon endpoint, and a dream? Not much to go
1375             // on, but let's give it a try
1376
1377             $uri = 'acct:'.$addr;
1378
1379             $profile = new Profile();
1380
1381             $profile->nickname = self::nicknameFromUri($uri);
1382             $profile->created  = common_sql_now();
1383
1384             if (isset($profileUrl)) {
1385                 $profile->profileurl = $profileUrl;
1386             }
1387
1388             $profile_id = $profile->insert();
1389
1390             if (!$profile_id) {
1391                 common_log_db_error($profile, 'INSERT', __FILE__);
1392                 throw new Exception("Couldn't save profile for '$addr'");
1393             }
1394
1395             $oprofile = new Ostatus_profile();
1396
1397             $oprofile->uri        = $uri;
1398             $oprofile->salmonuri  = $salmonEndpoint;
1399             $oprofile->profile_id = $profile_id;
1400             $oprofile->created    = common_sql_now();
1401
1402             if (isset($feedUrl)) {
1403                 $profile->feeduri = $feedUrl;
1404             }
1405
1406             $result = $oprofile->insert();
1407
1408             if (!$result) {
1409                 common_log_db_error($oprofile, 'INSERT', __FILE__);
1410                 throw new Exception("Couldn't save ostatus_profile for '$addr'");
1411             }
1412
1413             return $oprofile;
1414         }
1415
1416         return null;
1417     }
1418
1419     function saveHTMLFile($title, $rendered)
1420     {
1421         $final = sprintf("<!DOCTYPE html>\n<html><head><title>%s</title></head>".
1422                          '<body><div>%s</div></body></html>',
1423                          htmlspecialchars($title),
1424                          $rendered);
1425
1426         $filename = File::filename($this->localProfile(),
1427                                    'ostatus', // ignored?
1428                                    'text/html');
1429
1430         $filepath = File::path($filename);
1431
1432         file_put_contents($filepath, $final);
1433
1434         $file = new File;
1435
1436         $file->filename = $filename;
1437         $file->url      = File::url($filename);
1438         $file->size     = filesize($filepath);
1439         $file->date     = time();
1440         $file->mimetype = 'text/html';
1441
1442         $file_id = $file->insert();
1443
1444         if ($file_id === false) {
1445             common_log_db_error($file, "INSERT", __FILE__);
1446             throw new ServerException(_('Could not store HTML content of long post as file.'));
1447         }
1448
1449         return $file;
1450     }
1451 }