plugins/ActivityModeration/ActivityModerationPlugin.php

   1 <?php
   2
   3 /**
   4  * @package     Activity
   5  * @maintainer  Mikael Nordfeldth <mmn@hethane.se>
   6  */
   7 class ActivityModerationPlugin extends ActivityVerbHandlerPlugin
   8 {
   9     public function tag()
  10     {
  11         return 'actmod';
  12     }
  13
  14     public function types()
  15     {
  16         return array();
  17     }
  18
  19     public function verbs()
  20     {
  21         return array(ActivityVerb::DELETE);
  22     }
  23
  24     public function onBeforePluginCheckSchema()
  25     {
  26         Deleted_notice::beforeSchemaUpdate();
  27         return true;
  28     }
  29
  30     public function onCheckSchema()
  31     {
  32         $schema = Schema::get();
  33         $schema->ensureTable('deleted_notice', Deleted_notice::schemaDef());
  34         return true;
  35     }
  36
  37     public function onGetNoticeSqlTimestamp($id, &$timestamp)
  38     {
  39         try {
  40             $deleted = Deleted_notice::getByID($id);
  41             $timestamp = $deleted->act_created;
  42         } catch (NoResultException $e) {
  43             return true;
  44         }
  45         // we're done for the event, so return false to stop it
  46         return false;
  47     }
  48
  49     public function onIsNoticeDeleted($id, &$deleted)
  50     {
  51         try {
  52             $found = Deleted_notice::getByID($id);
  53             $deleted = ($found instanceof Deleted_notice);
  54         } catch (NoResultException $e) {
  55             $deleted = false;
  56         }
  57         // return true (continue event) if $deleted is false, return false (stop event) if deleted notice was found
  58         return !$deleted;
  59     }
  60
  61     protected function getActionTitle(ManagedAction $action, $verb, Notice $target, Profile $scoped)
  62     {
  63         // FIXME: switch based on action type
  64         return _m('TITLE', 'Notice moderation');
  65     }
  66
  67     protected function doActionPreparation(ManagedAction $action, $verb, Notice $target, Profile $scoped)
  68     {
  69         // pass
  70     }
  71
  72     protected function doActionPost(ManagedAction $action, $verb, Notice $target, Profile $scoped)
  73     {
  74         switch (true) {
  75         case ActivityUtils::compareVerbs($verb, array(ActivityVerb::DELETE)):
  76             // do whatever preparation is necessary to delete a verb
  77             $target->delete();
  78             break;
  79         default:
  80             throw new ServerException('ActivityVerb POST not handled by plugin that was supposed to do it.');
  81         }
  82     }
  83
  84     public function deleteRelated(Notice $notice)
  85     {
  86         // pass
  87     }
  88
  89     public function onDeleteNoticeAsProfile(Notice $stored, Profile $actor, &$result) {
  90         // By adding a new 'delete' verb we will eventually trigger $this->saveObjectFromActivity
  91         if (false === Deleted_notice::addNew($stored, $actor)) {
  92             // false is returned if we did not have an error, but did not create the object
  93             // (i.e. the author is currently being deleted)
  94             return true;
  95         }
  96
  97         // We return false (to stop the event) if the deleted_notice entry was
  98         // added, which means we have run $this->saveObjectFromActivity which
  99         // in turn has called the delete function of the notice.
 100         return false;
 101     }
 102
 103     /**
 104      * This is run when a 'delete' verb activity comes in.
 105      *
 106      * @return boolean hook flag
 107      */
 108     protected function saveObjectFromActivity(Activity $act, Notice $stored, array $options=array())
 109     {
 110         // Everything is done in the StartNoticeSave event
 111         return true;
 112     }
 113
 114     // FIXME: Put this in lib/activityhandlerplugin.php when we're ready
 115     //          with the other microapps/activityhandlers as well.
 116     //          Also it should be StartNoticeAsActivity (with a prepped Activity, including ->context etc.)
 117     public function onEndNoticeAsActivity(Notice $stored, Activity $act, Profile $scoped=null)
 118     {
 119         if (!$this->isMyNotice($stored)) {
 120             return true;
 121         }
 122
 123         common_debug('Extending activity '.$stored->id.' with '.get_called_class());
 124         $this->extendActivity($stored, $act, $scoped);
 125         return false;
 126     }
 127
 128     /**
 129      * This is run before ->insert, so our task in this function is just to
 130      * delete if it is the delete verb.
 131      */
 132     public function onStartNoticeSave(Notice $stored)
 133     {
 134         // DELETE is a bit special, we have to remove the existing entry and then
 135         // add a new one with the same URI in order to trigger the distribution.
 136         // (that's why we don't use $this->isMyNotice(...))
 137         if (!ActivityUtils::compareVerbs($stored->verb, array(ActivityVerb::DELETE))) {
 138             return true;
 139         }
 140
 141         try {
 142             $target = Notice::getByUri($stored->uri);
 143         } catch (NoResultException $e) {
 144             throw new AlreadyFulfilledException('Notice URI not found, so we have nothing to delete.');
 145         }
 146
 147         $actor = $stored->getProfile();
 148         $owner = $target->getProfile();
 149
 150         if ($owner->hasRole(Profile_role::DELETED)) {
 151             // Don't bother with replacing notices if its author is being deleted.
 152             // The later "StoreActivityObject" will pick this up and execute
 153             // the deletion then.
 154             // (the "delete verb notice" is too new to ever pass through Notice::saveNew
 155             // which otherwise wouldn't execute the StoreActivityObject event)
 156             return true;
 157         }
 158
 159         // Since the user deleting may not be the same as the notice's owner,
 160         // double-check this and also set the "re-stored" notice profile_id.
 161         if (!$actor->sameAs($owner) && !$actor->hasRight(Right::DELETEOTHERSNOTICE)) {
 162             throw new AuthorizationException(_('You are not allowed to delete another user\'s notice.'));
 163         }
 164
 165         // We copy the identifying fields and replace the sensitive ones.
 166         //$stored->id = $target->id;    // We can't copy this since DB_DataObject won't inject it anyway
 167         $props = array('uri', 'profile_id', 'conversation', 'reply_to', 'created', 'repeat_of', 'object_type', 'is_local', 'scope');
 168         foreach($props as $prop) {
 169             $stored->$prop = $target->$prop;
 170         }
 171
 172         // Let's see if this has been deleted already.
 173         try {
 174             $deleted = Deleted_notice::getByKeys( ['uri' => $stored->getUri()] );
 175             return $deleted;
 176         } catch (NoResultException $e) {
 177             $deleted = new Deleted_notice();
 178
 179             $deleted->id            = $target->getID();
 180             $deleted->profile_id    = $actor->getID();
 181             $deleted->uri           = $stored->getUri();
 182             $deleted->act_created   = $stored->created;
 183             $deleted->created       = common_sql_now();
 184
 185             // throws exception on error
 186             $result = $deleted->insert();
 187         }
 188
 189         // Now we delete the original notice, leaving the id and uri free.
 190         $target->delete();
 191
 192         return true;
 193     }
 194
 195     public function extendActivity(Notice $stored, Activity $act, Profile $scoped=null)
 196     {
 197         Deleted_notice::extendActivity($stored, $act, $scoped);
 198     }
 199
 200     public function activityObjectFromNotice(Notice $notice)
 201     {
 202         $object = Deleted_notice::fromStored($notice);
 203         return $object->asActivityObject();
 204     }
 205
 206     protected function getActivityForm(ManagedAction $action, $verb, Notice $target, Profile $scoped)
 207     {
 208         if (!$scoped instanceof Profile || !($scoped->sameAs($target->getProfile()) || $scoped->hasRight(Right::DELETEOTHERSNOTICE))) {
 209             throw new AuthorizationException(_('You are not allowed to delete other user\'s notices'));
 210         }
 211         return DeletenoticeForm($action, array('notice'=>$target));
 212     }
 213 }