Identity.hpp

#ifndef DITTO_IDENTITY_H
#define DITTO_IDENTITY_H
 
#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;
 
public:
  IdentityType type;
  virtual ~Identity();

  static std::shared_ptr<OfflinePlaygroundIdentity>
  OfflinePlayground(std::string app_id = "");

  static std::shared_ptr<OfflinePlaygroundIdentity> DITTO_DEPRECATED_BECAUSE(
      "Use the OfflinePlayground() function that does not specify a `site_id` "
      "instead.  Use `peer_key` to uniquely identify a peer")
      OfflinePlayground(std::string app_id, uint64_t site_id);

  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,
                   std::string custom_auth_url = "");
  static std::shared_ptr<SharedKeyIdentity> SharedKey(std::string app_id,
                                                      std::string shared_key);

  static std::shared_ptr<SharedKeyIdentity> DITTO_DEPRECATED_BECAUSE(
      "Use the SharedKey() function that does not specify a `site_id` "
      "instead.  Use `peer_key` to uniquely identify a peer")
      SharedKey(std::string app_id, std::string shared_key, uint64_t site_id);

  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:
  DITTO_DEPRECATED_BECAUSE("Use `peer_key` instead to uniquely identify a peer")
  uint64_t site_id; // NOLINT
 
private:
  OfflinePlaygroundIdentity(std::string app_id);

  DITTO_DEPRECATED_BECAUSE(
      "Use the OfflinePlaygroundIdentity constructor that does not specify a "
      "`site_id`. Use `peer_key` instead to uniquely identify a peer.")
  OfflinePlaygroundIdentity(std::string app_id, uint64_t site_id);
 
  std::string app_id;
  std::string get_app_id() const override;
  bool requires_offline_license_token() const override;
  CIdentityConfig_t *build_identity_config() override;
};

class OnlineWithAuthenticationIdentity : public Identity {
  friend class Ditto;
  friend class Identity;
 
public:
  // TODO(v5): make enable_ditto_cloud_sync private and add a getter
  bool enable_ditto_cloud_sync; // NOLINT

  // TODO(v5): make custom_auth_url private and add a getter
  std::string custom_auth_url; // NOLINT
 
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 override;
  bool get_enable_ditto_cloud_sync() const override;
  bool requires_offline_license_token() const override;
  CIdentityConfig_t *build_identity_config() override;
};

class OnlinePlaygroundIdentity : public Identity {
  friend class Identity;
 
public:
  // TODO(v5): make token private and add a getter
  std::string token; // NOLINT

  // TODO(v5): make enable_ditto_cloud_sync private and add a getter
  bool enable_ditto_cloud_sync; // NOLINT

  // TODO(v5): make custom_auth_url private and add a getter
  std::string custom_auth_url; // NOLINT
 
private:
  OnlinePlaygroundIdentity(std::string app_id, std::string token,
                           bool enable_ditto_cloud_sync,
                           std::string custom_auth_url);
 
  std::string app_id;
  std::string get_app_id() const override;
  std::string get_token() const;
  bool get_enable_ditto_cloud_sync() const override;
  bool requires_offline_license_token() const override;
  CIdentityConfig_t *build_identity_config() override;
};

class SharedKeyIdentity : public Identity {
  friend class Identity;
 
public:
  // TODO(v5): make shared_key private and add a getter
  std::string shared_key; // NOLINT

  DITTO_DEPRECATED_BECAUSE(
      "Use `peer_key` instead to uniquely identify a peer.")
  uint64_t site_id; // NOLINT
 
private:
  SharedKeyIdentity(std::string app_id, std::string shared_key);

  DITTO_DEPRECATED_BECAUSE(
      "Use the @ref SharedKeyIdentity constructor that does not specify a "
      "`site_id` instead.  Use `peer_key` to uniquely identify a peer.")
  SharedKeyIdentity(std::string app_id, std::string shared_key,
                    uint64_t site_id);
 
  std::string app_id;
  std::string get_app_id() const override;
  bool requires_offline_license_token() const override;
  CIdentityConfig_t *build_identity_config() override;
};

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 override;
  CIdentityConfig_t *build_identity_config() override;
};
 
} // namespace ditto
 
#endif