path: root/Digitigrade/Model/Note.php

<?php
namespace Digitigrade\Model;

use Digitigrade\Db;
use Digitigrade\Model\HomeTimelineItem;
use Digitigrade\Notification\Notifyable;
use Digitigrade\Timeline\TimelineIncludeable;
use Digitigrade\Timeline\TimelineItem;

class Note extends PushableModel implements TimelineIncludeable, Notifyable {
    public ?int $id;
    public string $uri;
    public \DateTimeImmutable $created;
    public ?\DateTimeImmutable $modified;
    public Actor $author;
    public ?string $summary;
    public string $plainContent;
    // associative array mapping strings to strings - mimetypes to content
    public array $formattedContent = [];
    public string $language;
    /**
     * @var Actor[]
     */
    public array $mentions = [];
    public ?Note $inReplyTo;
    public ?Note $threadApex;
    public NotePrivacy $privacy;
    /**
     * @var NoteAttachment[]
     */
    public array $attachments = [];
    public array $extensions = [];

    /**
     * Creates and saves a new note with the specified fields pre-set
     * @param Actor $author who wrote the note
     * @param string $plainContent text of the note, without any markup
     * @param string $language ISO 639-3 3-letter language code
     * @param ?string $summary summary line or content warning
     * @param NotePrivacyScope $scope who is allowed to view this note
     * @param bool $indexable whether this note should be findable e.g. in search results
     * @return self
     */
    public static function create(
        Actor $author,
        string $plainContent,
        string $language,
        ?string $summary = null,
        NotePrivacyScope $scope = NotePrivacyScope::PUBLIC ,
        bool $indexable = true
    ): self {
        $note = new self();
        // can't set the note uri properly until it's been saved and we have an id
        $note->uri = "UNKNOWN";
        $note->created = new \DateTimeImmutable();
        $note->author = $author;
        $note->summary = $summary;
        $note->plainContent = $plainContent;
        $note->language = $language;
        $note->privacy = new NotePrivacy();
        $note->privacy->scope = $scope;
        $note->privacy->indexable = $indexable;

        $note->save();
        $note->uri = path_to_uri("/note/$note->id");
        $note->save();

        return $note;
    }

    protected function getUpdateWhereClause(\PDO $db): ?string {
        if (self::findWhere('uri = ?', [$this->uri]) != null)
            return 'uri = ' . $db->quote($this->uri);
        if (self::findWhere('id = ?', [$this->id]) != null)
            return "id = $this->id";
        return null;
    }

    protected function hydrate() {
        $this->privacy = NotePrivacy::findWhere('note_id = ?', [$this->id]);
        $this->formattedContent = $this->findFormattedContents();
        $this->mentions = $this->findMentions();
        $this->attachments = NoteAttachment::findAllWhere('note_id = ?', [$this->id]);
    }

    protected function validate(): bool {
        // author has to be from the same instance as the note itself
        return hostname_from_uri($this->author->uri) == hostname_from_uri($this->uri);
    }

    private function findFormattedContents(): array {
        $pdo = Db::getInstance()->getPdo();
        $stmt = $pdo->prepare('SELECT mimetype, body FROM note_formatted_content WHERE note_id = ?');
        $stmt->execute([$this->id]);
        return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    }

    private function findMentions(): array {
        $pdo = Db::getInstance()->getPdo();
        $stmt = $pdo->prepare('SELECT actor_id FROM note_mention WHERE note_id = ?');
        $stmt->execute([$this->id]);
        $actors = array_map(function ($actorId) {
            return Actor::find($actorId);
        }, $stmt->fetchAll(\PDO::FETCH_COLUMN, 0));
        return $actors;
    }

    public static function findAllWithAuthor(Actor $author, ?int $limit = null, int $offset = 0, bool $includeDeleted = false): array {
        $where = 'author = ?';
        if (!$includeDeleted) {
            $where .= ' AND deleted = false';
        }
        return self::findAllWhere($where, [$author->id], $limit, $offset, 'created DESC');
    }

    public static function countWithAuthor(Actor $author): int {
        return self::countWhere('author = ? AND deleted = false', [$author->id]);
    }

    public static function findAllInThread(Note $threadApex, ?int $limit = null, int $offset = 0): array {
        if (isset($limit))
            $limit--; // to account for adding the note afterwards
        $notes = self::findAllWhere('thread_apex = ? AND deleted = false', [$threadApex->id], $limit, $offset, 'created ASC');
        array_splice($notes, 0, 0, [$threadApex]); // since the apex itself has threadApex = null
        return $notes;
    }

    public function getInteractions(): array {
        return Interaction::findAllWithTarget($this);
    }

