instance.hpp

/*  This file is part of mastodonpp.
 *  Copyright © 2020 tastytea <tastytea@tastytea.de>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Affero General Public License as published by
 *  the Free Software Foundation, version 3.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Affero General Public License for more details.
 *
 *  You should have received a copy of the GNU Affero General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef MASTODONPP_INSTANCE_HPP
#define MASTODONPP_INSTANCE_HPP
 
#include "curl_wrapper.hpp"
#include "types.hpp"
 
#include <cstdint>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace mastodonpp
{
 
using std::uint64_t;
using std::string;
using std::string_view;
using std::vector;
 
class Instance : public CURLWrapper
{
public:
    explicit Instance(string_view hostname, string_view access_token);
 
    Instance(const Instance &other);
 
    Instance(Instance &&other) noexcept = delete;
 
    ~Instance() noexcept override = default;
 
    Instance& operator=(const Instance &other) = delete;
 
    Instance& operator=(Instance &&other) noexcept = delete;
 
    inline void copy_connection_properties(CURLWrapper &curlwrapper) const
    {
        curlwrapper.setup_connection_properties(_proxy, _access_token, _cainfo,
                                                _useragent);
    }
 
    [[nodiscard]]
    inline string_view get_hostname() const noexcept
    {
        return _hostname;
    }
 
    [[nodiscard]]
    inline string_view get_baseuri() const noexcept
    {
        return _baseuri;
    }
 
    [[nodiscard]]
    inline string_view get_access_token() const noexcept
    {
        return _access_token;
    }
 
    inline void set_access_token(const string_view access_token)
    {
        _access_token = access_token;
        CURLWrapper::set_access_token(access_token);
    }
 
    [[nodiscard]]
    uint64_t get_max_chars() noexcept;
 
    void set_proxy(const string_view proxy) override
    {
        _proxy = proxy;
        CURLWrapper::set_proxy(proxy);
    }
 
    [[nodiscard]]
    answer_type get_nodeinfo();
 
    vector<string> get_post_formats() noexcept;
 
    void set_cainfo(string_view path) override
    {
        _cainfo = path;
        CURLWrapper::set_cainfo(path);
    }
 
    void set_useragent(const string_view useragent) override
    {
        _useragent = useragent;
        CURLWrapper::set_useragent(useragent);
    }
 
    class ObtainToken : public CURLWrapper
    {
    public:
        explicit ObtainToken(Instance &instance)
            : _instance{instance}
            , _baseuri{instance.get_baseuri()}
        {
            _instance.copy_connection_properties(*this);
        }
 
        [[nodiscard]]
        answer_type step_1(string_view client_name, string_view scopes,
                           string_view website);
 
        [[nodiscard]]
        answer_type step_2(string_view code);
 
    private:
        Instance &_instance;
        const string _baseuri;
        string _scopes;
        string _client_id;
        string _client_secret;
    };
 
private:
    const string _hostname;
    const string _baseuri;
    string _access_token;
    uint64_t _max_chars;
    string _proxy;
    vector<string> _post_formats;
    string _cainfo;
    string _useragent;
};
 
} // namespace mastodonpp
 
#endif  // MASTODONPP_INSTANCE_HPP