app.hpp

 
//
// Autores 2022 Realm Inc.
//
// Licenciado sob a Licença Apache, Versão 2.0 (a "Licença");
// você não pode usar este arquivo, exceto em conformidade com a Licença.
// Você pode obter uma cópia da Licença em
//
// http://www.apache.org/license/LICENSE-2.0
//
// A menos que exigido pela lei aplicável ou acordado por escrito, o software
// distribuído sob a Licença é distribuído "Como está",
// sem garantias ou condições de qualquer tipo, Express ou implícitas.
// Consulte a Licença para obter as permissões específicas de domínio do idioma e
// limitações da Licença.
//
 
#ifndef CPPREALM_APP_HPP
#define CPPREALM_APP_HPP
 
#include <cpprealm/bson.hpp>
#include <cprealm/db.hpp>
 
#include <cprealm/internal/bridge/realm.hpp>
#include <cprealm/internal/bridge/sync_error.hpp>
#include <cprealm/internal/bridge/sync_manager.hpp>
#include <cprealm/internal/bridge/sync_session.hpp>
#include <cprealm/internal/bridge/utils.hpp>
#include <cpprealm/network/http.hpp>
#include <cpprealm/network/websocket.hpp>
 
#include <future>
#include <utility>
 
namespace Realm {
 
    usando proxy_config = sync_config::proxy_config;
    usando sync_session = initial::bridge::sync_session;
 
    aplicativo namespace  {
        aplicativo de classe  ;
        usuário da classe  ;
        struct AppError;
 }// namespace app
    namespace interno::bridge {
        struct sync_error;
 }
 
//MARK: Usuário
 
// Representa um estado de erro do servidor.
estrutura, estrutura app_error {
    app_error() = delete;
    app_error(const app_errore outros);
    app_error& operator=(const app_error& other) ;
    app_error(app_error&& outro);
    app_error& operator=(app_error&& other);
    ~app_error();
    app_error(realm::app::AppError&& erro); //NOLINT(google-explicit-constructor)
 
 [[nodiscard]] std::string_view message() const;
 
 [[nodiscard]] std::string_view link_to_server_logs() const;
 
 [[nodiscard]] bool is_json_error() const;
 
 [[nodiscard]] bool is_service_error() const;
 
 [[nodiscard]] bool is_http_error() const;
 
 [[nodiscard]] bool is_custom_error() const;
 
 [[nodiscard]] bool is_client_error() const;
privado:
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 internal::bridge::storage::AppError m_error[1];
#else
 std::shared_ptr<realm::app::AppError> m_error;
#endif
};
 
estrutura, estrutura usuário {
    user() = default;
    usuário(const usuário&) = padrão;
    usuário ( usuário &&) = padrão ;
    user& operator=(const user&) = default;
    user& operator=(user&&) = default;
    explícito usuário(std::shared_ptr<app::usuário><app::User> usuário);
    bool is_logged_in() const;
 
    Classe de enumeração estado : uint8_t {
 chunk_out,
 chunk_in,
 removido,
 };
 
 [[nodiscard]] std::string identificador() const;
 
 [[nodiscard]] state state() const;
 
 [[nodiscard]] std::string access_token() const;
 
 [[nodiscard]] std::string refresh_token() const;
 
    estrutura, estrutura initial::bridge::sync_manager sync_manager() const;
 
 [[nodiscard]] db_config flexible_sync_configuration() const;
 
    vazio log_out(std::function <vazio(std::opcional<app_error>)>&& chamada de resposta) const;
 
 [[nodiscard]] std::future<void> log_out() const;
 
 
 [[deprecated("Replaced by `get_custom_data()'. Este método será removido em uma versão futura.")]]
 [[nodiscard]] std::optional<std::string> custom_data() const;
 
 [[nodiscard]] std::optional<bsoncxx::document> get_custom_data() const;
 
 [[deprecated("Esta função está obsoleta e será substituída pela API call_function baseada em BSON.")]]]
    vazio call_function(const std::string& nome, const std::string& args_ejson,
 std::function <null(std::opcional<std::string>, std::opcional<app_error>)> chamada de resposta) const;
 
