wxFlickrClient.h

// wxFlickrClient.h: Schnittstelle für die Klasse wxFlickrClient.
//

#if !defined(AFX_WXFLICKRCLIENT_H__58F0F436_7CBC_40E6_ADC4_5C1A28B28A9F__INCLUDED_)
#define AFX_WXFLICKRCLIENT_H__58F0F436_7CBC_40E6_ADC4_5C1A28B28A9F__INCLUDED_

// wx includes
#include <wx/socket.h>

// TinyXML includes
#include "includes/tinyxml_2_4_2/tinyxml.h"

// local includes
#include "wxFlickrEvent.h"
#include "wxFlickrData.h"

namespace wxFlickrAPI {

  // forward declarations
  class wxFlickrAPIMethod;

  enum CommunicationType {
    REST,
    //XMLRPC,
    // SOAP,
  };

  class wxFlickrClient : public wxSocketClient {
  public:
    friend class wxFlickrAPIMethod;
    friend class Upload;
    wxFlickrClient(wxString sAPIKey, wxString sSharedSecret);
    virtual ~wxFlickrClient();
    void SetSocketEventHandler(wxEvtHandler& handler, int iId = -1, bool bDeleteOnDestruction = FALSE);
    AuthData *GetAuthData();
    wxString GetAPIKey();
    void SetAuthData(AuthData *pData, bool bCopy = FALSE);
    void SetFlickrHandler(wxEvtHandler* pFlHandler);
    bool IsReady();
    bool IsSignedIn();
    void ForwardFlickrResponse(TiXmlNode *pFlickrTree, bool bIsErrorMsg);

  protected:
    virtual bool Connect(bool bWait = TRUE);
    void SetCurrentMethod(wxFlickrAPIMethod *pMethod);
    virtual void Send2Flickr(wxString sMethod, StrStrHashMap args, wxFlickrAPIMethod *pSender = NULL, bool bSigned = FALSE) = 0;
    void UploadPhoto(wxString sImage, StrStrHashMap args, wxFlickrAPIMethod *pSender);
    wxString BuildSignature(wxArrayString aSortedArgs);
    wxEvtHandler *GetFlickrHandler();
    void SendWhileNotReadyErr(wxString sFullMethodName);

    wxEvtHandler *m_pFlHandler;
    wxFlickrAPIMethod *m_pCurrentMethod;
    wxString m_sAPIKey;
    wxString m_sSharedSecret;
    wxIPV4address m_FlickrURL;
    AuthData *m_pAuthData;
  private:
    wxEvtHandler *m_pSocketEventHandler;
  };

  class wxFlickrAPIMethod : public wxObject {
  public:
    enum State {
      Idle,
    };
    // \todo using standard constructor causes m_pClient == NULL !
    wxFlickrAPIMethod();
    virtual ~wxFlickrAPIMethod();
    virtual void OnFlickrResponse(TiXmlNode *pFlickrTree, bool bIsErrorMsg);
    virtual void SetArg(wxString sArgName, wxString sValue);
    bool IsReady();
    void NotSignedErr(wxString sMethod);
    wxString BuildSignature(wxArrayString aSortedArgs);
  protected:
    void Send2Flickr(wxString sMethod, bool bSigned = FALSE);
    wxString m_sMethodPrefix;
    void PostFlickrEvent(wxFlickrData *pDataOut, wxFlickrEvent::Type iType);
    void PostFlickrError(wxFlickrError *pError);
    void SendWhileNotReadyErr(wxString sFullMethodName);
    void ReceiveWhileNotWaitingErr();
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
    void SimpleProcessResponse(TiXmlNode *pResponse);
    virtual void ProcessErrorResponse(TiXmlNode *pErrorMsg);
    wxFlickrClient *m_pClient;
    int m_iState;
  private:
    DECLARE_ABSTRACT_CLASS(wxFlickrAPIMethod)
    StrStrHashMap m_Args;
  };

  class wxFlickrClientREST : public wxFlickrClient {
  public:
    wxFlickrClientREST(wxString sAPIKey, wxString sSharedSecret) : wxFlickrClient(sAPIKey, sSharedSecret) {};
    virtual void Send2Flickr(wxString sMethod, StrStrHashMap args, wxFlickrAPIMethod *pSender = NULL, bool bSigned = FALSE);
  };

  class wxFlickrClientXMLRPC : public wxFlickrClient {
  public:
    wxFlickrClientXMLRPC(wxString sAPIKey, wxString sSharedSecret) : wxFlickrClient(sAPIKey, sSharedSecret) {};
    virtual void Send2Flickr(wxString sMethod, StrStrHashMap args, wxFlickrAPIMethod *pSender = NULL, bool bSigned = FALSE);
  };

