Identity.hpp

#ifndef _DITTO_IDENTITY_
#define _DITTO_IDENTITY_
 
#include "AuthenticationCallback.hpp"
#include "Helpers.hpp"
#include "dittoffi.hpp"
 
#include <memory>
#include <string>
 
namespace ditto {
class Authenticator;
class LoginProvider;
 
class OfflinePlaygroundIdentity;
class OnlineWithAuthenticationIdentity;
class OnlinePlaygroundIdentity;
class SharedKeyIdentity;
class ManualIdentity;
 
enum class IdentityType {
  OFFLINE_PLAYGROUND,
  ONLINE_WITH_AUTHENTICATION,
  ONLINE_PLAYGROUND,
  SHARED_KEY,
  MANUAL,
};
 
class Identity {
  friend class Ditto;
  friend class ManualIdentity;
  friend class OfflinePlaygroundIdentity;
  friend class OnlineWithAuthenticationIdentity;
  friend class OnlinePlaygroundIdentity;
  friend class SharedKeyIdentity;
  friend class Sync;
 
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 final;
  virtual std::shared_ptr<Authenticator> get_authenticator() const;
  virtual bool get_enable_ditto_cloud_sync() const;
  virtual bool requires_offline_license_token() const;
 
  virtual std::shared_ptr<CAuthClient_t>
  authenticate(std::string persistence_dir = "") = 0;
 
  void close();
  std::shared_ptr<CAuthClient_t> auth_client;
};
 
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::shared_ptr<CAuthClient_t> authenticate(std::string persistence_dir = "");
  bool requires_offline_license_token() const;
};
 
class OnlineWithAuthenticationIdentity : public Identity {
  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;
  bool get_enable_ditto_cloud_sync() const;
  std::shared_ptr<Authenticator> get_authenticator() const;
  std::shared_ptr<CAuthClient_t> authenticate(std::string persistence_dir = "");
  std::shared_ptr<Authenticator> authenticator;
  std::shared_ptr<LoginProvider> login_provider;
  std::shared_ptr<AuthenticationCallback> callback;
  bool requires_offline_license_token() const;
};
 
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_token() const;
  bool get_enable_ditto_cloud_sync() const;
  bool requires_offline_license_token() const;
  std::shared_ptr<Authenticator> get_authenticator() const;
  std::shared_ptr<CAuthClient_t> authenticate(std::string persistence_dir = "");
  std::shared_ptr<Authenticator> authenticator;
};
 
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;
  bool requires_offline_license_token() const;
  std::shared_ptr<CAuthClient_t> authenticate(std::string persistence_dir = "");
};
 
class ManualIdentity : public Identity {
  friend class Identity;
 
public:
  std::string certificate_config;
 
private:
  std::shared_ptr<CAuthClient_t> authenticate(std::string persistence_dir = "");
  explicit ManualIdentity(std::string certificate_config);
  bool requires_offline_license_token() const;
};
 
} // namespace ditto
 
#endif