yourls-ui/yourlsclient.cpp

#include "yourlsclient.h"

#include <QJsonDocument>
#include <QJsonObject>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QUrlQuery>
#ifndef QT_NO_DEBUG
#include <QDebug>
#endif

/**
 * @brief Constructs the client.
 * @param parent QObject parent.
 */
YourlsClient::YourlsClient (QObject *parent)
  : QObject (parent)
  , m_networkAccessManager (new QNetworkAccessManager (this)) {
}

/**
 * @brief Requests a short URL from the YOURLS API.
 * @param settings API endpoint and signature.
 * @param longUrl Source URL to shorten.
 */
void YourlsClient::shortenUrl (const YourlsSettings &settings, const QUrl &longUrl) {
#ifndef QT_NO_DEBUG
  qDebug() << "[yourls] source URL:" << longUrl << "valid:" << longUrl.isValid()
           << "scheme:" << longUrl.scheme() << "host:" << longUrl.host();
#endif
  if (settings.apiUrl.trimmed().isEmpty()) {
    emit shortenFailed (QStringLiteral ("API URL is empty."));
    return;
  }

  if (settings.signature.trimmed().isEmpty()) {
    emit shortenFailed (QStringLiteral ("API signature is empty."));
    return;
  }

  if (!longUrl.isValid() || longUrl.scheme().isEmpty() || longUrl.host().isEmpty()) {
    emit shortenFailed (QStringLiteral ("Clipboard does not contain a valid URL."));
    return;
  }

  QUrl requestUrl (settings.apiUrl);
  if (!requestUrl.isValid()) {
    emit shortenFailed (QStringLiteral ("Configured API URL is invalid: %1").arg (settings.apiUrl));
    return;
  }

  QUrlQuery query;
  query.addQueryItem (QStringLiteral ("signature"), settings.signature);
  query.addQueryItem (QStringLiteral ("action"), QStringLiteral ("shorturl"));
  query.addQueryItem (QStringLiteral ("format"), QStringLiteral ("json"));
  query.addQueryItem (QStringLiteral ("url"),
                      QString::fromLatin1 (QUrl::toPercentEncoding (longUrl.toString (QUrl::FullyEncoded))));
  requestUrl.setQuery (query);

  QNetworkRequest request (requestUrl);
  request.setHeader (QNetworkRequest::UserAgentHeader, QStringLiteral ("yourls-ui/1.0"));

#ifndef QT_NO_DEBUG
  // Never log the request query: it contains the API signature.
  qDebug() << "[yourls] sending GET, endpoint:"
           << requestUrl.adjusted (QUrl::RemoveQuery | QUrl::RemoveFragment | QUrl::RemoveUserInfo)
           << "source URL:" << longUrl;
#endif
  QNetworkReply *reply = m_networkAccessManager->get (request);

  connect (reply, &QNetworkReply::finished, this, [this, reply, longUrl]() {
    const QByteArray body = reply->readAll();
#ifndef QT_NO_DEBUG
    qDebug() << "[yourls] response HTTP status:"
             << reply->attribute (QNetworkRequest::HttpStatusCodeAttribute)
             << "network error code:" << reply->error()
             << "response bytes:" << body.size();
#endif

    QJsonParseError parseError;
    const QJsonDocument jsonDocument = QJsonDocument::fromJson (body, &parseError);
    const QJsonObject object = jsonDocument.object();
    const QUrl existingShortUrl (object.value (QStringLiteral ("shorturl")).toString());
    const QUrl existingLongUrl (object.value (QStringLiteral ("url")).toObject()
                                  .value (QStringLiteral ("url")).toString());
    // YOURLS reports duplicate URLs as HTTP 400, but returns the existing link.
    if (reply->attribute (QNetworkRequest::HttpStatusCodeAttribute).toInt() == 400
        && object.value (QStringLiteral ("status")).toString() == QStringLiteral ("fail")
        && object.value (QStringLiteral ("code")).toString() == QStringLiteral ("error:url")
        && existingLongUrl == longUrl && existingShortUrl.isValid()
        && (existingShortUrl.scheme() == QStringLiteral ("https")
            || existingShortUrl.scheme() == QStringLiteral ("http"))
        && !existingShortUrl.host().isEmpty()) {
#ifndef QT_NO_DEBUG
      qDebug() << "[yourls] reusing existing short URL:" << existingShortUrl;
#endif
      reply->deleteLater();
      emit shortenSucceeded (existingShortUrl);
      return;
    }

    if (reply->error() != QNetworkReply::NoError) {
      const QString details = QStringLiteral ("Network error: %1\nHTTP status: %2\nResponse body:\n%3")
                              .arg (reply->errorString(),
                                    reply->attribute (QNetworkRequest::HttpStatusCodeAttribute).toString(),
                                    QString::fromUtf8 (body));
      reply->deleteLater();
      emit shortenFailed (details);
      return;
    }

#ifndef QT_NO_DEBUG
    qDebug() << "[yourls] JSON parse error:" << parseError.errorString()
             << "offset:" << parseError.offset << "is object:" << jsonDocument.isObject();
#endif
    if (parseError.error != QJsonParseError::NoError || !jsonDocument.isObject()) {
      const QString details = QStringLiteral ("Failed to parse YOURLS response as JSON: %1\nResponse body:\n%2")
                              .arg (parseError.errorString(), QString::fromUtf8 (body));
      reply->deleteLater();
      emit shortenFailed (details);
      return;
    }

    const QString status = object.value (QStringLiteral ("status")).toString();
    const QString shortUrlText = object.value (QStringLiteral ("shorturl")).toString();
#ifndef QT_NO_DEBUG
    qDebug() << "[yourls] API status:" << status
             << "code:" << object.value (QStringLiteral ("code")).toVariant()
             << "short URL:" << shortUrlText;
#endif

    if (status.compare (QStringLiteral ("success"), Qt::CaseInsensitive) != 0 || shortUrlText.isEmpty()) {
      QStringList details;
      details << QStringLiteral ("YOURLS returned an error.");
      if (object.contains (QStringLiteral ("message")))
        details << QStringLiteral ("Message: %1").arg (object.value (QStringLiteral ("message")).toString());
      if (object.contains (QStringLiteral ("code")))
        details << QStringLiteral ("Code: %1").arg (object.value (QStringLiteral ("code")).toVariant().toString());
      details << QStringLiteral ("Raw response:\n%1").arg (QString::fromUtf8 (body));
      reply->deleteLater();
      emit shortenFailed (details.join (QStringLiteral ("\n")));
      return;
    }

    const QUrl shortUrl (shortUrlText);
    if (!shortUrl.isValid() || shortUrl.host().isEmpty()
        || (shortUrl.scheme() != QStringLiteral ("https") && shortUrl.scheme() != QStringLiteral ("http"))) {
      reply->deleteLater();
      emit shortenFailed (QStringLiteral ("YOURLS returned an invalid short URL: %1").arg (shortUrlText));
      return;
    }

    reply->deleteLater();
    emit shortenSucceeded (shortUrl);
  });
}