datastore.h

/***************************************************************************
 *   Copyright (C) 2006 by Andreas Gungl <[email protected]>                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library 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 Library 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 DATASTORE_H
#define DATASTORE_H

#include <QObject>
#include <QList>
#include <QVector>
#include <QThreadStorage>
#include <QSqlDatabase>

class QSqlQuery;
class QTimer;

#include "entities.h"
#include "notificationcollector.h"

#include <memory>

namespace Akonadi
{
namespace Server
{

class DataStore;
class DataStoreFactory
{
public:
    virtual ~DataStoreFactory() = default;
    virtual DataStore *createStore() = 0;
};

class NotificationCollector;

class DataStore : public QObject
{
    Q_OBJECT
public:
    const constexpr static bool Silent = true;

    static void setFactory(std::unique_ptr<DataStoreFactory> factory);

    ~DataStore() override;

    virtual void open();

    void close();

    virtual bool init();

    static DataStore *self();

    static bool hasDataStore();

    /* --- ItemFlags ----------------------------------------------------- */
    virtual bool setItemsFlags(const PimItem::List &items, const QVector<Flag> &flags,
                               bool *flagsChanged = nullptr, const Collection &col = Collection(), bool silent = false);
    virtual bool appendItemsFlags(const PimItem::List &items, const QVector<Flag> &flags, bool *flagsChanged = nullptr,
                                  bool checkIfExists = true, const Collection &col = Collection(), bool silent = false);
    virtual bool removeItemsFlags(const PimItem::List &items, const QVector<Flag> &flags, bool *tagsChanged = nullptr,
                                  const Collection &collection = Collection(), bool silent = false);

    /* --- ItemTags ----------------------------------------------------- */
    virtual bool setItemsTags(const PimItem::List &items, const Tag::List &tags,
                              bool *tagsChanged = nullptr, bool silent = false);
    virtual bool appendItemsTags(const PimItem::List &items, const Tag::List &tags,
                                 bool *tagsChanged = nullptr, bool checkIfExists = true,
                                 const Collection &col = Collection(), bool silent = false);
    virtual bool removeItemsTags(const PimItem::List &items, const Tag::List &tags,
                                 bool *tagsChanged = nullptr, bool silent = false);
    virtual bool removeTags(const Tag::List &tags, bool silent = false);

    /* --- ItemParts ----------------------------------------------------- */
    virtual bool removeItemParts(const PimItem &item, const QSet<QByteArray> &parts);

    // removes all payload parts for this item.
    virtual bool invalidateItemCache(const PimItem &item);

    /* --- Collection ------------------------------------------------------ */
    virtual bool appendCollection(Collection &collection, const QStringList &mimeTypes, const QMap<QByteArray, QByteArray> &attributes);

    virtual bool cleanupCollection(Collection &collection);
    virtual bool cleanupCollection_slow(Collection &collection);

    virtual bool moveCollection(Collection &collection, const Collection &newParent);

    virtual bool appendMimeTypeForCollection(qint64 collectionId, const QStringList &mimeTypes);

    static QString collectionDelimiter()
    {
        return QStringLiteral("/");
    }

    virtual void activeCachePolicy(Collection &col);

    QVector<Collection> virtualCollections(const PimItem &item);

    QMap< Server::Entity::Id, QList< PimItem > > virtualCollections(const Akonadi::Server::PimItem::List &items);

    /* --- PimItem ------------------------------------------------------- */
    virtual bool appendPimItem(QVector<Part> &parts,
                               const QVector<Flag> &flags,
                               const MimeType &mimetype,
                               const Collection &collection,
                               const QDateTime &dateTime,
                               const QString &remote_id,
                               const QString &remoteRevision,
                               const QString &gid,
                               PimItem &pimItem);
    virtual bool cleanupPimItems(const PimItem::List &items, bool silent = false);

    virtual bool unhidePimItem(PimItem &pimItem);

    virtual bool unhideAllPimItems();

    /* --- Collection attributes ------------------------------------------ */
    virtual bool addCollectionAttribute(const Collection &col, const QByteArray &key,
                                        const QByteArray &value, bool silent = false);
    virtual bool removeCollectionAttribute(const Collection &col, const QByteArray &key);

    /* --- Helper functions ---------------------------------------------- */

    virtual bool beginTransaction(const QString &name);

    virtual bool rollbackTransaction();

    virtual bool commitTransaction();

    bool inTransaction() const;

    NotificationCollector *notificationCollector();

    QSqlDatabase database();

    void setSessionId(const QByteArray &sessionId)
    {
        mSessionId = sessionId;
    }

    bool isOpened() const
    {
        return m_dbOpened;
    }

    bool doRollback();
    void transactionKilledByDB();

Q_SIGNALS:
    void transactionCommitted();
    void transactionRolledBack();

protected:
    DataStore(AkonadiServer &akonadi);

    void debugLastDbError(const char *actionDescription) const;
    void debugLastQueryError(const QSqlQuery &query, const char *actionDescription) const;

private:
    bool doAppendItemsFlag(const PimItem::List &items, const Flag &flag,
                           const QSet<PimItem::Id> &existing, const Collection &col,
                           bool silent);

    bool doAppendItemsTag(const PimItem::List &items, const Tag &tag,
                          const QSet<Entity::Id> &existing, const Collection &col,
                          bool silent);

    static QString dateTimeFromQDateTime(const QDateTime &dateTime);

    static QDateTime dateTimeToQDateTime(const QByteArray &dateTime);

private Q_SLOTS:
    void sendKeepAliveQuery();

protected:
    static std::unique_ptr<DataStoreFactory> sFactory;
    std::unique_ptr<NotificationCollector> mNotificationCollector;
    AkonadiServer &m_akonadi;

private:
    void cleanupAfterRollback();
    QString m_connectionName;
    QSqlDatabase m_database;
    bool m_dbOpened;
    bool m_transactionKilledByDB = false;
    uint m_transactionLevel;
    struct TransactionQuery {
        QString query;
        QVector<QVariant> boundValues;
        bool isBatch;
    };
    QByteArray mSessionId;
    QTimer *m_keepAliveTimer = nullptr;
    static bool s_hasForeignKeyConstraints;

    friend class DataStoreFactory;

};

} // namespace Server
} // namespace Akonadi

#endif