gnu-social/plugins/DeleteNote/DeleteNote.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;
    }
}