    public function countInteractionsOfKind(InteractionKind $kind): int {
        return Interaction::countWhere('target = ? AND kind = ? AND deleted = false', [$this->id, $kind->value]);
    }

    public function getInteractionsWithAuthor(Actor $author): array {
        return Interaction::findAllWhere('author = ? AND target = ? AND deleted = false', [$author->id, $this->id]);
    }

    public function countReplies(): int {
        return self::countWhere('in_reply_to = ? AND deleted = false', [$this->id]);
    }

    /**
     * @return Actor[] actors who this note can be seen by, are mentioned, etc
     */
    public function getRelevantActors(): array {
        return array_unique(array_merge(match ($this->privacy->scope) {
            NotePrivacyScope::NONE => [],
            NotePrivacyScope::MUTUALS => $this->author->findMutualFollows(),
            default => $this->author->findFollowers()
        }, $this->mentions, $this->privacy->alsoVisibleTo, [$this->author]));
    }

    public function getRelevantServers(): array {
        $recipientActors = $this->getRelevantActors();
        // reply-to and thread apex author should be covered by mentions but in case they're not:
        if (isset($this->inReplyTo))
            $recipientActors[] = $this->inReplyTo->author;
        if (isset($this->threadApex))
            $recipientActors[] = $this->threadApex->author;

        $recipientActors = array_unique($recipientActors);
        $instances = array_map(fn(Actor $a) => $a->isLocal ? null : $a->findHomeInstance(), $recipientActors);
        return array_unique(array_filter($instances, fn(?Instance $i) => $i != null));
    }

    public function isViewableBy(?UserAccount $viewer): bool {
        if ($this->privacy->scope == NotePrivacyScope::PUBLIC ) {
            return true;
        }
        if ($viewer == null) {
            return false;
        }
        return in_array($viewer->actor, $this->getRelevantActors());
    }

    /**
     * Gets this note's formatted content in the given mimetype or null if there isn't one
     * @param string $mimetype content type to return
     * @return ?string the marked up content
     */
    public function getFormattedContent(string $mimetype): ?string {
        return array_filter($this->formattedContent, fn($item) => $item['mimetype'] == $mimetype)[0]['body'] ?? null;
    }

    public function renderAsHtml() {
        render_template('note', ['note' => $this]);
    }

    public function toJsonReference(): mixed {
        return $this->id;
    }

    public static function fromJsonReference(mixed $reference): self {
        return self::find($reference);
    }

    public function getNotificationTitle(): string {
        // assuming that this notification is because the note is a reply for now
        return sprintf(__('notifications.interaction.reply.title'), $this->author->displayName);
    }
    public function getNotificationTitleLink(): ?string {
        return '/@/' . $this->author->getFullHandle() . '/note/' . $this->id;
    }
    public function getNotificationBody(): ?string {
        return $this->plainContent;
    }
    public function getNotificationImageUrl(): ?string {
        return $this->author->avatar;
    }
    public function getNotificationImageLink(): ?string {
        return '/@/' . $this->author->getFullHandle();
    }

    public function processNotifications() {
        foreach ($this->mentions as $a) {
            if (!$a->isLocal) {
                continue;
            }
            $user = UserAccount::findByLinkedActor($a);
            Notification::fromNotifyable($this, $user)->send();
        }
    }

    public function processTimelineAdditions() {
        $item = new TimelineItem($this);
        foreach ($this->getRelevantActors() as $actor) {
            if (!$actor->isLocal)
                continue;
            $user = UserAccount::findByLinkedActor($actor);
            HomeTimelineItem::fromTimelineItem($item, $user)->save();
        }
    }

    public function jsonSerialize(): array {
        if ($this->deleted) {
            return [
                'type' => 'tombstone',
                'self' => path_to_uri("/note/$this->id"),
                'previousType' => 'note'
            ];
        }
        return [
            'type' => 'note',
            'self' => path_to_uri("/note/$this->id"),
            'created' => $this->created->format('c'),
            'modified' => $this->modified?->format('c'),
            'author' => $this->author->uri,
            'summary' => $this->summary,
            'plainContent' => $this->plainContent,
            'formattedContent' => $this->formattedContent,
            'language' => $this->language,
            'mentions' => array_map(function (Actor $actor) {
                return $actor->uri;
            }, $this->mentions),
            'inReplyTo' => $this->inReplyTo?->uri,
            'threadApex' => $this->threadApex?->uri,
            'privacy' => $this->privacy,
            'attachments' => array_map(function (NoteAttachment $attachment) {
                return [
                    'type' => $attachment->type,
                    'href' => $attachment->href,
                    'description' => $attachment->description
                ];
            }, $this->attachments),
            //'extensions' => []
        ];
    }
}