mastodon-cpp.hpp

/*  This file is part of mastodon-cpp.
 *  Copyright © 2018, 2019 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 MASTODON_CPP_HPP
#define MASTODON_CPP_HPP

#include <string>
#include <vector>
#include <memory>
#include <array>
#include <mutex>
#include <ostream>
#include <thread>
#include <cstdint>
#include <Poco/Net/HTMLForm.h>

#include "return_types.hpp"
#include "types.hpp"

using std::string;
using std::uint8_t;
using std::unique_ptr;
using Poco::Net::HTMLForm;

namespace Mastodon
{
    class API
    {
    public:
        class http
        {
        public:
            explicit http(const API &api, const string &instance,
                          const string &access_token);
            ~http();
            return_call request(const http_method &meth, const string &path);

            return_call request(const http_method &meth,
                                const string &path,
                                HTMLForm &formdata);

            void request_stream(const string &path, string &stream);

            void get_headers(string &headers) const;

            void cancel_stream();

            std::mutex &get_mutex();

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

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

            return_call request_common(const http_method &meth,
                                       const string &path,
                                       HTMLForm &formdata,
                                       string &answer);
            size_t callback_write(char* data, size_t size, size_t nmemb,
                                  string *oss);
            double callback_progress(double /* dltotal */, double /* dlnow */,
                                     double /* ultotal */, double /* ulnow */);
        };

        enum class v1
        {
            // Mastodon
            accounts_id,
            accounts,
            accounts_verify_credentials,
            accounts_update_credentials,
            accounts_id_followers,
            accounts_id_following,
            accounts_id_statuses,
            accounts_id_follow,
            accounts_id_unfollow,
            accounts_relationships,
            accounts_search,

            apps,
            apps_verify_credentials,

            blocks,
            accounts_id_block,
            accounts_id_unblock,

            custom_emojis,

            domain_blocks,

            endorsements,
            accounts_id_pin,
            accounts_id_unpin,

            favourites,
            statuses_id_favourite,
            statuses_id_unfavourite,

            filters,
            filters_id,

            follow_requests,
            follow_requests_id_authorize,
            follow_requests_id_reject,

            suggestions,
            suggestions_accountid,

            instance,

            lists,
            accounts_id_lists,
            lists_id_accounts,
            lists_id,

            media,
            media_id,

            mutes,
            accounts_id_mute,
            accounts_id_unmute,
            statuses_id_mute,
            statuses_id_unmute,

            notifications,
            notifications_id,
            notifications_clear,
            notifications_dismiss,
            push_subscription,

            polls_id,
            polls_id_votes,

            reports,

            // scheduled_statuses,
            // scheduled_statuses_id,

            statuses_id,
            statuses_id_context,
            statuses_id_card,
            statuses_id_reblogged_by,
            statuses_id_favourited_by,
            statuses,
            statuses_id_reblog,
            statuses_id_unreblog,
            statuses_id_pin,
            statuses_id_unpin,

            timelines_home,
            conversations,
            timelines_public,
            timelines_tag_hashtag,
            timelines_list_list_id,

            streaming_health,
            streaming_user,
            streaming_public,
            streaming_public_local,
            streaming_hashtag,
            streaming_hashtag_local,
            streaming_list,
            streaming_direct,

            // Glitch-Soc
            bookmarks,
            statuses_id_bookmark,
            statuses_id_unbookmark
        };

        enum class v2
        {
            search
        };

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

        virtual ~API();

        void set_useragent(const string &useragent);

        const string get_useragent() const;

        const string get_instance() const;

        [[deprecated("Replaced by Mastodon::urlencode")]]
        static const string urlencode(const string &str);

        [[deprecated("Replaced by Mastodon::urldecode")]]
        static const string urldecode(const string &str);

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


        return_call register_app2(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;

        [[deprecated("Replaced by Mastodon::unescape_html")]]
        static const string unescape_html(const string &html);

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

        const return_call get(const Mastodon::API::v1 &call);

        const return_call get(const Mastodon::API::v1 &call,
                              const parameters &parameters);

        const return_call get(const Mastodon::API::v2 &call,
                              const parameters &parameters);

        const return_call get(const string &call);

        void get_stream(const Mastodon::API::v1 &call,
                        const parameters &parameters,
                        unique_ptr<Mastodon::API::http> &ptr,
                        string &stream);

        void get_stream(const Mastodon::API::v1 &call,
                        unique_ptr<Mastodon::API::http> &ptr,
                        string &stream);

        void get_stream(const string &call,
                        unique_ptr<Mastodon::API::http> &ptr,
                        string &stream);

        return_call patch(const Mastodon::API::v1 &call,
                          const parameters &parameters);

        return_call post(const Mastodon::API::v1 &call);

        return_call post(const Mastodon::API::v1 &call,
                         const parameters &parameters);

        return_call post(const string &call,
                         const parameters &parameters);

        return_call put(const Mastodon::API::v1 &call,
                        const parameters &parameters);

        return_call put(const string &call, const parameters &parameters);

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

        return_call del(const string &call, const parameters &parameters);

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

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

        unique_ptr<HTMLForm> maptoformdata(const parameters &map);

        const parameters delete_params(const parameters &params,
                                       const vector<string> &keys);
    };

    const string urlencode(const string &str);

    const string urldecode(const string &str);

    const string unescape_html(const string &html);
}

#endif