File indexing completed on 2024-04-21 04:59:27

 // SPDX-FileCopyrightText: 2022 Bharadwaj Raju <bharadwaj.raju777@protonmail.com>
 // SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-or-later OR LicenseRef-KDE-Accepted-GPL
 
 #include "linkpreviewer.h"
 
 #include <Quotient/connection.h>
 #include <Quotient/csapi/content-repo.h>
 #include <Quotient/events/roommessageevent.h>
 
 #include "neochatconfig.h"
 #include "neochatroom.h"
 #include "utils.h"
 
 using namespace Quotient;
 
 LinkPreviewer::LinkPreviewer(const NeoChatRoom *room, const Quotient::RoomMessageEvent *event)
     : QObject(nullptr)
     , m_currentRoom(room)
     , m_event(event)
     , m_loaded(false)
     , m_url(linkPreview(event))
 {
     connect(this, &LinkPreviewer::urlChanged, this, &LinkPreviewer::emptyChanged);
 
     if (m_event != nullptr && m_currentRoom != nullptr) {
         loadUrlPreview();
         connect(m_currentRoom, &NeoChatRoom::urlPreviewEnabledChanged, this, &LinkPreviewer::loadUrlPreview);
         // Make sure that we react to edits
         connect(m_currentRoom, &NeoChatRoom::replacedEvent, this, [this](const Quotient::RoomEvent *newEvent) {
             if (m_event->id() == newEvent->id()) {
                 m_event = eventCast<const Quotient::RoomMessageEvent>(newEvent);
                 m_url = linkPreview(m_event);
                 Q_EMIT urlChanged();
                 loadUrlPreview();
             }
         });
     }
     connect(NeoChatConfig::self(), &NeoChatConfig::ShowLinkPreviewChanged, this, &LinkPreviewer::loadUrlPreview);
 }
 
 bool LinkPreviewer::loaded() const
 {
     return m_loaded;
 }
 
 QString LinkPreviewer::title() const
 {
     return m_title;
 }
 
 QString LinkPreviewer::description() const
 {
     return m_description;
 }
 
 QUrl LinkPreviewer::imageSource() const
 {
     return m_imageSource;
 }
 
 QUrl LinkPreviewer::url() const
 {
     return m_url;
 }
 
 void LinkPreviewer::loadUrlPreview()
 {
     if (!m_currentRoom || !NeoChatConfig::showLinkPreview() || !m_currentRoom->urlPreviewEnabled()) {
         return;
     }
     if (m_url.scheme() == QStringLiteral("https")) {
         m_loaded = false;
         Q_EMIT loadedChanged();
 
         auto conn = m_currentRoom->connection();
         GetUrlPreviewJob *job = conn->callApi<GetUrlPreviewJob>(m_url);
 
         connect(job, &BaseJob::success, this, [this, job, conn]() {
             const auto json = job->jsonData();
             m_title = json["og:title"_ls].toString().trimmed();
             m_description = json["og:description"_ls].toString().trimmed().replace("\n"_ls, " "_ls);
 
             auto imageUrl = QUrl(json["og:image"_ls].toString());
             if (imageUrl.isValid() && imageUrl.scheme() == QStringLiteral("mxc")) {
                 m_imageSource = conn->makeMediaUrl(imageUrl);
             } else {
                 m_imageSource = QUrl();
             }
 
             m_loaded = true;
             Q_EMIT titleChanged();
             Q_EMIT descriptionChanged();
             Q_EMIT imageSourceChanged();
             Q_EMIT loadedChanged();
         });
     }
 }
 
 bool LinkPreviewer::empty() const
 {
     return m_url.isEmpty();
 }
 
 QUrl LinkPreviewer::linkPreview(const Quotient::RoomMessageEvent *event)
 {
     if (event == nullptr) {
         return {};
     }
 
     QString text;
     if (event->hasTextContent()) {
         auto textContent = static_cast<const Quotient::EventContent::TextContent *>(event->content());
         if (textContent) {
             text = textContent->body;
         } else {
             text = event->plainBody();
         }
     } else {
         text = event->plainBody();
     }
 
     auto data = text.remove(TextRegex::removeRichReply);
     auto linksMatch = TextRegex::url.globalMatch(data);
     while (linksMatch.hasNext()) {
         auto link = linksMatch.next().captured();
         if (!link.contains(QStringLiteral("matrix.to"))) {
             return QUrl(link);
         }
     }
     return {};
 }
 
 bool LinkPreviewer::hasPreviewableLinks(const Quotient::RoomMessageEvent *event)
 {
     return !linkPreview(event).isEmpty();
 }
 
 #include "moc_linkpreviewer.cpp"