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);
  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
 107         $this->showNotice($notice, $out);
 108
 109         $nli->showNoticeLink();
 110         $nli->showNoticeSource();
 111         $nli->showNoticeLocation();
 112         $nli->showContext();
 113         $nli->showRepeat();
 114
 115         $out->elementEnd('div');
 116
 117         $nli->showNoticeOptions();
 118
 119         return false;
 120     }
 121
 122     /**
 123      * Render a notice as one of our objects
 124      *
 125      * @param Notice         $notice  Notice to render
 126      * @param ActivityObject &$object Empty object to fill
 127      *
 128      * @return boolean hook value
 129      */
 130
 131     function onStartActivityObjectFromNotice($notice, &$object)
 132     {
 133         if ($this->isMyNotice($notice)) {
 134             $object = $this->activityObjectFromNotice($notice);
 135             return false;
 136         }
 137
 138         return true;
 139     }
 140
 141     /**
 142      * Handle a posted object from PuSH
 143      *
 144      * @param Activity        $activity activity to handle
 145      * @param Ostatus_profile $oprofile Profile for the feed
 146      *
 147      * @return boolean hook value
 148      */
 149
 150     function onStartHandleFeedEntryWithProfile($activity, $oprofile)
 151     {
 152         if ($this->isMyActivity($activity)) {
 153
 154             $actor = $oprofile->checkAuthorship($activity);
 155
 156             if (empty($actor)) {
 157                 throw new ClientException(_('Can\'t get author for activity.'));
 158             }
 159
 160             $this->saveNoticeFromActivity($activity, $actor);
 161
 162             return false;
 163         }
 164
 165         return true;
 166     }
 167
 168     /**
 169      * Handle a posted object from Salmon
 170      *
 171      * @param Activity $activity activity to handle
 172      * @param mixed    $target   user or group targeted
 173      *
 174      * @return boolean hook value
 175      */
 176
 177     function onStartHandleSalmonTarget($activity, $target)
 178     {
 179         if ($this->isMyActivity($activity)) {
 180
 181             $this->log(LOG_INFO, "Checking {$activity->id} as a valid Salmon slap.");
 182
 183             if ($target instanceof User_group) {
 184                 $uri = $target->getUri();
 185                 if (!in_array($uri, $activity->context->attention)) {
 186                     throw new ClientException(_("Bookmark not posted ".
 187                                                 "to this group."));
 188                 }
 189             } else if ($target instanceof User) {
 190                 $uri      = $target->uri;
 191                 $original = null;
 192                 if (!empty($activity->context->replyToID)) {
 193                     $original = Notice::staticGet('uri',
 194                                                   $activity->context->replyToID);
 195                 }
 196                 if (!in_array($uri, $activity->context->attention) &&
 197                     (empty($original) ||
 198                      $original->profile_id != $target->id)) {
 199                     throw new ClientException(_("Bookmark not posted ".
 200                                                 "to this user."));
 201                 }
 202             } else {
 203                 throw new ServerException(_("Don't know how to handle ".
 204                                             "this kind of target."));
 205             }
 206
 207             $actor = Ostatus_profile::ensureActivityObjectProfile($activity->actor);
 208
 209             $this->saveNoticeFromActivity($activity, $actor);
 210
 211             return false;
 212         }
 213
 214         return true;
 215     }
 216
 217     /**
 218      * Handle object posted via AtomPub
 219      *
 220      * @param Activity &$activity Activity that was posted
 221      * @param User     $user      User that posted it
 222      * @param Notice   &$notice   Resulting notice
 223      *
 224      * @return boolean hook value
 225      */
 226
 227     function onStartAtomPubNewActivity(&$activity, $user, &$notice)
 228     {
 229         if ($this->isMyActivity($activity)) {
 230
 231             $options = array('source' => 'atompub');
 232
 233             $this->saveNoticeFromActivity($activity,
 234                                           $user->getProfile(),
 235                                           $options);
 236
 237             return false;
 238         }
 239
 240         return true;
 241     }
 242
 243     /**
 244      * Handle object imported from a backup file
 245      *
 246      * @param User           $user     User to import for
 247      * @param ActivityObject $author   Original author per import file
 248      * @param Activity       $activity Activity to import
 249      * @param boolean        $trusted  Is this a trusted user?
 250      * @param boolean        &$done    Is this done (success or unrecoverable error)
 251      *
 252      * @return boolean hook value
 253      */
 254
 255     function onStartImportActivity($user, $author, $activity, $trusted, &$done)
 256     {
 257         if ($this->isMyActivity($activity)) {
 258
 259             $obj = $activity->objects[0];
 260
 261             $options = array('uri' => $bookmark->id,
 262                              'url' => $bookmark->link,
 263                              'source' => 'restore');
 264
 265             $saved = $this->saveNoticeFromActivity($activity,
 266                                                    $user->getProfile(),
 267                                                    $options);
 268
 269             if (!empty($saved)) {
 270                 $done = true;
 271             }
 272
 273             return false;
 274         }
 275
 276         return true;
 277     }
 278 }