mastodon-cpp.hpp

/*  This file is part of mastodon-cpp.
 *  Copyright © 2018 tastytea <tastytea@tastytea.de>
 *                                                                   
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef MASTODON_CPP_HPP
#define MASTODON_CPP_HPP

#include <string>
#include <vector>
#include <cstdint>
#include <map>
#include <memory>
#include <array>
#include <mutex>
#include <curlpp/cURLpp.hpp>
#include <curlpp/Easy.hpp>

using std::uint_fast16_t;
using std::string;

namespace Mastodon
{
class API
{
public:
    class http
    {
    public:
        enum class method
        {
            GET,
            PATCH,
            POST,
            PUT,
            DELETE,
            GET_STREAM
        };

        explicit http(const API &api, const string &instance,
                      const string &access_token);
        ~http();
        uint_fast16_t request(const method &meth,
                                    const string &path,
                                    string &answer);

        uint_fast16_t request(const method &meth,
                                    const string &path,
                                    const curlpp::Forms &formdata,
                                    string &answer);

        void get_headers(string &headers) const;

        void cancel_stream();

        [[deprecated("Will vanish in 1.0.0. Use cancel_stream() instead.")]]
        void abort_stream();

        std::mutex &get_mutex();

    private:
        const API &parent;
        const string _instance;
        const string _access_token;
        string _headers;
        bool _cancel_stream;
        std::mutex _mutex;

        size_t callback_write(char* data, size_t size, size_t nmemb,
                                    string *oss);
        [[deprecated("Will vanish in 1.0.0. Use callback_write() instead.")]]
        size_t callback(char* data, size_t size, size_t nmemb,
                              string *oss);
        double callback_progress(double /* dltotal */, double /* dlnow */,
                                 double /* ultotal */, double /* ulnow */);
    };

    typedef std::map<string, std::vector<string>> parametermap;

    enum class v1
    {
        accounts_id,
        accounts_verify_credentials,
        accounts_id_followers,
        accounts_id_following,
        accounts_id_statuses,
        accounts_relationships,
        accounts_search,
        blocks,
        domain_blocks,
        endorsements,
        favourites,
        follow_requests,
        instance,
        custom_emojis,
        lists,
        accounts_id_lists,
        lists_id_accounts,
        lists_id,
        mutes,
        notifications,
        notifications_id,
        reports,
        search,
        statuses_id,
        statuses_id_context,
        statuses_id_card,
        statuses_id_reblogged_by,
        statuses_id_favourited_by,
        timelines_home,
        timelines_public,
        timelines_tag_hashtag,
        timelines_list_list_id,
        // PATCH
        accounts_update_credentials,
        // POST
        accounts_id_follow,
        accounts_id_unfollow,
        accounts_id_block,
        accounts_id_unblock,
        accounts_id_mute,
        accounts_id_unmute,
        accounts_id_pin,
        accounts_id_unpin,
        apps,
        follow_requests_id_authorize,
        follow_requests_id_reject,
        follows,
        media,
        notifications_clear,
        notifications_dismiss,
        statuses,
        statuses_id_reblog,
        statuses_id_unreblog,
        statuses_id_favourite,
        statuses_id_unfavourite,
        statuses_id_pin,
        statuses_id_unpin,
        statuses_id_mute,
        statuses_id_unmute,
        // PUT
        media_id,
        // Streaming
        streaming_user,
        streaming_public,
        streaming_public_local,
        streaming_hashtag,
        streaming_list,
        // Push
        push_subscription,
        // Glitch-Soc
        bookmarks,
        statuses_id_bookmark,
        statuses_id_unbookmark
    };

    enum class v2
    {
        search
    };

    explicit API(const string &instance, const string &access_token);

    void set_useragent(const string &useragent);

    const string get_useragent() const;

    const string get_instance() const;

    static const string urlencode(const string &str);

    static const string urldecode(const string &str);

    uint_fast16_t register_app1(const string &client_name,
                                const string &redirect_uri,
                                const string &scopes,
                                const string &website,
                                string &client_id,
                                string &client_secret,
                                string &url);

    [[deprecated("Will vanish in 1.0.0")]]
    uint_fast16_t register_app1(const string &instance,
                                const string &client_name,
                                const string &redirect_uri,
                                const string &scopes,
                                const string &website,
                                string &client_id,
                                string &client_secret,
                                string &url);

    uint_fast16_t register_app2(const string &client_id,
                                const string &client_secret,
                                const string &redirect_uri,
                                const string &code,
                                string &access_token);

    [[deprecated("Will vanish in 1.0.0")]]
    uint_fast16_t register_app2(const string &instance,
                                const string &client_id,
                                const string &client_secret,
                                const string &redirect_uri,
                                const string &code,
                                string &access_token);

    const string get_header(const string &header) const;

    bool exceptions(const bool &value);

    bool exceptions() const;

    static const string unescape_html(const string &html);

    void set_proxy(const string &proxy, const string &userpw = "");

    void get_proxy(string &proxy, string &userpw) const;

    uint_fast16_t get(const Mastodon::API::v1 &call, string &answer);

    uint_fast16_t get(const Mastodon::API::v1 &call,
                      const parametermap &parameters,
                      string &answer);

    uint_fast16_t get(const Mastodon::API::v2 &call,
                      const parametermap &parameters,
                      string &answer);

    uint_fast16_t get(const string &call, string &answer);

    [[deprecated("Will vanish in 1.0.0, use get() without string argument "
                 "instead.")]]
    uint_fast16_t get(const Mastodon::API::v1 &call,
                      const string &argument,
                      string &answer);

    [[deprecated("Will vanish in 1.0.0, use get() without string argument "
                 "instead.")]]
    uint_fast16_t get(const Mastodon::API::v1 &call,
                      const string &argument,
                      const parametermap &parameters,
                      string &answer);

    uint_fast16_t get_stream(const Mastodon::API::v1 &call,
                             const parametermap &parameters,
                             string &answer,
                             std::unique_ptr<Mastodon::API::http> &ptr);

    uint_fast16_t get_stream(const Mastodon::API::v1 &call,
                             string &answer,
                             std::unique_ptr<Mastodon::API::http> &ptr);

    uint_fast16_t get_stream(const string &call,
                             string &answer,
                             std::unique_ptr<Mastodon::API::http> &ptr);

    [[deprecated("Will vanish in 1.0.0, use get_stream() without string "
                 "argument instead.")]]
    uint_fast16_t get_stream(const Mastodon::API::v1 &call,
                             const string &argument,
                             string &answer,
                             std::unique_ptr<Mastodon::API::http> &ptr);

    uint_fast16_t patch(const Mastodon::API::v1 &call,
                        const parametermap &parameters,
                        string &answer);

    uint_fast16_t post(const Mastodon::API::v1 &call, string &answer);

     uint_fast16_t post(const Mastodon::API::v1 &call,
                        const parametermap &parameters,
                        string &answer);

     uint_fast16_t post(const string &call,
                        const parametermap &parameters,
                        string &answer);

    [[deprecated("Will vanish in 1.0.0, use post() without string argument "
                 "instead.")]]
     uint_fast16_t post(const Mastodon::API::v1 &call,
                        const string &argument,
                        string &answer);

    [[deprecated("Will vanish in 1.0.0, use post() without string argument "
                 "instead.")]]
     uint_fast16_t post(const Mastodon::API::v1 &call,
                        const string &argument,
                        const parametermap &parameters,
                        string &answer);

    uint_fast16_t put(const Mastodon::API::v1 &call,
                      const parametermap &parameters,
                      string &answer);

    uint_fast16_t put(const string &call,
                            const parametermap &parameters,
                            string &answer);

    [[deprecated("Will vanish in 1.0.0, use put() without string argument "
                 "instead.")]]
    uint_fast16_t put(const Mastodon::API::v1 &call,
                      const string &argument,
                      const parametermap &parameters,
                      string &answer);

    uint_fast16_t del(const Mastodon::API::v1 &call,
                      const parametermap &parameters);

    uint_fast16_t del(const string &call,
                      const parametermap &parameters,
                      string &answer);

    [[deprecated("Will vanish in 1.0.0, use del() without string argument "
                 "instead.")]]
    uint_fast16_t del(const Mastodon::API::v1 &call,
                      const string &argument);

    [[deprecated("Will vanish in 1.0.0, use del() without string argument "
                 "instead.")]]
    uint_fast16_t del(const Mastodon::API::v1 &call,
                      const string &argument,
                      const parametermap &parameters);

private:
    const string _instance;
    string _access_token;
    string _useragent;
    http _http;
    bool _exceptions;
    string _proxy;
    string _proxy_userpw;

    const string maptostr(const parametermap &map,
                          const bool &firstparam = true);

    const curlpp::Forms maptoformdata(const parametermap &map);
};
}

#endif