  class Upload : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Ok,
    };
    Upload() {};
    Upload(wxFlickrClient *pClient);
    virtual ~Upload();
    void DoUpload();
    void SetImageFileName(wxString sImage);
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    wxString m_sImage;
    DECLARE_DYNAMIC_CLASS(Auth)
  };

  class Auth : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Frob,
      Waiting4Token,
    };
    Auth() {};
    Auth(wxFlickrClient *pClient, wxString sPerms);
    virtual ~Auth();
    void CheckToken();
    void GetFrob();
    void GetToken();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
    void ProcessFrob(TiXmlNode *pResponse);
    void ProcessToken(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(Auth)
    wxString m_sPerms;
  };

  class Blogs : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4List,
      Waiting4Post,
    };
    Blogs() {};
    Blogs(wxFlickrClient *pClient);
    virtual ~Blogs();
    void GetList();
    void PostPhoto();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(Blogs)
  };

  class Contacts : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4List,
    };
    Contacts() {};
    Contacts(wxFlickrClient *pClient);
    virtual ~Contacts();
    void GetList();
    void GetPublicList();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(Contacts)
  };

  class Favorites : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4List,
      Waiting4Add,
      Waiting4Remove,
    };
    Favorites() {};
    Favorites(wxFlickrClient *pClient);
    virtual ~Favorites();
    void Add();
    void GetList();
    void GetPublicList();
    void Remove();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
    void ProcessList(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(Favorites)
  };

  class Groups : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Data,
    };
    Groups() {};
    Groups(wxFlickrClient *pClient);
    virtual ~Groups();
    void Browse();
    void GetInfo();
    void Search();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(Groups)
  };

  class GroupsPools : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Photos,
      Waiting4Data,
    };
    GroupsPools(wxFlickrClient *pClient);
    GroupsPools() {};
    virtual ~GroupsPools();
    void Add();
    void GetContext();
    void GetGroups();
    void GetPhotos();
    void Remove();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(GroupsPools)
  };

  class Interestingness : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4List,
    };
    Interestingness() {};
    Interestingness(wxFlickrClient *pClient);
    virtual ~Interestingness();
    void GetList();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(Interestingness)
  };

  class People : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Data,
      Waiting4Photos,
    };
    People() {};
    People(wxFlickrClient *pClient);
    virtual ~People();
    void  FindByEmail();
    void FindByUsername();
    void GetInfo();
    void GetPublicGroups();
    void GetPublicPhotos();
    void GetUploadStatus();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
    void ProcessList(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(People)
  };

  class Photos : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Photos,
      Waiting4Ok,
      Waiting4Data,
    };
    Photos() {};
    Photos(wxFlickrClient *pClient);
    virtual ~Photos();
    //virtual void OnFlickrResponse(TiXmlNode *pFlickrTree);

    void AddTags();
    void Delete();
    void GetAllContexts();
    void GetContactsPhotos();
    void GetContactsPublicPhotos();
    void GetContext();
    void GetCounts();
    void GetExif();
    void GetInfo();
    void GetNotInSet();
    void GetPerms();
    void GetRecent();
    void GetSizes();
    void GetUntagged();
    void RemoveTag();
    void Search();
    void SetDates();
    void SetMeta();
    void SetPerms();
    void SetTags();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
    void ProcessSearch(TiXmlNode *pResponse);
    void ProcessContexts(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(Photos)
  };

  class PhotosLicenses : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Data,
    };
    PhotosLicenses() {};
    PhotosLicenses(wxFlickrClient *pClient);
    virtual ~PhotosLicenses();
    void GetInfo();
    void SetLicense();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(PhotosLicenses)
  };

  class PhotosNotes : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Data,
    };
    PhotosNotes() {};
    PhotosNotes(wxFlickrClient *pClient);
    virtual ~PhotosNotes();
    void Add();
    void Delete();
    void Edit();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(PhotosNotes)
  };

  class PhotosTransform : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Data,
    };
    PhotosTransform() {};
    PhotosTransform(wxFlickrClient *pClient);
    virtual ~PhotosTransform();
    void Rotate();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(PhotosTransform)
  };

  class PhotosUpload : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Data,
    };
    PhotosUpload() {};
    PhotosUpload(wxFlickrClient *pClient);
    virtual ~PhotosUpload();
    void CheckTickets();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(PhotosUpload)
  };

  class Photosets : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Data,
      Waiting4Photos,
    };
    Photosets() {};
    Photosets(wxFlickrClient *pClient);
    virtual ~Photosets();
    void AddPhoto();
    void Create();
    void Delete();
    void EditMeta();
    void EditPhotos();
    void GetContext();
    void GetInfo();
    void GetList();
    void GetPhotos();
    void OrderSets();
    void RemovePhoto();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(Photosets)
  };

  class Reflection : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Data,
    };
    Reflection() {};
    Reflection(wxFlickrClient *pClient);
    virtual ~Reflection();
    void GetMethodInfo();
    void GetMethods();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(Reflection)
  };

  class Tags : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Data
    };
    Tags() {};
    Tags(wxFlickrClient *pClient);
    virtual ~Tags();
    void GetListPhoto();
    void GetListUser();
    void GetListUserPopular();
    void GetRelated();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(Tags)
  };

  class Test : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Data,
    };
    Test() {};
    Test(wxFlickrClient *pClient);
    virtual ~Test();
    void Echo();
    void Login();
  protected:
  private:
    DECLARE_DYNAMIC_CLASS(Test)
  };

  class URLs : public wxFlickrAPIMethod {
  public:
    enum State {
      Idle,
      Waiting4Data,
    };
    URLs() {};
    URLs(wxFlickrClient *pClient);
    virtual ~URLs();
    void GetGroup();
    void GetUserPhotos();
    void GetUserProfile();
    void LookupGroup();
    void LookupUser();
  protected:
    virtual void ProcessFlickrResponse(TiXmlNode *pResponse);
  private:
    DECLARE_DYNAMIC_CLASS(URLs)
  };
}

#endif // !defined(AFX_WXFLICKRCLIENT_H__58F0F436_7CBC_40E6_ADC4_5C1A28B28A9F__INCLUDED_)

---