datamanagementmodel.h

Go to the documentation of this file.

/*
   This file is part of the Nepomuk KDE project.
   Copyright (C) 2010 Sebastian Trueg <trueg@kde.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) version 3, or any
   later version accepted by the membership of KDE e.V. (or its
   successor approved by the membership of KDE e.V.), which shall
   act as a proxy defined in Section 6 of version 3 of the license.

   This library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef DATAMANAGEMENTMODEL_H
#define DATAMANAGEMENTMODEL_H

#include "datamanagement.h"

#include <Soprano/FilterModel>

#include <QtCore/QDateTime>

namespace Nepomuk2 {

class ClassAndPropertyTree;
class ResourceMerger;
class SimpleResourceGraph;
class ResourceWatcherManager;
class TypeCache;

class DataManagementModel : public Soprano::FilterModel
{
    Q_OBJECT

public:
    DataManagementModel(ClassAndPropertyTree* tree, Soprano::Model* model, QObject *parent = 0);
    ~DataManagementModel();

    ResourceWatcherManager* resourceWatcherManager() const;

public Q_SLOTS:
    void addProperty(const QList<QUrl>& resources,
                     const QUrl& property,
                     const QVariantList& values,
                     const QString& app);

    void setProperty(const QList<QUrl>& resources,
                     const QUrl& property,
                     const QVariantList& values,
                     const QString& app);

    void removeProperty(const QList<QUrl>& resources,
                        const QUrl& property,
                        const QVariantList& values,
                        const QString& app);

    void removeProperties(const QList<QUrl>& resources,
                          const QList<QUrl>& properties,
                          const QString& app);

    QUrl createResource(const QList<QUrl>& types,
                        const QString& label,
                        const QString& description,
                        const QString& app);

    void removeResources(const QList<QUrl>& resources,
                         Nepomuk2::RemovalFlags flags,
                         const QString& app);

    void removeDataByApplication(const QList<QUrl>& resources,
                                 RemovalFlags flags,
                                 const QString& app);

    void removeDataByApplication(RemovalFlags flags,
                                 const QString& app);

    QHash<QUrl,QUrl> storeResources(const SimpleResourceGraph& resources,
                        const QString& app,
                        Nepomuk2::StoreIdentificationMode identificationMode = Nepomuk2::IdentifyNew,
                        Nepomuk2::StoreResourcesFlags flags = Nepomuk2::NoStoreResourcesFlags,
                        const QHash<QUrl, QVariant>& additionalMetadata = (QHash<QUrl, QVariant>()) );

    QHash<QUrl,QUrl> storeResources(const SimpleResourceGraph& resources,
                        const QString& app,
                        bool discardable,
                        Nepomuk2::StoreIdentificationMode identificationMode = Nepomuk2::IdentifyNew,
                        Nepomuk2::StoreResourcesFlags flags = Nepomuk2::NoStoreResourcesFlags);
    void mergeResources(const QList<QUrl>& resources, const QString& app);

    void importResources(const QUrl& url, const QString& app,
                         Soprano::RdfSerialization serialization,
                         const QString& userSerialization = QString(),
                         Nepomuk2::StoreIdentificationMode identificationMode = Nepomuk2::IdentifyNew,
                         Nepomuk2::StoreResourcesFlags flags = Nepomuk2::NoStoreResourcesFlags,
                         const QHash<QUrl, QVariant>& additionalMetadata = (QHash<QUrl, QVariant>()) );

    SimpleResourceGraph describeResources(const QList<QUrl>& resources,
                                          DescribeResourcesFlags flags = NoDescribeResourcesFlags,
                                          const QList<QUrl>& targetParties = QList<QUrl>() );

    QString exportResources(const QList<QUrl>& resources,
                            Soprano::RdfSerialization serialization,
                            const QString& userSerialization = QString(),
                            DescribeResourcesFlags flags = NoDescribeResourcesFlags,
                            const QList<QUrl>& targetParties = QList<QUrl>() );

    void clearCache();

    TypeCache* typeCache();

    QUrl nepomukGraph();
private:
    QUrl createNepomukGraph();
    QUrl createGraph(const QString& app, const QMultiHash<QUrl, Soprano::Node>& additionalMetadata);
    QUrl fetchGraph(const QString& app, bool discardable = false);

    QUrl findApplicationResource(const QString& app, bool create = true);

    Soprano::Error::ErrorCode updateModificationDate( const QUrl& resource,
                                                      const QDateTime& date = QDateTime::currentDateTime() );

    Soprano::Error::ErrorCode updateModificationDate( const QSet<QUrl>& resources,
                                                      const QDateTime& date = QDateTime::currentDateTime() );

    QHash<QUrl, QList<Soprano::Node> > addProperty(const QList<QUrl>& resources, const QUrl& property,
                                                   const QList<Soprano::Node>& nodes, const QString& app,
                                                   bool signalPropertyChanged = false);

    void removeAllResources(const QSet<QUrl>& resourceUris, RemovalFlags flags);

    bool doesResourceExist(const QUrl& res, const QUrl& graph = QUrl()) const;

    QUrl resolveUrl(const QUrl& url, bool statLocalFiles = false);

    QList<QUrl> resolveUrls(const QList< QUrl >& urls, const QString& app, bool statLocalFiles = true);

    QList<Soprano::Node> resolveNodes(const QSet<Soprano::Node>& nodes, const QString& app);

    QList<QUrl> createFileResources(const QList<QUrl>& nieUrls, const QUrl& graph);

    bool updateNieUrlOnLocalFile(const QUrl& resource, const QUrl& nieUrl);

    ClassAndPropertyTree * classAndPropertyTree();

    enum UriType {
        GraphUri,
        ResourceUri
    };
    QUrl createUri(UriType type);

    bool isProtectedProperty(const QUrl& prop) const;

    class Private;
    Private* const d;

    friend class ResourceMerger;
};
}

#endif