Identity.hpp

#ifndef _DITTO_IDENTITY_
#define _DITTO_IDENTITY_
 
#include "AuthenticationCallback.hpp"
#include "Helpers.hpp"
#include "dittoffi.hpp"
 
#include <memory>
#include <string>
 
namespace ditto {
class OfflinePlaygroundIdentity;
class OnlineWithAuthenticationIdentity;
class OnlinePlaygroundIdentity;
class SharedKeyIdentity;
class ManualIdentity;

enum class IdentityType {
  OFFLINE_PLAYGROUND,
  ONLINE_WITH_AUTHENTICATION,
  ONLINE_PLAYGROUND,
  SHARED_KEY,
  MANUAL,
};

std::string default_auth_url(std::string app_id);

class Identity {
  friend class Ditto;
  friend class ManualIdentity;
  friend class OfflinePlaygroundIdentity;
  friend class OnlineWithAuthenticationIdentity;
  friend class OnlinePlaygroundIdentity;
  friend class SharedKeyIdentity;
  friend class TransportSync;
 
public:
  IdentityType type;
  virtual ~Identity();

  static std::shared_ptr<OfflinePlaygroundIdentity>
  OfflinePlayground(std::string app_id = "", uint64_t site_id = 0);

  static std::shared_ptr<OnlineWithAuthenticationIdentity>
  OnlineWithAuthentication(std::string app_id,
                           std::shared_ptr<AuthenticationCallback> callback,
                           bool enable_ditto_cloud_sync = true,
                           std::string custom_auth_url = "");

  static std::shared_ptr<OnlinePlaygroundIdentity>
  OnlinePlayground(std::string app_id, std::string token,
                   bool enable_ditto_cloud_sync = true);

  static std::shared_ptr<SharedKeyIdentity>
  SharedKey(std::string app_id, std::string shared_key, uint64_t site_id = 0);

  static std::shared_ptr<ManualIdentity> Manual(std::string certificate_config);
 
private:
  virtual std::string get_app_id() const;
  virtual bool get_enable_ditto_cloud_sync() const;
  virtual bool requires_offline_license_token() const;

  virtual CIdentityConfig_t *build_identity_config() = 0;
};

class OfflinePlaygroundIdentity : public Identity {
  friend class Identity;
 
public:
  uint64_t site_id;
 
private:
  OfflinePlaygroundIdentity(std::string app_id, uint64_t site_id);
 
  std::string app_id;
  std::string get_app_id() const;
  bool requires_offline_license_token() const;
  CIdentityConfig_t *build_identity_config();
};

class OnlineWithAuthenticationIdentity : public Identity {
  friend class Ditto;
  friend class Identity;
 
public:
  bool enable_ditto_cloud_sync;

  std::string custom_auth_url;
 
private:
  OnlineWithAuthenticationIdentity(
      std::string app_id, std::shared_ptr<AuthenticationCallback> callback,
      bool enable_ditto_cloud_sync, std::string custom_auth_url);
 
  std::string app_id;
  std::shared_ptr<AuthenticationCallback> callback;
  std::string get_app_id() const;
  bool get_enable_ditto_cloud_sync() const;
  bool requires_offline_license_token() const;
  CIdentityConfig_t *build_identity_config();
};

class OnlinePlaygroundIdentity : public Identity {
  friend class Identity;
 
public:
  std::string token;

  bool enable_ditto_cloud_sync;
 
private:
  OnlinePlaygroundIdentity(std::string app_id, std::string token,
                           bool enable_ditto_cloud_sync);
 
  std::string app_id;
  std::string get_app_id() const;
  std::string get_token() const;
  bool get_enable_ditto_cloud_sync() const;
  bool requires_offline_license_token() const;
  CIdentityConfig_t *build_identity_config();
};

class SharedKeyIdentity : public Identity {
  friend class Identity;
 
public:
  std::string shared_key;

  uint64_t site_id;
 
private:
  SharedKeyIdentity(std::string app_id, std::string shared_key,
                    uint64_t site_id);
 
  std::string app_id;
  std::string get_app_id() const;
  bool requires_offline_license_token() const;
  CIdentityConfig_t *build_identity_config();
};

class ManualIdentity : public Identity {
  friend class Identity;
 
public:
  std::string certificate_config;
 
private:
  explicit ManualIdentity(std::string certificate_config);
  bool requires_offline_license_token() const;
  CIdentityConfig_t *build_identity_config();
};
 
} // namespace ditto
 
#endif