lib/microappplugin.php

   1 <?php
   2 /**
   3  * StatusNet - the distributed open-source microblogging tool
   4  * Copyright (C) 2011, StatusNet, Inc.
   5  *
   6  * Superclass for microapp plugin
   7  *
   8  * PHP version 5
   9  *
  10  * This program is free software: you can redistribute it and/or modify
  11  * it under the terms of the GNU Affero General Public License as published by
  12  * the Free Software Foundation, either version 3 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Affero General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Affero General Public License
  21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  *
  23  * @category  Microapp
  24  * @package   StatusNet
  25  * @author    Evan Prodromou <evan@status.net>
  26  * @copyright 2011 StatusNet, Inc.
  27  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html AGPL 3.0
  28  * @link      http://status.net/
  29  */
  30
  31 if (!defined('STATUSNET')) {
  32     // This check helps protect against security problems;
  33     // your code file can't be executed directly from the web.
  34     exit(1);
  35 }
  36
  37 /**
  38  * Superclass for microapp plugins
  39  *
  40  * This class lets you define micro-applications with different kinds of activities.
  41  *
  42  * The applications work more-or-less like other
  43  *
  44  * @category  Microapp
  45  * @package   StatusNet
  46  * @author    Evan Prodromou <evan@status.net>
  47  * @copyright 2011 StatusNet, Inc.
  48  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html AGPL 3.0
  49  * @link      http://status.net/
  50  */
  51
  52 abstract class MicroAppPlugin extends Plugin
  53 {
  54     abstract function appTitle();
  55     abstract function tag();
  56     abstract function types();
  57     abstract function saveNoticeFromActivity($activity, $actor, $options);
  58     abstract function activityObjectFromNotice($notice);
  59     abstract function showNotice($notice, $out);
  60     abstract function entryForm($out);
  61     abstract function deleteRelated($notice);
  62
  63     function isMyNotice($notice) {
  64         $types = $this->types();
  65         return in_array($notice->object_type, $types);
  66     }
  67
  68     function isMyActivity($activity) {
  69         $types = $this->types();
  70         return (count($activity->objects) == 1 &&
  71                 in_array($activity->objects[0]->type, $types));
  72     }
  73
  74     /**
  75      * When a notice is deleted, delete the related objects
  76      *
  77      * @param Notice $notice Notice being deleted
  78      *
  79      * @return boolean hook value
  80      */
  81
  82     function onNoticeDeleteRelated($notice)
  83     {
  84         if ($this->isMyNotice($notice)) {
  85             $this->deleteRelated($notice);
  86         }
  87
  88         return true;
  89     }
  90
  91     /**
  92      * Output the HTML for this kind of object in a list
  93      *
  94      * @param NoticeListItem $nli The list item being shown.
  95      *
  96      * @return boolean hook value
  97      */
  98
  99     function onStartShowNoticeItem($nli)
 100     {
 101         if (!$this->isMyNotice($nli->notice)) {
 102             return true;
 103         }
 104
 105         $out = $nli->out;
 106         $notice = $nli->notice;
 107
 108         $this->showNotice($notice, $out);
 109
 110         $nli->showNoticeLink();
 111         $nli->showNoticeSource();
 112         $nli->showNoticeLocation();
 113         $nli->showContext();
 114         $nli->showRepeat();
 115
 116         $out->elementEnd('div');
 117
 118         $nli->showNoticeOptions();
 119
 120         return false;
 121     }
 122
 123     /**
 124      * Render a notice as one of our objects
 125      *
 126      * @param Notice         $notice  Notice to render
 127      * @param ActivityObject &$object Empty object to fill
 128      *
 129      * @return boolean hook value
 130      */
 131
 132     function onStartActivityObjectFromNotice($notice, &$object)
 133     {
 134         if ($this->isMyNotice($notice)) {
 135             $object = $this->activityObjectFromNotice($notice);
 136             return false;
 137         }
 138
 139         return true;
 140     }
 141
 142     /**
 143      * Handle a posted object from PuSH
 144      *
 145      * @param Activity        $activity activity to handle
 146      * @param Ostatus_profile $oprofile Profile for the feed
 147      *
 148      * @return boolean hook value
 149      */
 150
 151     function onStartHandleFeedEntryWithProfile($activity, $oprofile)
 152     {
 153         if ($this->isMyActivity($activity)) {
 154
 155             $actor = $oprofile->checkAuthorship($activity);
 156
 157             if (empty($actor)) {
 158                 throw new ClientException(_('Can\'t get author for activity.'));
 159             }
 160
 161             $object = $activity->objects[0];
 162
 163             $options = array('uri' => $object->id,
 164                              'url' => $object->link,
 165                              'is_local' => Notice::REMOTE_OMB,
 166                              'source' => 'ostatus');
 167
 168             $this->saveNoticeFromActivity($activity, $actor);
 169
 170             return false;
 171         }
 172
 173         return true;
 174     }
 175
 176     /**
 177      * Handle a posted object from Salmon
 178      *
 179      * @param Activity $activity activity to handle
 180      * @param mixed    $target   user or group targeted
 181      *
 182      * @return boolean hook value
 183      */
 184
 185     function onStartHandleSalmonTarget($activity, $target)
 186     {
 187         if ($this->isMyActivity($activity)) {
 188
 189             $this->log(LOG_INFO, "Checking {$activity->id} as a valid Salmon slap.");
 190
 191             if ($target instanceof User_group) {
 192                 $uri = $target->getUri();
 193                 if (!in_array($uri, $activity->context->attention)) {
 194                     throw new ClientException(_("Bookmark not posted ".
 195                                                 "to this group."));
 196                 }
 197             } else if ($target instanceof User) {
 198                 $uri      = $target->uri;
 199                 $original = null;
 200                 if (!empty($activity->context->replyToID)) {
 201                     $original = Notice::staticGet('uri',
 202                                                   $activity->context->replyToID);
 203                 }
 204                 if (!in_array($uri, $activity->context->attention) &&
 205                     (empty($original) ||
 206                      $original->profile_id != $target->id)) {
 207                     throw new ClientException(_("Object not posted ".
 208                                                 "to this user."));
 209                 }
 210             } else {
 211                 throw new ServerException(_("Don't know how to handle ".
 212                                             "this kind of target."));
 213             }
 214
 215             $actor = Ostatus_profile::ensureActivityObjectProfile($activity->actor);
 216
 217             $object = $activity->objects[0];
 218
 219             $options = array('uri' => $object->id,
 220                              'url' => $object->link,
 221                              'is_local' => Notice::REMOTE_OMB,
 222                              'source' => 'ostatus');
 223
 224             $this->saveNoticeFromActivity($activity, $actor, $options);
 225
 226             return false;
 227         }
 228
 229         return true;
 230     }
 231
 232     /**
 233      * Handle object posted via AtomPub
 234      *
 235      * @param Activity &$activity Activity that was posted
 236      * @param User     $user      User that posted it
 237      * @param Notice   &$notice   Resulting notice
 238      *
 239      * @return boolean hook value
 240      */
 241
 242     function onStartAtomPubNewActivity(&$activity, $user, &$notice)
 243     {
 244         if ($this->isMyActivity($activity)) {
 245
 246             $options = array('source' => 'atompub');
 247
 248             $this->saveNoticeFromActivity($activity,
 249                                           $user->getProfile(),
 250                                           $options);
 251
 252             return false;
 253         }
 254
 255         return true;
 256     }
 257
 258     /**
 259      * Handle object imported from a backup file
 260      *
 261      * @param User           $user     User to import for
 262      * @param ActivityObject $author   Original author per import file
 263      * @param Activity       $activity Activity to import
 264      * @param boolean        $trusted  Is this a trusted user?
 265      * @param boolean        &$done    Is this done (success or unrecoverable error)
 266      *
 267      * @return boolean hook value
 268      */
 269
 270     function onStartImportActivity($user, $author, $activity, $trusted, &$done)
 271     {
 272         if ($this->isMyActivity($activity)) {
 273
 274             $obj = $activity->objects[0];
 275
 276             $options = array('uri' => $object->id,
 277                              'url' => $object->link,
 278                              'source' => 'restore');
 279
 280             $saved = $this->saveNoticeFromActivity($activity,
 281                                                    $user->getProfile(),
 282                                                    $options);
 283
 284             if (!empty($saved)) {
 285                 $done = true;
 286             }
 287
 288             return false;
 289         }
 290
 291         return true;
 292     }
 293
 294     function onStartShowEntryForms(&$tabs)
 295     {
 296         $tabs[$this->tag()] = $this->appTitle();
 297         return true;
 298     }
 299
 300     function onStartMakeEntryForm($tag, $out, &$form)
 301     {
 302         $this->log(LOG_INFO, "onStartMakeEntryForm() called for tag '$tag'");
 303
 304         if ($tag == $this->tag()) {
 305             $form = $this->entryForm($out);
 306             return false;
 307         }
 308
 309         return true;
 310     }
 311 }