musicwyquerymovierequest.cpp

Go to the documentation of this file.

#include "musicwyquerymovierequest.h"

static constexpr const char *WY_MOVIE_URL = "dFowcHhjYXk3UWRkZlo2eW40NkY2TEU4VzRoMC84TFh4Wm93N1hCbWk5V21WQnZnYzIrVUhvYmVtK0xtUW90cGpidHBqdz09";
static constexpr const char *WY_MOVIE_DATA_URL = "dmt4VnNDdWErYjRYUXBnOWdubVBIQT09";
static constexpr const char *WY_VIDEO_INFO_URL = "VGVNaXVsNW9GSTA0d1VYMnFlRnhuVFoyd1BTV0U0Y1RMWGxON25tTlZ4S2lxSUthSFkvSXFOcFB1MjE1eG4xVFBhUXpITWVEZkVrbU5uNk0=";
static constexpr const char *WY_VIDEO_INFO_DATA_URL = "MTFxaHNCYnNQYnh5YWFMQUpadk9sWmRCY3FJPQ==";
static constexpr const char *WY_VIDEO_PATH_URL = "VjZLL2tEVlFnYjhQclRPMDVnblZiNmE4Q0NDMzBqa3ZaeStjallYbkdBbllYU2YxSWE0OFFIRXppVDRLeEtsM2g4OTROdz09";
static constexpr const char *WY_VIDEO_PATH_DATA_URL = "OE8vNmRpSVV6VXg4OGRKL0s5OStEdFQ4K1R2SGJlblZnSGljeVllZ1RQUW5ES1JONWIvdVhNSWdtZGc9";
static constexpr const char *WY_ARTIST_MOVIE_URL = "eFdablNDbDlZVzVvYlo4UU9waEFVRlluRUFzdXA4TXFzVE9RMllXWVdQUXE2WjlsRi9DMzc0VlNXQlU9";
static constexpr const char *WY_ARTIST_MOVIE_DATA_URL = "OE95dm9DdmtycVlzcnZaaWRhRFpHYjNBenl0bmFKM0ZLa1lVaFFVenBFQnZ5N2RoNE5VR3N5TzlDTitNTjFiUk9vdDZ4QndxSHY2QjVzcFlPM0laTlplUEt0bz0=";

namespace ReqWYInterface
{
    static void parseFromMovieProperty(QString &url, const QString &id, int bitrate);

}

void ReqWYInterface::parseFromMovieProperty(QString &url, const QString &id, int bitrate)
{
    QNetworkRequest request;
    const QByteArray &parameter = ReqWYInterface::makeTokenRequest(&request,
                      TTK::Algorithm::mdII(WY_VIDEO_PATH_URL, false),
                      TTK::Algorithm::mdII(WY_VIDEO_PATH_DATA_URL, false).arg(id).arg(bitrate));

    const QByteArray &bytes = TTK::syncNetworkQueryForPost(&request, parameter);
    if(bytes.isEmpty())
    {
        return;
    }

    QJsonParseError ok;
    const QJsonDocument &json = QJsonDocument::fromJson(bytes, &ok);
    if(QJsonParseError::NoError == ok.error)
    {
        QVariantMap value = json.toVariant().toMap();
        if(value["code"].toInt() == 200)
        {
            const QVariantList &datas = value["urls"].toList();
            for(const QVariant &var : qAsConst(datas))
            {
                if(var.isNull())
                {
                    continue;
                }

                value = var.toMap();
                url = value["url"].toString();

                if(!url.isEmpty())
                {
                    return;
                }
            }
        }
    }
}


MusicWYQueryMovieRequest::MusicWYQueryMovieRequest(QObject *parent)
    : MusicUnityQueryMovieRequest(parent)
{
    m_queryServer = QUERY_WY_INTERFACE;
}

