extendedstorage.h

Go to the documentation of this file.

/*
  This file is part of the mkcal library.
 
  Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
  Contact: Alvaro Manera <alvaro.manera@nokia.com>
 
  This library 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 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
  Library General Public License for more details.
 
  You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to
  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  Boston, MA 02110-1301, USA.
*/
#ifndef MKCAL_EXTENDEDSTORAGE_H
#define MKCAL_EXTENDEDSTORAGE_H
 
#include "mkcal_export.h"
#include "extendedcalendar.h"
#include "notebook.h"
 
#include <calstorage.h>
#include <calendar.h>
 
#include <kdatetime.h>
 
namespace KCalCore {
class Incidence;
}
 
class MkcalTool;
 
namespace mKCal {
 
enum DBOperation {
    DBNone,
    DBInsert,
    DBUpdate,
    DBMarkDeleted,
    DBDelete,
    DBSelect
};
 
// Default alarm receiver is the organiser application.
const char *const DBusService = "com.nokia.organiser";
const char *const DBusInterface = "com.nokia.OrganiserAlarmIf";
const char *const DBusPath = "/";
const char *const DBusName = "alarm";
 
class MKCAL_EXPORT ExtendedStorage
    : public KCalCore::CalStorage, public KCalCore::Calendar::CalendarObserver
{
    Q_OBJECT
 
public:
 
    enum DeleteAction {
        MarkDeleted,
        PurgeDeleted
    };
 
    typedef QSharedPointer<ExtendedStorage> Ptr;
 
    explicit ExtendedStorage(const ExtendedCalendar::Ptr &cal, bool validateNotebooks = false);
 
    virtual ~ExtendedStorage();
 
    virtual bool open() = 0;
 
    virtual bool load() = 0;
 
    virtual bool load(const QString &uid, const KDateTime &recurrenceId = KDateTime()) = 0;
 
    virtual bool load(const QDate &date) = 0;
 
    virtual bool load(const QDate &start, const QDate &end) = 0;
 
    virtual bool loadSeries(const QString &uid) = 0;
 
    virtual bool loadNotebookIncidences(const QString &notebookUid) = 0;
 
    virtual bool loadJournals() = 0;
 
    virtual bool loadPlainIncidences() = 0;
 
    virtual bool loadRecurringIncidences() = 0;
 
    virtual bool loadGeoIncidences() = 0;
 
    virtual bool loadGeoIncidences(float geoLatitude, float geoLongitude,
                                   float diffLatitude, float diffLongitude) = 0;
 
    virtual bool loadAttendeeIncidences() = 0;
 
    // Smart Loading Functions //
 
    virtual int loadUncompletedTodos() = 0;
 
    virtual int loadCompletedTodos(bool hasDate, int limit, KDateTime *last) = 0;
 
    virtual int loadIncidences(bool hasDate, int limit, KDateTime *last) = 0;
 
    virtual int loadFutureIncidences(int limit, KDateTime *last) = 0;
 
    virtual int loadGeoIncidences(bool hasDate, int limit, KDateTime *last) = 0;
 
    virtual int loadUnreadInvitationIncidences() = 0;
 
    virtual int loadOldInvitationIncidences(int limit, KDateTime *last) = 0;
 
    virtual KCalCore::Person::List loadContacts() = 0;
 
    virtual int loadContactIncidences(const KCalCore::Person::Ptr &person,
                                      int limit, KDateTime *last) = 0;
 
    virtual int loadJournals(int limit, KDateTime *last) = 0;
 
    virtual bool purgeDeletedIncidences(const KCalCore::Incidence::List &list) = 0;
 
    virtual bool save() = 0;
 
    virtual bool save(DeleteAction deleteAction) = 0;
 
    virtual bool notifyOpened(const KCalCore::Incidence::Ptr &incidence) = 0;
 
    virtual bool cancel() = 0;
 
    virtual bool close() = 0;
 
    // Internal Calendar Listener Methods //
 
    virtual void calendarModified(bool modified, KCalCore::Calendar *calendar) = 0;
 
    virtual void calendarIncidenceAdded(const KCalCore::Incidence::Ptr &incidence) = 0;
 
    virtual void calendarIncidenceChanged(const KCalCore::Incidence::Ptr &incidence) = 0;
 
    virtual void calendarIncidenceDeleted(const KCalCore::Incidence::Ptr &incidence) = 0;
 
    virtual void calendarIncidenceAdditionCanceled(const KCalCore::Incidence::Ptr &incidence) = 0;
 
    // Synchronization Specific Methods //
 
    virtual bool insertedIncidences(KCalCore::Incidence::List *list,
                                    const KDateTime &after = KDateTime(),
                                    const QString &notebookUid = QString()) = 0;
 
    virtual bool modifiedIncidences(KCalCore::Incidence::List *list,
                                    const KDateTime &after = KDateTime(),
                                    const QString &notebookUid = QString()) = 0;
 
    virtual bool deletedIncidences(KCalCore::Incidence::List *list,
                                   const KDateTime &after = KDateTime(),
                                   const QString &notebookUid = QString()) = 0;
 
    virtual bool allIncidences(KCalCore::Incidence::List *list,
                               const QString &notebookUid = QString()) = 0;
 
    virtual bool duplicateIncidences(KCalCore::Incidence::List *list,
                                     const KCalCore::Incidence::Ptr &incidence,
                                     const QString &notebookUid = QString()) = 0;
 
    virtual KDateTime incidenceDeletedDate(const KCalCore::Incidence::Ptr &incidence) = 0;
 
    virtual int eventCount() = 0;
 
    virtual int todoCount() = 0;
 
    virtual int journalCount() = 0;
 
    // Observer Specific Methods //
 
    void registerObserver(ExtendedStorageObserver *observer);
 
    void unregisterObserver(ExtendedStorageObserver *observer);
 
    // Notebook Methods //
 
    bool addNotebook(const Notebook::Ptr &nb, bool signal = true);
 
    bool updateNotebook(const Notebook::Ptr &nb);
 
    bool deleteNotebook(const Notebook::Ptr &nb, bool onlyMemory = false);
 
    bool setDefaultNotebook(const Notebook::Ptr &nb);
 
    Notebook::Ptr defaultNotebook();
 
    Notebook::Ptr notebook(const QString &uid);
 
    Notebook::Ptr notebook(Notebook::List &list, const QString &uid);
 
    Notebook::List notebooks();
 
    void setValidateNotebooks(bool validateNotebooks);
 
    bool validateNotebooks();
 
    bool isValidNotebook(const QString &notebookUid);
 
    // Alarm Methods //
 
    KCalCore::Incidence::Ptr checkAlarm(const QString &uid, const QString &recurrenceId,
                                        bool loadAlways = false);
 
    Notebook::Ptr createDefaultNotebook(QString name = QString(),
                                        QString color = QString());
 
    virtual void virtual_hook(int id, void *data) = 0;
 
protected:
    virtual bool loadNotebooks() = 0;
    virtual bool reloadNotebooks() = 0;
    virtual bool modifyNotebook(const Notebook::Ptr &nb, DBOperation dbop,
                                bool signal = true) = 0;
 
    bool getLoadDates(const QDate &start, const QDate &end,
                      KDateTime &loadStart, KDateTime &loadEnd);
 
    void setLoadDates(const QDate &start, const QDate &end);
 
    void setModified(const QString &info);
    void setProgress(const QString &info);
    void setFinished(bool error, const QString &info);
 
    // These alarm methods are used to communicate with an external
    // daemon, like timed, to bind Incidence::Alarm with the system notification.
    void clearAlarms(const KCalCore::Incidence::Ptr &incidence);
    void clearAlarms(const KCalCore::Incidence::List &incidences);
    void clearAlarms(const QString &nname);
    void setAlarms(const KCalCore::Incidence::Ptr &incidence);
    void setAlarms(const KCalCore::Incidence::List &incidences);
    void resetAlarms(const KCalCore::Incidence::List &incidences);
    void resetAlarms(const KCalCore::Incidence::Ptr &incidence);
 
    bool isUncompletedTodosLoaded();
    void setIsUncompletedTodosLoaded(bool loaded);
 
    bool isCompletedTodosDateLoaded();
    void setIsCompletedTodosDateLoaded(bool loaded);
    bool isCompletedTodosCreatedLoaded();
    void setIsCompletedTodosCreatedLoaded(bool loaded);
 
    bool isJournalsLoaded();
    void setIsJournalsLoaded(bool loaded);
 
    bool isDateLoaded();
    void setIsDateLoaded(bool loaded);
    bool isCreatedLoaded();
    void setIsCreatedLoaded(bool loaded);
    bool isFutureDateLoaded();
    void setIsFutureDateLoaded(bool loaded);
 
    bool isGeoDateLoaded();
    void setIsGeoDateLoaded(bool loaded);
    bool isGeoCreatedLoaded();
    void setIsGeoCreatedLoaded(bool loaded);
 
    bool isUnreadIncidencesLoaded();
    void setIsUnreadIncidencesLoaded(bool loaded);
 
    bool isInvitationIncidencesLoaded();
    void setIsInvitationIncidencesLoaded(bool loaded);
 
    void clearLoaded();
 
private:
    //@cond PRIVATE
    Q_DISABLE_COPY(ExtendedStorage)
    class MKCAL_HIDE Private;
    Private *const d;
    //@endcond
 
    friend class ::MkcalTool;
};
 
}
 
#endif