 [[deprecated("Esta função está obsoleta e será substituída pela API call_function baseada em BSON.")]]]
 [[nodiscard]] std::future <std::opcional<std::string>> call_function(const std::string& name,
                                                                        const std::string& args_ejson) const;
 
    vazio call_function(const std::string& name, const std::vector<bsoncxx>& args_bson,
 std::function < null(std::opcional<bsoncxx><app_error> < bsoncxx >, std::opcional )> chamada de resposta) const ;
 
 [[nodiscard]] std::future<std::optional<bsoncxx>> call_function(const std::string& name, const std::vector<bsoncxx>& args_bson) const;
 
    vazio refresh_custom_user_data(std::function<void(std::optional<app_error>)> chamada de resposta);
 
 [[nodiscard]] std::future<void> refresh_custom_user_data() const;
 
 std::shared_ptr<app::User> m_user;
};
 
bool operator==(const user& lhs, const user& rhs);
operador bool !=(const user& lhs, const user& rhs);
 
aplicativo namespace  {
    estrutura AppCredentials;
}
 
classe Aplicativo {
público:
    estrutura, estrutura configuração {
 std::string app_id;
 std::opcional<std::string> base_url;
 <std::string> caminho std::opcional ;
 [[deprecated("As opções de rede devem ser fornecidas por meio de implementações de rede personalizadas.")]]]
 std::optional <std::map <std::string, std::string>> custom_http_headers;
 std::opcional <std::array <char, 64>> metadata_encryption_key;
        bool enable_cashing = true;
 [[deprecated("As opções de rede devem ser fornecidas por meio de implementações de rede personalizadas.")]]]
 std::opcional<sync_config::proxy_config> proxy_configuration;
 std::shared_ptr<networking::http_transport_client> http_transport_client;
 std::shared_ptr<networking::sync_socket_provider> sync_socket_provider;
 
 };
 
 
    App(configuração const &);
 
    estrutura, estrutura credenciais {
        estático credenciais anônimas();
        estático credenciais api_key(const std::string& chave);
        estático credenciais Facebook(const std::string& access_token);
        estático credenciais apple(const std::string& ID);
        estático credenciais google_auth_code(const std::string& auth_code);
        estático credenciais google_ID(const std::string& ID);
        estático credenciais personalizadas(const std::string& token);
        estático credenciais username_password(const std::string& nome de usuário, const std::string& senha);
        estático função de credenciais (const std::string& carga útil);
        credenciais();
        credenciais(credenciaisconst e outras);
        credenciais& operador=(const credenciais& outro);
        credenciais(credenciais&& outro);
        credenciais& operador=(credenciais&& outro);
        ~credentials();
    privado:
        credenciais (app::AppCredentials&& credenciais ) noexceto ;
        operador app::AppCredentials() const;
        amigo classe Aplicação;
 
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 internal::bridge::storage::AppCredentials m_credentials[1];
#else
 std::shared_ptr<app::AppCredentials> m_credentials;
#endif
 };
 
 std::future<void> subscribe_user(const std::string& username, const std::string& password);
 std::future<user> login(const credenciais &credenciais);
    vazio login(const credenciais& credenciais, std::function<void(usuário, std::opcional<app_error>)>&& chamada de resposta);
 [[nodiscard]] internal::bridge::sync_manager get_sync_manager() const;
 [[nodiscard]] std::optional<user> get_current_user() const;
    vazio clear_cached_apps();
 std::opcional<App> get_cached_app(const std::string& app_id, const std::optional<std::string>& base_url);
 std::string get_base_url() const;
 
#ifdef Realm_ENABLE_EXPERIMENTAL
 [[nodiscard]] std::future<void> update_base_url(std::string base_url) const;
#endif
 
 [[nodiscard]] std::string path_for_realm(const realm::sync_config&) const;
privado:
 std::shared_ptr<app::App> m_app;
    Aplicativo(std::Shared_ptr<app::App>&& a) : m_app(std::move(a)) { }
};
 
}
#endif /* CPPREALM_APP_HPP */