void MusicWYQueryMovieRequest::startToPage(int offset)
{
    TTK_INFO_STREAM(metaObject()->className() << __FUNCTION__ << offset);

    if(needToUnity())
    {
        MusicUnityQueryMovieRequest::startToPage(offset);
        return;
    }

    deleteAll();
    m_totalSize = 0;
    m_pageIndex = offset;

    QNetworkRequest request;
    const QByteArray &parameter = ReqWYInterface::makeTokenRequest(&request,
                      TTK::Algorithm::mdII(WY_SEARCH_URL, false),
                      TTK::Algorithm::mdII(WY_SEARCH_DATA_URL, false).arg(1014).arg(m_queryValue).arg(m_pageSize * offset).arg(m_pageSize).toUtf8());

    m_reply = m_manager.post(request, parameter);
    connect(m_reply, SIGNAL(finished()), SLOT(downloadFinished()));
    QtNetworkErrorConnect(m_reply, this, replyError, TTK_SLOT);
}

void MusicWYQueryMovieRequest::startToSearch(const QString &value)
{
    resetUnity();
    MusicUnityQueryMovieRequest::startToSearch(value);
}

void MusicWYQueryMovieRequest::startToSearchByID(const QString &value)
{
    TTK_INFO_STREAM(metaObject()->className() << __FUNCTION__ << value);

    deleteAll();
    m_queryValue = value;

    TTK_SIGNLE_SHOT(downloadSingleFinished, TTK_SLOT);
}

void MusicWYQueryMovieRequest::downloadFinished()
{
    TTK_INFO_STREAM(metaObject()->className() << __FUNCTION__);

    MusicPageQueryRequest::downloadFinished();
    if(m_reply && m_reply->error() == QNetworkReply::NoError)
    {
        QJsonParseError ok;
        const QJsonDocument &json = QJsonDocument::fromJson(m_reply->readAll(), &ok);
        if(QJsonParseError::NoError == ok.error)
        {
            QVariantMap value = json.toVariant().toMap();
            if(value["code"].toInt() == 200)
            {
                value = value["result"].toMap();
                m_totalSize = value["videoCount"].toInt();

                const QVariantList &datas = value["videos"].toList();
                for(const QVariant &var : qAsConst(datas))
                {
                    if(var.isNull())
                    {
                        continue;
                    }

                    value = var.toMap();
                    TTK_NETWORK_QUERY_CHECK();

                    const int type = value["type"].toInt();
                    if(type == 0)
                    {
                        const qint64 vid = value["vid"].toLongLong();
                        if(vid == 0)
                        {
                            continue;
                        }

                        TTK_NETWORK_QUERY_CHECK();
                        parseFromMovieList(vid);
                        TTK_NETWORK_QUERY_CHECK();
                    }
                    else if(type == 1)
                    {
                        TTK_NETWORK_QUERY_CHECK();
                        parseFromVideoList(value["vid"].toString());
                        TTK_NETWORK_QUERY_CHECK();
                    }
                }
            }
        }
    }

    if(!pageValid())
    {
        setToUnity();
    }

    Q_EMIT downloadDataChanged({});
    deleteAll();
}

void MusicWYQueryMovieRequest::downloadSingleFinished()
{
    TTK_INFO_STREAM(metaObject()->className() << __FUNCTION__);

    MusicQueryMovieRequest::downloadFinished();

    const qint64 vid = m_queryValue.toLongLong();
    if(vid != 0)
    {
        TTK_NETWORK_QUERY_CHECK();
        parseFromMovieList(vid);
        TTK_NETWORK_QUERY_CHECK();
    }

    Q_EMIT downloadDataChanged({});
    deleteAll();
}

