metalinker.h

Go to the documentation of this file.

/***************************************************************************
*   Copyright (C) 2009 Matthias Fuchs <mat69@gmx.net>                     *
*   Copyright (C) 2012 Aish Raj Dahal <dahalaishraj@gmail.com>            *
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
*   This program is distributed in the hope that it will be useful,       *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
*   GNU General Public License for more details.                          *
*                                                                         *
*   You should have received a copy of the GNU General Public License     *
*   along with this program; if not, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
***************************************************************************/


#ifndef Metalinker_H
#define Metalinker_H

#include <KIO/Job>
#include <KUrl>
#include <QDate>
#include <QDomElement>
#include <QtCore/QEventLoop>
#include <QtCore/QString>
#include <QtCore/QObject>

#ifdef HAVE_NEPOMUK
namespace Nepomuk2
{
    class Variant;
}
#endif //HAVE_NEPOMUK

namespace KGetMetalink
{

class DateConstruct
{
    public:
        DateConstruct()
          : negativeOffset(false)
        {
        }

        void setData(const QDateTime &dateTime, const QTime &timeZoneOffset = QTime(), bool negativeOffset = false);
        void setData(const QString &dateConstruct);

        void clear();

        bool isNull() const;
        bool isValid() const;

        QString toString() const;

        QDateTime dateTime;
        QTime timeZoneOffset;
        bool negativeOffset;
};

class UrlText
{
    public:
        UrlText() {};

        bool isEmpty() const {return name.isEmpty() && url.isEmpty();}

        void clear();

        QString name;
        KUrl url;
};

class CommonData
{
    public:
        CommonData() {}

        void load(const QDomElement &e);
        void save(QDomElement &e) const;

        void clear();

#ifdef HAVE_NEPOMUK

        QList<QPair<QUrl, Nepomuk2::Variant> > properties() const;
#endif //HAVE_NEPOMUK

        QString identity;
        QString version;
        QString description;
        QStringList oses;
        KUrl logo;
        QStringList languages;
        UrlText publisher;
        QString copyright;
};

class Metaurl
{
    public:
        Metaurl()
          : priority(0)
        {
        }

        bool operator<(const Metaurl &other) const;

        void load(const QDomElement &e);
        void save(QDomElement &e) const;

        bool isValid();

        void clear();

        QString type;

        uint priority;

        QString name;

        KUrl url;
};

class Url
{
    public:
        Url()
          : priority(0)
        {
        }

        bool operator<(const Url &other) const;

        void load(const QDomElement &e);
        void save(QDomElement &e) const;

        bool isValid();

        void clear();

        uint priority;

        QString location;

        KUrl url;
};

class Resources
{
    public:
        Resources() {}

        bool isValid() const {return !urls.isEmpty() || !metaurls.isEmpty();}

        void load(const QDomElement &e);
        void save(QDomElement &e) const;

        void clear();

        QList<Url> urls;
        QList<Metaurl> metaurls;
};

class Pieces
{
    public:
        Pieces()
          : length(0)
        {
        }

        void load(const QDomElement &e);
        void save(QDomElement &e) const;

        void clear();

        QString type;
        KIO::filesize_t length;
        QStringList hashes;
};

class Verification
{
    public:
        Verification() {}

        void load(const QDomElement &e);
        void save(QDomElement &e) const;

        void clear();

        QHash<QString, QString> hashes;
        QList<Pieces> pieces;
        QHash<QString, QString> signatures;
};

class File
{
    public:
        File()
          : size(0)
        {
        }

        void load(const QDomElement &e);
        void save(QDomElement &e) const;

        void clear();

        bool isValid() const;

        bool isValidNameAttribute() const;

#ifdef HAVE_NEPOMUK

        QList<QPair<QUrl, Nepomuk2::Variant> > properties() const;
#endif //HAVE_NEPOMUK

        QString name;
        Verification verification;
        KIO::filesize_t size;
        CommonData data;
        Resources resources;
};

class Files
{
    public:
        Files() {}

