X-Git-Url: https://git.sur5r.net/?p=minitube;a=blobdiff_plain;f=src%2Fytsearch.cpp;h=ea07412b50fc1d39a5ac6fe22f824dd27fd0c3db;hp=7274d89d44c193874ecf65c701842f3d88c7b03a;hb=533489a63a9716c645a11a99ca446978b20eedd0;hpb=994e6e5e95196b0e36c680b1fd496f12d71739c9

diff --git a/src/ytsearch.cpp b/src/ytsearch.cpp
index 7274d89..ea07412 100644
--- a/src/ytsearch.cpp
+++ b/src/ytsearch.cpp
@@ -20,143 +20,145 @@ $END_LICENSE */
 
 #include "ytsearch.h"
 #include "constants.h"
-#include "networkaccess.h"
+#include "http.h"
+#include "httputils.h"
 #include "searchparams.h"
 #include "video.h"
 #include "ytchannel.h"
 
-#ifdef APP_YT3
+#include "datautils.h"
+#include "mainwindow.h"
 #include "yt3.h"
 #include "yt3listparser.h"
-#include "datautils.h"
-#else
-#include "ytfeedreader.h"
-#endif
-#include "compatibility/qurlqueryhelper.h"
-
-namespace The {
-NetworkAccess* http();
-QHash<QString, QAction*>* globalActions();
-}
 
 namespace {
 
-QDateTime RFC3339fromString(const QString &s) {
-    return QDateTime::fromString(s, "yyyy-MM-ddThh:mm:ssZ");
-}
-
 QString RFC3339toString(const QDateTime &dt) {
-    return dt.toString("yyyy-MM-ddThh:mm:ssZ");
+    return dt.toString(QStringLiteral("yyyy-MM-ddThh:mm:ssZ"));
 }
-
 }
 