void MusicWYQueryMovieRequest::parseFromMovieList(qint64 id)
{
    QNetworkRequest request;
    const QByteArray &parameter = ReqWYInterface::makeTokenRequest(&request,
                      TTK::Algorithm::mdII(WY_MOVIE_URL, false),
                      TTK::Algorithm::mdII(WY_MOVIE_DATA_URL, false).arg(id));

    const QByteArray &bytes = TTK::syncNetworkQueryForPost(&request, parameter);
    if(bytes.isEmpty())
    {
        return;
    }

    QJsonParseError ok;
    const QJsonDocument &json = QJsonDocument::fromJson(bytes, &ok);
    if(QJsonParseError::NoError == ok.error)
    {
        QVariantMap value = json.toVariant().toMap();
        if(value["code"].toInt() == 200)
        {
            value = value["data"].toMap();
            TTK_NETWORK_QUERY_CHECK();

            TTK::MusicSongInformation info;
            info.m_songId = QString::number(id);
            info.m_songName = TTK::String::charactersReplace(value["name"].toString());

            info.m_artistName = ReqWYInterface::makeSongArtist(info.m_artistName, value["artistName"].toString());

            info.m_coverUrl = value["cover"].toString();
            info.m_duration = TTKTime::formatDuration(value["duration"].toInt());

            value = value["brs"].toMap();
            for(const QString &key : value.keys())
            {
                const int bitrate = key.toInt();
                TTK::MusicSongProperty prop;
                if(bitrate <= 375)
                {
                    prop.m_bitrate = TTK_BN_250;
                }
                else if(bitrate > 375 && bitrate <= 625)
                {
                    prop.m_bitrate = TTK_BN_500;
                }
                else if(bitrate > 625 && bitrate <= 875)
                {
                    prop.m_bitrate = TTK_BN_750;
                }
                else if(bitrate > 875)
                {
                    prop.m_bitrate = TTK_BN_1000;
                }

                prop.m_url = value[key].toString();
                prop.m_format = TTK::String::splitToken(prop.m_url);

                if(!fetchUrlPathSize(&prop, info.m_duration))
                {
                    continue;
                }

                info.m_songProps.append(prop);
            }

            if(info.m_songProps.isEmpty())
            {
                return;
            }

            Q_EMIT createResultItem({info, serverToString()});
            m_items << info;
        }
    }
}

void MusicWYQueryMovieRequest::parseFromVideoList(const QString &id)
{
    QNetworkRequest request;
    const QByteArray &parameter = ReqWYInterface::makeTokenRequest(&request,
                      TTK::Algorithm::mdII(WY_VIDEO_INFO_URL, false),
                      TTK::Algorithm::mdII(WY_VIDEO_INFO_DATA_URL, false).arg(id));

    const QByteArray &bytes = TTK::syncNetworkQueryForPost(&request, parameter);
    if(bytes.isEmpty())
    {
        return;
    }

    QJsonParseError ok;
    const QJsonDocument &json = QJsonDocument::fromJson(bytes, &ok);
    if(QJsonParseError::NoError == ok.error)
    {
        QVariantMap value = json.toVariant().toMap();
        if(value["code"].toInt() == 200)
        {
            value = value["data"].toMap();
            TTK_NETWORK_QUERY_CHECK();

            TTK::MusicSongInformation info;
            info.m_songId = id;
            info.m_songName = TTK::String::charactersReplace(value["title"].toString());

            const QVariantMap &artistObject = value["creator"].toMap();
            info.m_artistName = ReqWYInterface::makeSongArtist(info.m_artistName, artistObject["nickname"].toString());

            info.m_coverUrl = value["cover"].toString();
            info.m_duration = TTKTime::formatDuration(value["durationms"].toInt());

            const QVariantList &datas = value["resolutions"].toList();
            for(const QVariant &var : qAsConst(datas))
            {
                if(var.isNull())
                {
                    continue;
                }

                value = var.toMap();
                TTK_NETWORK_QUERY_CHECK();

                const int bitrate = value["resolution"].toInt();
                TTK::MusicSongProperty prop;
                ReqWYInterface::parseFromMovieProperty(prop.m_url, id, bitrate);
                TTK_NETWORK_QUERY_CHECK();

                if(prop.isEmpty())
                {
                    continue;
                }

                if(bitrate <= 375)
                {
                    prop.m_bitrate = TTK_BN_250;
                }
                else if(bitrate > 375 && bitrate <= 625)
                {
                    prop.m_bitrate = TTK_BN_500;
                }
                else if(bitrate > 625 && bitrate <= 875)
                {
                    prop.m_bitrate = TTK_BN_750;
                }
                else if(bitrate > 875)
                {
                    prop.m_bitrate = TTK_BN_1000;
                }

                prop.m_size = TTK::Number::sizeByteToLabel(value["size"].toInt());
                prop.m_format = TTK::String::splitToken(prop.m_url);
                info.m_songProps.append(prop);
            }

            if(info.m_songProps.isEmpty())
            {
                return;
            }

            Q_EMIT createResultItem({info, serverToString()});
            m_items << info;
        }
    }
}



