gnu-social/plugins/DeleteNote/DeleteNote.php

258 lines
11 KiB
PHP

<?php
declare(strict_types = 1);
// {{{ License
// This file is part of GNU social - https://www.gnu.org/software/social
//
// GNU social is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU social is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with GNU social. If not, see <http://www.gnu.org/licenses/>.
// }}}
namespace Plugin\DeleteNote;
use ActivityPhp\Type\AbstractObject;
use App\Core\Cache;
use App\Core\DB;
use App\Core\Event;
use function App\Core\I18n\_m;
use App\Core\Modules\NoteHandlerPlugin;
use App\Core\Router;
use App\Entity\Activity;
use App\Entity\Actor;
use App\Entity\Note;
use App\Util\Common;
use App\Util\Exception\ClientException;
use DateTime;
use EventResult;
use Plugin\ActivityPub\Entity\ActivitypubActivity;
use Symfony\Component\HttpFoundation\Request;
/**
* Delete note plugin main class.
* Adds "delete this note" action to respective note if the user logged in is
* the author.
*
* @package GNUsocial
* @category DeleteNote
*
* @author Eliseu Amaro <mail@eliseuama.ro>
* @copyright 2021-2022 Free Software Foundation, Inc http://www.fsf.org
* @license https://www.gnu.org/licenses/agpl.html GNU AGPL v3 or later
*/
class DeleteNote extends NoteHandlerPlugin
{
public static function cacheKeys(int|Note $note_id): array
{
$note_id = \is_int($note_id) ? $note_id : $note_id->getId();
return [
'activity' => "deleted-note-activity-{$note_id}",
];
}
/**
* **Checks actor permissions for the DeleteNote action, deletes given Note
* and creates respective Activity and Notification**
*
* Ensures the given Actor has sufficient permissions to perform the
* deletion.
* If it does, **Undertaker** will carry on, spelling doom for
* the given Note and **everything related to it**
* - Replies and Conversation **are unaffected**, except for the fact that
* this Note no longer exists, of course
* - Replies to this Note **will** remain on the same Conversation, and can
* **still be seen** on that Conversation (potentially separated from a
* parent, this Note)
*
* Replies shouldn't be taken out of context in any additional way, and
* **Undertaker** only calls the methods necessary to accomplish the
* deletion of this Note. Not any other as collateral damage.
*
* Creates the **_delete_ (verb)** Activity, performed on the given **Note
* (object)**, by the given **Actor (subject)**. Launches the
* NewNotification Event, stating who dared to call Undertaker.
*
* @throws \App\Util\Exception\ClientException
* @throws \App\Util\Exception\ServerException
*/
private static function undertaker(Actor $actor, Note $note): Activity
{
// Check permissions
if (!$actor->canModerate($note->getActor())) {
throw new ClientException(_m('You don\'t have permissions to delete this note.'), 401);
}
// Undertaker believes the actor can terminate this note
$activity = $note->delete(actor: $actor, source: 'web');
Cache::delete(self::cacheKeys($note)['activity']);
// Undertaker successful
Event::handle('NewNotification', [$actor, $activity, $note->getAttentionTargets(), _m('{actor_id} deleted note {note_id}.', ['actor_id' => $actor->getId(), 'note_id' => $activity->getObjectId()])]);
return $activity;
}
/**
* Delegates **DeleteNote::undertaker** to delete the Note provided
*
* Checks whether the Note has already been deleted, only passing on the
* responsibility to undertaker if the Note wasn't.
*
* @throws \App\Util\Exception\ClientException
* @throws \App\Util\Exception\DuplicateFoundException
* @throws \App\Util\Exception\NotFoundException
* @throws \App\Util\Exception\ServerException
*/
public static function deleteNote(Note|int $note, Actor|int $actor, string $source = 'web'): ?Activity
{
$actor = \is_int($actor) ? Actor::getById($actor) : $actor;
$note = \is_int($note) ? Note::getById($note) : $note;
// Try to find if note was already deleted
if (\is_null(
Cache::get(
self::cacheKeys($note)['activity'],
fn () => DB::findOneBy(Activity::class, ['verb' => 'delete', 'object_type' => Note::schemaName(), 'object_id' => $note->getId()], return_null: true),
),
)) {
// If none found, then undertaker has a job to do
return self::undertaker($actor, $note);
} else {
return null;
}
}
/**
* Adds and connects the _delete_note_action_ route to
* Controller\DeleteNote::class
*/
public function onAddRoute(Router $r): EventResult
{
$r->connect(id: 'delete_note_action', uri_path: '/object/note/{note_id<\d+>}/delete', target: Controller\DeleteNote::class);
return Event::next;
}
/**
* **Catches AddExtraNoteActions Event**
*
* Adds an anchor link to the route _delete_note_action_ in the **Note card
* template**. More specifically, in the **note_actions block**.
*
* @throws \App\Util\Exception\DuplicateFoundException
* @throws \App\Util\Exception\NotFoundException
* @throws \App\Util\Exception\ServerException
*
* @params string[] $actions
*/
public function onAddExtraNoteActions(Request $request, Note $note, array &$actions): EventResult
{
if (\is_null($actor = Common::actor())) {
return Event::next;
}
if (
// Only add action if note wasn't already deleted!
\is_null(Cache::get(
self::cacheKeys($note)['activity'],
fn () => DB::findOneBy(Activity::class, ['verb' => 'delete', 'object_type' => Note::schemaName(), 'object_id' => $note->getId()], return_null: true),
))
// And has permissions
&& $actor->canModerate($note->getActor())) {
$delete_action_url = Router::url('delete_note_action', ['note_id' => $note->getId()]);
$query_string = $request->getQueryString();
if (\is_null($query_string)) {
return Event::next;
}
$delete_action_url .= '?from=' . mb_substr($query_string, 2);
$actions[] = [
'title' => _m('Delete note'),
'classes' => '',
'url' => $delete_action_url,
];
}
return Event::next;
}
// ActivityPub handling and processing for Delete note is below
/**
* ActivityPub Inbox handler for Delete activities
*
* @param Actor $actor Actor who authored the activity
* @param \ActivityPhp\Type\AbstractObject $type_activity Activity Streams 2.0 Activity
* @param mixed $type_object Activity's Object
* @param null|\Plugin\ActivityPub\Entity\ActivitypubActivity $ap_act Resulting ActivitypubActivity
*/
private function activitypub_handler(Actor $actor, AbstractObject $type_activity, mixed $type_object, ?ActivitypubActivity &$ap_act): EventResult
{
if ($type_activity->get('type') !== 'Delete'
|| !($type_object instanceof Note)) {
// Don't care about AbstractObject because we only want to delete objects we already have
return Event::next;
}
$activity = self::deleteNote($type_object, $actor, source: 'ActivityPub');
if (!\is_null($activity)) {
// Store ActivityPub Activity
$ap_act = \Plugin\ActivityPub\Entity\ActivitypubActivity::create([
'activity_id' => $activity->getId(),
'activity_uri' => $type_activity->get('id'),
'created' => new DateTime($type_activity->get('published') ?? 'now'),
'modified' => new DateTime(),
]);
DB::persist($ap_act);
}
return Event::stop;
}
/**
* Convert an Activity Streams 2.0 Delete into the appropriate Delete entities
*
* @param Actor $actor Actor who authored the activity
* @param \ActivityPhp\Type\AbstractObject $type_activity Activity Streams 2.0 Activity
* @param \ActivityPhp\Type\AbstractObject $type_object Activity Streams 2.0 Object
* @param null|\Plugin\ActivityPub\Entity\ActivitypubActivity $ap_act Resulting ActivitypubActivity
*/
public function onNewActivityPubActivity(Actor $actor, AbstractObject $type_activity, AbstractObject $type_object, ?ActivitypubActivity &$ap_act): EventResult
{
return $this->activitypub_handler($actor, $type_activity, $type_object, $ap_act);
}
/**
* Convert an Activity Streams 2.0 formatted activity with a known object into Entities
*
* @param Actor $actor Actor who authored the activity
* @param \ActivityPhp\Type\AbstractObject $type_activity Activity Streams 2.0 Activity
* @param mixed $type_object Object
* @param null|\Plugin\ActivityPub\Entity\ActivitypubActivity $ap_act Resulting ActivitypubActivity
*/
public function onNewActivityPubActivityWithObject(Actor $actor, AbstractObject $type_activity, mixed $type_object, ?ActivitypubActivity &$ap_act): EventResult
{
return $this->activitypub_handler($actor, $type_activity, $type_object, $ap_act);
}
/**
* Translate GNU social internal verb 'delete' to Activity Streams 2.0 'Delete'
*
* @param string $verb GNU social's internal verb
* @param null|string $gs_verb_to_activity_stream_two_verb Resulting Activity Streams 2.0 verb
*/
public function onGSVerbToActivityStreamsTwoActivityType(string $verb, ?string &$gs_verb_to_activity_stream_two_verb): EventResult
{
if ($verb === 'delete') {
$gs_verb_to_activity_stream_two_verb = 'Delete';
return Event::stop;
}
return Event::next;
}
}