CardDAVStorage.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/ContactsStorage.hpp>
#include <list>
#include "helpers/Http.hpp"
#include "CardDAVHelper.hpp"

class CardDAVStorageItemIterator;

class CardDAVStorage : public OpenAB_Storage::ContactsStorage
{
  public:
    CardDAVStorage(const std::string& url,
                  const std::string& login,
                  const OpenAB::SecureString& password);

    CardDAVStorage(const std::string& url,
                  const std::string& clientId,
                  const OpenAB::SecureString& clientSecret,
                  const OpenAB::SecureString& refreshToken);

    virtual ~CardDAVStorage();

    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 addContact( const std::string& vCard,
                              OpenAB::PIMItem::ID& newId,
                              OpenAB::PIMItem::Revision& revision);

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

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

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

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

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

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

    enum eGetItem getContacts(const OpenAB::PIMItem::IDs & ids,
                              std::vector<OpenAB::SmartPtr<OpenAB::PIMContactItem> > & 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:
    CardDAVStorage(CardDAVStorage const &other);

    CardDAVStorage& operator=(CardDAVStorage const &other);

    void construct();

    void cleanup();

    bool downloadVCards(unsigned int offset, unsigned int size);

    std::string       serverUrl;

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

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

    std::string syncToken;

    OpenAB::HttpSession curlSession;
    OpenAB::HttpAuthorizer* authorizer;
    CardDAVHelper* cardDAVHelper;
    CardDAVStorageItemIterator* sourceIterator;
};

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

    virtual ~CardDAVStorageItemIterator();

    enum eCursorInit{
      eCursorInitOK,
      eCursorInitFail
    };
    enum eCursorInit cursorInit(CardDAVHelper* cardDavHelper);

    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:
    CardDAVStorageItemIterator(CardDAVStorageItemIterator const &other);

    CardDAVStorageItemIterator& operator=(CardDAVStorageItemIterator const &other);

    enum eFetchContacts {
      eFetchContactsOK,
      eFetchContactsEND,
      eFetchContactsFail
    };
    enum eFetchContacts fetchContacts(int fetchsize);

    static void* downloadThreadFunc(void* ptr);
    bool downloadVCards(unsigned int offset, unsigned int size);
    OpenAB_Storage::StorageItem    elem;
    CardDAVHelper*              cardDavHelper;
    unsigned                    total;
    unsigned int                offset;
    unsigned int                offsetOfCachedVCards;
    std::list<OpenAB::SmartPtr<OpenAB::PIMContactItem> >  cachedContacts;
    std::vector<CardDAVHelper::ContactMetadata> contactsMetadata;
    bool                 paused;
    bool                 cancelled;
    pthread_t            downloadThread;
    bool                 threadCreated;
    pthread_mutex_t      mutex;
    pthread_cond_t       bufferReadyCond;
    OpenAB_Source::Source::eGetItemRet transferStatus;
};

#endif // CARDDAV_H_