MusicWYQueryArtistMovieRequest::MusicWYQueryArtistMovieRequest(QObject *parent)
    : MusicQueryMovieRequest(parent)
{
    m_pageSize = TTK_PAGE_SIZE_12;
    m_queryServer = QUERY_WY_INTERFACE;
}

void MusicWYQueryArtistMovieRequest::startToPage(int offset)
{
    TTK_INFO_STREAM(metaObject()->className() << __FUNCTION__ << offset);

    deleteAll();
    m_totalSize = 0;
    m_pageIndex = offset;

    QNetworkRequest request;
    const QByteArray &parameter = ReqWYInterface::makeTokenRequest(&request,
                      TTK::Algorithm::mdII(WY_ARTIST_MOVIE_URL, false),
                      TTK::Algorithm::mdII(WY_ARTIST_MOVIE_DATA_URL, false).arg(m_queryValue).arg(m_pageSize * offset).arg(m_pageSize));

    m_reply = m_manager.post(request, parameter);
    connect(m_reply, SIGNAL(finished()), SLOT(downloadFinished()));
    QtNetworkErrorConnect(m_reply, this, replyError, TTK_SLOT);
}

void MusicWYQueryArtistMovieRequest::downloadFinished()
{
    TTK_INFO_STREAM(metaObject()->className() << __FUNCTION__);

    MusicPageQueryRequest::downloadFinished();
    if(m_reply && m_reply->error() == QNetworkReply::NoError)
    {
        QJsonParseError ok;
        const QJsonDocument &json = QJsonDocument::fromJson(m_reply->readAll(), &ok);
        if(QJsonParseError::NoError == ok.error)
        {
            QVariantMap value = json.toVariant().toMap();
            if(value["code"].toInt() == 200 && value.contains("mvs"))
            {
                TTK_NETWORK_QUERY_CHECK();
                parseFromArtistMoviesCount(m_queryValue.toLongLong());
                TTK_NETWORK_QUERY_CHECK();

                const QVariantList &datas = value["mvs"].toList();
                for(const QVariant &var : qAsConst(datas))
                {
                    if(var.isNull())
                    {
                        continue;
                    }

                    value = var.toMap();
                    TTK_NETWORK_QUERY_CHECK();

                    MusicResultDataItem item;
                    item.m_id = value["id"].toString();
                    item.m_name = value["name"].toString();
                    item.m_coverUrl = value["imgurl"].toString();
                    item.m_time.clear();
                    Q_EMIT createMovieItem(item);
                }
            }
        }
    }

    Q_EMIT downloadDataChanged({});
    deleteAll();
}

void MusicWYQueryArtistMovieRequest::parseFromArtistMoviesCount(qint64 id)
{
    m_totalSize = TTK_HIGH_LEVEL;

    QNetworkRequest request;
    const QByteArray &parameter = ReqWYInterface::makeTokenRequest(&request,
                      TTK::Algorithm::mdII(WY_ARTIST_MOVIE_URL, false),
                      TTK::Algorithm::mdII(WY_ARTIST_MOVIE_DATA_URL, false).arg(id).arg(0).arg(m_totalSize));

    const QByteArray &bytes = TTK::syncNetworkQueryForPost(&request, parameter);
    if(bytes.isEmpty())
    {
        return;
    }

    QJsonParseError ok;
    const QJsonDocument &json = QJsonDocument::fromJson(bytes, &ok);
    if(QJsonParseError::NoError == ok.error)
    {
        const QVariantMap &value = json.toVariant().toMap();
        if(value["code"].toInt() == 200 && value.contains("mvs"))
        {
            m_totalSize = value["mvs"].toList().count();
        }
    }
}