-YTSearch::YTSearch(SearchParams *searchParams, QObject *parent) :
-    PaginatedVideoSource(parent),
-    searchParams(searchParams) {
+YTSearch::YTSearch(SearchParams *searchParams, QObject *parent)
+    : PaginatedVideoSource(parent), searchParams(searchParams) {
     searchParams->setParent(this);
 }
 
-#ifdef APP_YT3
-
 void YTSearch::loadVideos(int max, int startIndex) {
     aborted = false;
 
     QUrl url = YT3::instance().method("search");
-    {
-        QUrlQueryHelper urlHelper(url);
-        urlHelper.addQueryItem("part", "snippet");
-        urlHelper.addQueryItem("type", "video");
-        urlHelper.addQueryItem("maxResults", QString::number(max));
-
-        if (startIndex > 1) {
-            if (maybeReloadToken(max, startIndex)) return;
-            urlHelper.addQueryItem("pageToken", nextPageToken);
-        }
 
-        // TODO interesting params
-        // urlHelper.addQueryItem("videoSyndicated", "true");
-        // urlHelper.addQueryItem("regionCode", "IT");
-        // urlHelper.addQueryItem("videoType", "movie");
+    QUrlQuery q(url);
+    q.addQueryItem("part", "snippet");
+    q.addQueryItem("type", "video");
+    q.addQueryItem("maxResults", QString::number(max));
 
-        if (!searchParams->keywords().isEmpty()) {
-            if (searchParams->keywords().startsWith("http://") ||
-                    searchParams->keywords().startsWith("https://")) {
-                urlHelper.addQueryItem("q", YTSearch::videoIdFromUrl(searchParams->keywords()));
-            } else urlHelper.addQueryItem("q", searchParams->keywords());
-        }
+    if (startIndex > 1) {
+        if (maybeReloadToken(max, startIndex)) return;
+        q.addQueryItem("pageToken", nextPageToken);
+    }
 
-        if (!searchParams->channelId().isEmpty())
-            urlHelper.addQueryItem("channelId", searchParams->channelId());
+    // TODO interesting params
+    // urlHelper.addQueryItem("videoSyndicated", "true");
+    // urlHelper.addQueryItem("regionCode", "IT");
+    // urlHelper.addQueryItem("videoType", "movie");
+
+    if (!searchParams->keywords().isEmpty()) {
+        if (searchParams->keywords().startsWith("http://") ||
+            searchParams->keywords().startsWith("https://")) {
+            q.addQueryItem("q", YTSearch::videoIdFromUrl(searchParams->keywords()));
+        } else
+            q.addQueryItem("q", searchParams->keywords());
+    }
 
-        switch (searchParams->sortBy()) {
-        case SearchParams::SortByNewest:
-            urlHelper.addQueryItem("order", "date");
-            break;
-        case SearchParams::SortByViewCount:
-            urlHelper.addQueryItem("order", "viewCount");
-            break;
-        case SearchParams::SortByRating:
-            urlHelper.addQueryItem("order", "rating");
-            break;
-        }
+    if (!searchParams->channelId().isEmpty())
+        q.addQueryItem("channelId", searchParams->channelId());
+
+    switch (searchParams->sortBy()) {
+    case SearchParams::SortByNewest:
+        q.addQueryItem("order", "date");
+        break;
+    case SearchParams::SortByViewCount:
+        q.addQueryItem("order", "viewCount");
+        break;
+    case SearchParams::SortByRating:
+        q.addQueryItem("order", "rating");
+        break;
+    }
 
-        switch (searchParams->duration()) {
-        case SearchParams::DurationShort:
-            urlHelper.addQueryItem("videoDuration", "short");
-            break;
-        case SearchParams::DurationMedium:
-            urlHelper.addQueryItem("videoDuration", "medium");
-            break;
-        case SearchParams::DurationLong:
-            urlHelper.addQueryItem("videoDuration", "long");
-            break;
-        }
+    switch (searchParams->duration()) {
+    case SearchParams::DurationShort:
+        q.addQueryItem("videoDuration", "short");
+        break;
+    case SearchParams::DurationMedium:
+        q.addQueryItem("videoDuration", "medium");
+        break;
+    case SearchParams::DurationLong:
+        q.addQueryItem("videoDuration", "long");
+        break;
+    }
 
-        switch (searchParams->time()) {
-        case SearchParams::TimeToday:
-            urlHelper.addQueryItem("publishedAfter", RFC3339toString(QDateTime::currentDateTimeUtc().addSecs(-60*60*24)));
-            break;
-        case SearchParams::TimeWeek:
-            urlHelper.addQueryItem("publishedAfter", RFC3339toString(QDateTime::currentDateTimeUtc().addSecs(-60*60*24*7)));
-            break;
-        case SearchParams::TimeMonth:
-            urlHelper.addQueryItem("publishedAfter", RFC3339toString(QDateTime::currentDateTimeUtc().addSecs(-60*60*24*30)));
-            break;
-        }
+    switch (searchParams->time()) {
+    case SearchParams::TimeToday:
+        q.addQueryItem("publishedAfter",
+                       RFC3339toString(QDateTime::currentDateTimeUtc().addSecs(-60 * 60 * 24)));
+        break;
+    case SearchParams::TimeWeek:
+        q.addQueryItem("publishedAfter",
+                       RFC3339toString(QDateTime::currentDateTimeUtc().addSecs(-60 * 60 * 24 * 7)));
+        break;
+    case SearchParams::TimeMonth:
+        q.addQueryItem("publishedAfter", RFC3339toString(QDateTime::currentDateTimeUtc().addSecs(
+                                                 -60 * 60 * 24 * 30)));
+        break;
+    }
 
-        if (searchParams->publishedAfter()) {
-            urlHelper.addQueryItem("publishedAfter", RFC3339toString(QDateTime::fromTime_t(searchParams->publishedAfter()).toUTC()));
-        }
+    if (searchParams->publishedAfter()) {
+        q.addQueryItem(
+                "publishedAfter",
+                RFC3339toString(QDateTime::fromTime_t(searchParams->publishedAfter()).toUTC()));
+    }
 
-        switch (searchParams->quality()) {
-        case SearchParams::QualityHD:
-            urlHelper.addQueryItem("videoDefinition", "high");
-            break;
-        }
+    switch (searchParams->quality()) {
+    case SearchParams::QualityHD:
+        q.addQueryItem("videoDefinition", "high");
+        break;
+    }
+
+    switch (searchParams->safeSearch()) {
+    case SearchParams::None:
+        q.addQueryItem("safeSearch", "none");
+        break;
+    case SearchParams::Strict:
+        q.addQueryItem("safeSearch", "strict");
+        break;
     }
 
+    url.setQuery(q);
+
     lastUrl = url;
 
     // qWarning() << "YT3 search" << url.toString();
-    QObject *reply = The::http()->get(url);
+    QObject *reply = HttpUtils::yt().get(url);
     connect(reply, SIGNAL(data(QByteArray)), SLOT(parseResults(QByteArray)));
-    connect(reply, SIGNAL(error(QNetworkReply*)), SLOT(requestError(QNetworkReply*)));
+    connect(reply, SIGNAL(error(QString)), SLOT(requestError(QString)));
 }
 
-void YTSearch::parseResults(QByteArray data) {
+void YTSearch::parseResults(const QByteArray &data) {
     if (aborted) return;
 
     YT3ListParser parser(data);
-    QList<Video*> videos = parser.getVideos();
-    suggestions = parser.getSuggestions();
+    const QVector<Video *> &videos = parser.getVideos();
 
     bool tryingWithNewToken = setPageToken(parser.getNextPageToken());
     if (tryingWithNewToken) return;
 
     if (name.isEmpty() && !searchParams->channelId().isEmpty()) {
         if (!videos.isEmpty()) {
-            name = videos.first()->channelTitle();
+            name = videos.at(0)->getChannelTitle();
+            if (!searchParams->keywords().isEmpty()) {
+                name += QLatin1String(": ") + searchParams->keywords();
+            }
         }
         emit nameChanged(name);
     }
@@ -168,117 +170,20 @@ void YTSearch::parseResults(QByteArray data) {
     loadVideoDetails(videos);
 }
 
-#else
-
-void YTSearch::loadVideos(int max, int startIndex) {
-    aborted = false;
-
-    QUrl url("http://gdata.youtube.com/feeds/api/videos/");
-    {
-        QUrlQueryHelper urlHelper(url);
-
-        urlHelper.addQueryItem("v", "2");
-        urlHelper.addQueryItem("max-results", QString::number(max));
-        urlHelper.addQueryItem("start-index", QString::number(startIndex));
-
-        if (!searchParams->keywords().isEmpty()) {
-            if (searchParams->keywords().startsWith("http://") ||
-                    searchParams->keywords().startsWith("https://")) {
-                urlHelper.addQueryItem("q", YTSearch::videoIdFromUrl(searchParams->keywords()));
-            } else urlHelper.addQueryItem("q", searchParams->keywords());
-        }
-
-        if (!searchParams->channelId().isEmpty())
-            urlHelper.addQueryItem("author", searchParams->channelId());
-
-        switch (searchParams->sortBy()) {
-        case SearchParams::SortByNewest:
-            urlHelper.addQueryItem("orderby", "published");
-            break;
-        case SearchParams::SortByViewCount:
-            urlHelper.addQueryItem("orderby", "viewCount");
-            break;
-        case SearchParams::SortByRating:
-            urlHelper.addQueryItem("orderby", "rating");
-            break;
-        }
-
-        switch (searchParams->duration()) {
-        case SearchParams::DurationShort:
-            urlHelper.addQueryItem("duration", "short");
-            break;
-        case SearchParams::DurationMedium:
-            urlHelper.addQueryItem("duration", "medium");
-            break;
-        case SearchParams::DurationLong:
-            urlHelper.addQueryItem("duration", "long");
-            break;
-        }
-
-        switch (searchParams->time()) {
-        case SearchParams::TimeToday:
-            urlHelper.addQueryItem("time", "today");
-            break;
-        case SearchParams::TimeWeek:
-            urlHelper.addQueryItem("time", "this_week");
-            break;
-        case SearchParams::TimeMonth:
-            urlHelper.addQueryItem("time", "this_month");
-            break;
-        }
-
-        switch (searchParams->quality()) {
-        case SearchParams::QualityHD:
-            urlHelper.addQueryItem("hd", "true");
-            break;
-        }
-
-    }
-    QObject *reply = The::http()->get(url);
-    connect(reply, SIGNAL(data(QByteArray)), SLOT(parseResults(QByteArray)));
-    connect(reply, SIGNAL(error(QNetworkReply*)), SLOT(requestError(QNetworkReply*)));
-}
-
-void YTSearch::parseResults(QByteArray data) {
-    if (aborted) return;
-
-    YTFeedReader reader(data);
-    QList<Video*> videos = reader.getVideos();
-    suggestions = reader.getSuggestions();
-
-    if (name.isEmpty() && !searchParams->channelId().isEmpty()) {
-        if (videos.isEmpty()) name = searchParams->channelId();
-        else {
-            name = videos.first()->channelTitle();
-            // also grab the userId
-            userId = videos.first()->channelId();
-        }
-        emit nameChanged(name);
-    }
-
-    emit gotVideos(videos);
-    emit finished(videos.size());
-}
-
-#endif
-
 void YTSearch::abort() {
     aborted = true;
 }
 
-const QStringList & YTSearch::getSuggestions() {
-    return suggestions;
-}
-
 QString YTSearch::getName() {
     if (!name.isEmpty()) return name;
     if (!searchParams->keywords().isEmpty()) return searchParams->keywords();
     return QString();
 }
 
-void YTSearch::requestError(QNetworkReply *reply) {
-    qWarning() << reply->errorString();
-    emit error(reply->errorString());
+void YTSearch::requestError(const QString &message) {
+    QString msg = message;
+    msg.remove(QRegularExpression("key=[^ &]+"));
+    emit error(msg);
 }
 
 QString YTSearch::videoIdFromUrl(const QString &url) {
@@ -289,10 +194,58 @@ QString YTSearch::videoIdFromUrl(const QString &url) {
     return QString();
 }
 
-QList<QAction*> YTSearch::getActions() {
-    QList<QAction*> channelActions;
-    if (searchParams->channelId().isEmpty())
-        return channelActions;
-    channelActions << The::globalActions()->value("subscribe-channel");
+QTime YTSearch::videoTimestampFromUrl(const QString &url) {
+    QTime res(0, 0);
+
+    // TODO: should we make this accept h/m/s in any order?
+    //       timestamps returned by youtube always seem to be
+    //       ordered.
+    QRegExp re = QRegExp(".*t=([0-9]*h)?([0-9]*m)?([0-9]*s)?.*");
+
+    if (!re.exactMatch(url)) {
+        return res;
+    }
+
+    const auto captured = re.capturedTexts();
+    for (const QString &str : captured) {
+        if (str.length() <= 1) continue;
+
+        QString truncated = str;
+        truncated.chop(1);
+
+        bool ok = false;
+        int value = truncated.toInt(&ok);
+        if (!ok) continue;
+        char unit = str.at(str.length() - 1).toLatin1();
+
+        switch (unit) {
+        case 'h':
+            value *= 60 * 60; // hours -> seconds
+            break;
+
+        case 'm':
+            value *= 60; // minutes -> seconds
+            break;
+
+        case 's':
+            break;
+
+        default:
+            continue;
+        }
+
+        res = res.addSecs(value);
+    }
+
+    return res;
+}
+
+const QList<QAction *> &YTSearch::getActions() {
+    static const QList<QAction *> channelActions = {
+            MainWindow::instance()->getAction("subscribeChannel")};
+    if (searchParams->channelId().isEmpty()) {
+        static const QList<QAction *> noActions;
+        return noActions;
+    }
     return channelActions;
 }