        bool isValid() const;

        void load(const QDomElement &e);
        void save(QDomElement &e) const;

// #ifdef HAVE_NEPOMUK//TODO wha this now?
//         /**
//          * Return all Nepomuk-properties that can be extracted of Files
//          * @Note only Files is being looked at, not each File it contains, so
//          * you only get the general metadata for all Files
//         */
//         QHash<QUrl, Nepomuk::Variant> properties() const;
// #endif //HAVE_NEPOMUK

        void clear();

        QList<File> files;
};

class Metalink
{
    public:
        Metalink()
          : dynamic(false)
        {
        }

        bool isValid() const;

        void load(const QDomElement &e);

        QDomDocument save() const;

        void clear();

        bool dynamic;
        QString xmlns; //the xmlns value is ignored when saving, instead the data format described in the specification is always used
        DateConstruct published; //when the metalink was published
        KUrl origin;
        QString generator;
        DateConstruct updated; //when the metalink was updated
        Files files;

        static const QString KGET_DESCRIPTION;
        static const uint MAX_URL_PRIORITY; //maximum pirority a Metalink 4.0 Url or Metaurl can have, not to be mixed up with the highest priority
};

class Metalink_v3
{
    public:
        Metalink_v3();

        Metalink metalink();
        void setMetalink(const Metalink &metalink);

        void load(const QDomElement &e);

        QDomDocument save() const;

    private:
        void parseFiles(const QDomElement &e);
        Resources parseResources(const QDomElement &e);
        DateConstruct parseDateConstruct(const QString &data);
        CommonData parseCommonData(const QDomElement &e);

        void inheritCommonData(const CommonData &ancestor, CommonData *inheritor);

        void saveFiles(QDomElement &e) const;
        void saveResources(const Resources &resources, QDomElement &e) const;
        void saveVerification(const Verification &verification, QDomElement &e) const;
        void saveCommonData(const CommonData &data, QDomElement &e) const;
        QString dateConstructToString(const DateConstruct &date) const;

    private:
        Metalink m_metalink;
        static const uint MAX_PREFERENCE;
};

class HandleMetalink
{
    public:
        static bool load(const KUrl &destination, Metalink *metalink);

        static bool load(const QByteArray &data, Metalink *metalink);

        static bool save(const KUrl &destination, Metalink *metalink);

#ifdef HAVE_NEPOMUK

        static void addProperty(QList<QPair<QUrl, Nepomuk2::Variant> > *data, const QByteArray &uriBa, const QString &value);
        static void addProperty(QList<QPair<QUrl, Nepomuk2::Variant> > *data, const QUrl &uri, const QString &value);
#endif //HAVE_NEPOMUK
};

class MetalinkHttpParser : public QObject
{
    Q_OBJECT
    public:
        MetalinkHttpParser(const KUrl& Url)
            : m_Url(Url), m_MetalinkHSatus(false) , m_EtagValue(QString(""))
        {
            checkMetalinkHttp();
        }

        ~MetalinkHttpParser();

        bool isMetalinkHttp();

        KUrl getUrl();
        QMultiMap<QString, QString>* getHeaderInfo();

        QString* getEtag();

    private slots:
        void slotHeaderResult(KJob* kjob);
        void checkMetalinkHttp();
        void detectMime(KIO::Job *  job, const QString &  type);
        void slotRedirection(KIO::Job*, const KUrl&);


    private:
        KUrl m_Url;
        KUrl m_redirectionUrl;
        bool m_MetalinkHSatus;
        QEventLoop m_loop;
        QMultiMap<QString, QString> m_headerInfo;
        QString m_EtagValue ;

        void parseHeaders(const QString&);

        void setMetalinkHSatus();

};

class HttpLinkHeader : public Metaurl
{
    public:
        HttpLinkHeader(const QString &headerLine);

        QString reltype;
        bool pref;
        int depth;
        QString geo;

        void parseHeaderLine(const QString &);

        bool operator<(const HttpLinkHeader &) const;
};

}

#endif // Metalinker_H