]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - lib/microappplugin.php
0b02f5da52ea1d991c16ed7ff9d46b20d464451e
[quix0rs-gnu-social.git] / 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
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             $object = $activity->objects[0];
161
162             $options = array('uri' => $object->id,
163                              'url' => $object->link,
164                              'is_local' => Notice::REMOTE_OMB,
165                              'source' => 'ostatus');
166             
167             $this->saveNoticeFromActivity($activity, $actor);
168
169             return false;
170         }
171
172         return true;
173     }
174
175     /**
176      * Handle a posted object from Salmon
177      *
178      * @param Activity $activity activity to handle
179      * @param mixed    $target   user or group targeted
180      *
181      * @return boolean hook value
182      */
183
184     function onStartHandleSalmonTarget($activity, $target)
185     {
186         if ($this->isMyActivity($activity)) {
187
188             $this->log(LOG_INFO, "Checking {$activity->id} as a valid Salmon slap.");
189
190             if ($target instanceof User_group) {
191                 $uri = $target->getUri();
192                 if (!in_array($uri, $activity->context->attention)) {
193                     throw new ClientException(_("Bookmark not posted ".
194                                                 "to this group."));
195                 }
196             } else if ($target instanceof User) {
197                 $uri      = $target->uri;
198                 $original = null;
199                 if (!empty($activity->context->replyToID)) {
200                     $original = Notice::staticGet('uri', 
201                                                   $activity->context->replyToID); 
202                 }
203                 if (!in_array($uri, $activity->context->attention) &&
204                     (empty($original) ||
205                      $original->profile_id != $target->id)) {
206                     throw new ClientException(_("Object not posted ".
207                                                 "to this user."));
208                 }
209             } else {
210                 throw new ServerException(_("Don't know how to handle ".
211                                             "this kind of target."));
212             }
213
214             $actor = Ostatus_profile::ensureActivityObjectProfile($activity->actor);
215
216             $object = $activity->objects[0];
217
218             $options = array('uri' => $object->id,
219                              'url' => $object->link,
220                              'is_local' => Notice::REMOTE_OMB,
221                              'source' => 'ostatus');
222
223             $this->saveNoticeFromActivity($activity, $actor, $options);
224
225             return false;
226         }
227
228         return true;
229     }
230
231     /**
232      * Handle object posted via AtomPub
233      *
234      * @param Activity &$activity Activity that was posted
235      * @param User     $user      User that posted it
236      * @param Notice   &$notice   Resulting notice
237      *
238      * @return boolean hook value
239      */
240
241     function onStartAtomPubNewActivity(&$activity, $user, &$notice)
242     {
243         if ($this->isMyActivity($activity)) {
244
245             $options = array('source' => 'atompub');
246
247             $this->saveNoticeFromActivity($activity,
248                                           $user->getProfile(),
249                                           $options);
250
251             return false;
252         }
253
254         return true;
255     }
256
257     /**
258      * Handle object imported from a backup file
259      *
260      * @param User           $user     User to import for
261      * @param ActivityObject $author   Original author per import file
262      * @param Activity       $activity Activity to import
263      * @param boolean        $trusted  Is this a trusted user?
264      * @param boolean        &$done    Is this done (success or unrecoverable error)
265      *
266      * @return boolean hook value
267      */
268
269     function onStartImportActivity($user, $author, $activity, $trusted, &$done)
270     {
271         if ($this->isMyActivity($activity)) {
272
273             $obj = $activity->objects[0];
274
275             $options = array('uri' => $object->id,
276                              'url' => $object->link,
277                              'source' => 'restore');
278
279             $saved = $this->saveNoticeFromActivity($activity,
280                                                    $user->getProfile(),
281                                                    $options);
282
283             if (!empty($saved)) {
284                 $done = true;
285             }
286
287             return false;
288         }
289
290         return true;
291     }
292
293     function onStartShowEntryForms(&$tabs)
294     {
295         $tabs[$this->tag()] = $this->appTitle();
296         return true;
297     }
298
299     function onStartMakeEntryForm($tag, $out, &$form)
300     {
301         $this->log(LOG_INFO, "onStartMakeEntryForm() called for tag '$tag'");
302
303         if ($tag == $this->tag()) {
304             $form = $this->entryForm($out);
305             return false;
306         }
307
308         return true;
309     }
310 }