CalDAVStorage.hpp

Go to the documentation of this file.

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef CARDDAV_H_
#define CARDDAV_H_

#include <plugin/storage/CalendarStorage.hpp>
#include <list>
#include "helpers/Http.hpp"
#include "CalDAVHelper.hpp"

class CalDAVStorageItemIterator;

class CalDAVStorage : public OpenAB_Storage::CalendarStorage
{
  public:
    CalDAVStorage(const std::string& url,
                  const std::string& login,
                  const OpenAB::SecureString& password,
                  const std::string& calendarURL,
                  const std::string& calendarName,
                  OpenAB::PIMItemType type);

    CalDAVStorage(const std::string& url,
                  const std::string& clientId,
                  const OpenAB::SecureString& clientSecret,
                  const OpenAB::SecureString& refreshToken,
                  const std::string& calendarURL,
                  const std::string& calendarName,
                  OpenAB::PIMItemType type);

    virtual ~CalDAVStorage();

    enum OpenAB_Source::Source::eInit init();

    enum OpenAB_Source::Source::eGetItemRet getItem(OpenAB::SmartPtr<OpenAB::PIMItem> & item);

    enum OpenAB_Source::Source::eSuspendRet suspend();

    enum OpenAB_Source::Source::eResumeRet resume();

    enum OpenAB_Source::Source::eCancelRet cancel();

    int getTotalCount() const;

    enum eAddItem addObject( const std::string& iCal,
                             OpenAB::PIMItem::ID& newId,
                             OpenAB::PIMItem::Revision& revision);

    enum eAddItem addObjects( const std::vector<std::string> &iCals,
                              OpenAB::PIMItem::IDs& newIds,
                              OpenAB::PIMItem::Revisions& revisions);

    enum eModifyItem modifyObject( const std::string& iCal,
                                   const OpenAB::PIMItem::ID& id,
                                   OpenAB::PIMItem::Revision& revision);

    enum eModifyItem modifyObjects( const std::vector<std::string> &iCals,
                                    const OpenAB::PIMItem::IDs& ids,
                                    OpenAB::PIMItem::Revisions& revisions);

    enum eRemoveItem removeObject( const OpenAB::PIMItem::ID& id);

    enum eRemoveItem removeObjects( const OpenAB::PIMItem::IDs& ids);

    enum eGetItem getEvent (const OpenAB::PIMItem::ID & id,
                            OpenAB::SmartPtr<OpenAB::PIMCalendarEventItem> & item);

    enum eGetItem getEvents(const OpenAB::PIMItem::IDs & ids,
                            std::vector<OpenAB::SmartPtr<OpenAB::PIMCalendarEventItem> > & items);

    enum eGetItem getTask (const OpenAB::PIMItem::ID & id,
                           OpenAB::SmartPtr<OpenAB::PIMCalendarTaskItem> & item);

    enum eGetItem getTasks(const OpenAB::PIMItem::IDs & ids,
                           std::vector<OpenAB::SmartPtr<OpenAB::PIMCalendarTaskItem> > & items);


    enum OpenAB_Storage::Storage::eGetRevisions getRevisions(std::map<std::string, std::string>& revisions);

    enum OpenAB_Storage::Storage::eGetRevisions getChangedRevisions(const std::string& token,
                                                                 std::map<std::string, std::string>& revisions,
                                                                 std::vector<OpenAB::PIMItem::ID>& removed);

    enum OpenAB_Storage::Storage::eGetSyncToken getLatestSyncToken(std::string& token);

    OpenAB_Storage::StorageItemIterator* newStorageItemIterator();

  private:
    CalDAVStorage(CalDAVStorage const &other);

    CalDAVStorage& operator=(CalDAVStorage const &other);

    void construct();

    void cleanup();

    bool selectFirstCalendar(const CalDAVHelper::Calendars cals,
                             CalDAVHelper::CalendarInfo& selectedCalendar);

    std::string       serverUrl;
    std::string       calendarUrl;
    std::string       calendarName;

    std::string       userLogin;
    OpenAB::SecureString userPassword;

    std::string       clientId;
    OpenAB::SecureString clientSecret;
    OpenAB::SecureString refreshToken;

    std::string syncToken;

    CalDAVHelper::CalendarInfo calendarInfo;

    OpenAB::HttpSession curlSession;
    OpenAB::HttpAuthorizer* authorizer;
    CalDAVHelper* calDavHelper;
    CalDAVStorageItemIterator* sourceIterator;
};

class CalDAVStorageItemIterator : public OpenAB_Storage::StorageItemIterator
{
  public:
    CalDAVStorageItemIterator();

    virtual ~CalDAVStorageItemIterator();

    enum eCursorInit{
      eCursorInitOK,
      eCursorInitFail
    };
    enum eCursorInit cursorInit(CalDAVHelper* calDAVHelper,
                                const std::string& calendarURL,
                                OpenAB::PIMItemType type);

    OpenAB_Storage::StorageItem* next();

    OpenAB_Storage::StorageItem  operator*();
    OpenAB_Storage::StorageItem* operator->();

    unsigned int getSize() const;

    /*OpenAB_Source::Source::eSuspendRet suspend();
    OpenAB_Source::Source::eResumeRet resume();
    OpenAB_Source::Source::eCancelRet cancel();*/

  private:
    CalDAVStorageItemIterator(CalDAVStorageItemIterator const &other);

    CalDAVStorageItemIterator& operator=(CalDAVStorageItemIterator const &other);

    enum eFetchEvents {
      eFetchEventsOK,
      eFetchEventsEND,
      eFetchEventsFail
    };
    enum eFetchEvents fetchEvents(int fetchsize);

    static void* downloadThreadFunc(void* ptr);
    bool downloadICals(unsigned int offset, unsigned int size);

    OpenAB_Storage::StorageItem    elem;
    CalDAVHelper*               calDavHelper;
    std::string                 calendarURL;

    unsigned                    total;
    unsigned int                offset;
    unsigned int                offsetOfCachedICals;

    std::list<OpenAB::SmartPtr<OpenAB::PIMCalendarItem> >  cachedEvents;
    std::vector<CalDAVHelper::EventMetadata> eventsMetadata;

    bool                 paused;
    bool                 cancelled;
    bool                 threadCreated;
    pthread_t            downloadThread;
    pthread_mutex_t      mutex;
    pthread_cond_t       bufferReadyCond;
    OpenAB_Source::Source::eGetItemRet transferStatus;
    OpenAB::PIMItemType     itemsType;
};

#endif // CARDDAV_H_