mutriz

main.cpp (7067B)

---

 #include <boost/beast.hpp>
 #include <iostream>
 #ifdef WIN32
     #include <windows.h>
 #else
     #include <cstdlib>
 #endif
 #include <variant.hpp>
 
 #include "client.hpp"
 #include "errors.hpp"
 #include "mtx.hpp"
 
 //
 // Simple usage example of the /login & /sync endpoints which
 // will print the stream of messages from all rooms as received by the client.
 //
 
 using namespace std;
 using namespace mtx::client;
 using namespace mtx::events;
 
 using TimelineEvent = mtx::events::collections::TimelineEvents;
 
 void
 print_errors(RequestErr err)
 {
     if (err->status_code != boost::beast::http::status::unknown)
         cout << err->status_code << "\n";
     if (!err->matrix_error.error.empty())
         cout << err->matrix_error.error << "\n";
     if (err->error_code)
         cout << err->error_code.message() << "\n";
 }
 
 // Check if the given event has a textual representation.
 bool
 is_room_message(const TimelineEvent &event)
 {
     return mpark::holds_alternative<mtx::events::RoomEvent<msg::Audio>>(event) ||
            mpark::holds_alternative<mtx::events::RoomEvent<msg::Emote>>(event) ||
            mpark::holds_alternative<mtx::events::RoomEvent<msg::File>>(event) ||
            mpark::holds_alternative<mtx::events::RoomEvent<msg::Image>>(event) ||
            mpark::holds_alternative<mtx::events::RoomEvent<msg::Notice>>(event) ||
            mpark::holds_alternative<mtx::events::RoomEvent<msg::Text>>(event) ||
            mpark::holds_alternative<mtx::events::RoomEvent<msg::Video>>(event);
 }
 
 // Retrieves the fallback body value from the event.
 std::string
 get_body(const TimelineEvent &event)
 {
     if (mpark::holds_alternative<RoomEvent<msg::Audio>>(event))
         return mpark::get<RoomEvent<msg::Audio>>(event).content.body;
     else if (mpark::holds_alternative<RoomEvent<msg::Emote>>(event))
         return mpark::get<RoomEvent<msg::Emote>>(event).content.body;
     else if (mpark::holds_alternative<RoomEvent<msg::File>>(event))
         return mpark::get<RoomEvent<msg::File>>(event).content.body;
     else if (mpark::holds_alternative<RoomEvent<msg::Image>>(event))
         return mpark::get<RoomEvent<msg::Image>>(event).content.body;
     else if (mpark::holds_alternative<RoomEvent<msg::Notice>>(event))
         return mpark::get<RoomEvent<msg::Notice>>(event).content.body;
     else if (mpark::holds_alternative<RoomEvent<msg::Text>>(event))
         return mpark::get<RoomEvent<msg::Text>>(event).content.body;
     else if (mpark::holds_alternative<RoomEvent<msg::Video>>(event))
         return mpark::get<RoomEvent<msg::Video>>(event).content.body;
 
     return "";
 }
 
 // Retrieves the sender of the event.
 std::string
 get_sender(const TimelineEvent &event)
 {
     return mpark::visit([](auto e) { return e.sender; }, event);
 }
 
 // Simple print of the message contents.
 void
 print_message(const TimelineEvent &event)
 {
     if (is_room_message(event))
         cout << get_sender(event) << ": " << get_body(event) << "\n";
 }
 
 // Callback to executed after a /sync request completes.
 void
 sync_handler(shared_ptr<Client> client, const mtx::responses::Sync &res, RequestErr err)
 {
     if (err) {
         cout << "sync error:\n";
         print_errors(err);
 
         client->sync(
                 "",
                 client->next_batch_token(),
                 false,
                 30000,
                 std::bind(&sync_handler, client, std::placeholders::_1, std::placeholders::_2));
 
         return;
     }
 
     for (const auto room : res.rooms.join) {
         for (const auto msg : room.second.timeline.events)
             print_message(msg);
     }
 
     client->set_next_batch_token(res.next_batch);
 
     client->sync(
             "",
             client->next_batch_token(),
             false,
             30000,
             std::bind(&sync_handler, client, std::placeholders::_1, std::placeholders::_2));
 }
 
 // Callback to executed after the first (initial) /sync request completes.
 void
 initial_sync_handler(shared_ptr<Client> client, const nlohmann::json &res, RequestErr err)
 {
     if (err) {
         cout << "error during initial sync:\n";
         print_errors(err);
 
         if (err->status_code != boost::beast::http::status::ok) {
             cout << "retrying initial sync ...\n";
             client->sync("",
                          "",
                          false,
                          0,
                          std::bind(&initial_sync_handler,
                                    client,
                                    std::placeholders::_1,
                                    std::placeholders::_2));
         }
 
         return;
     }
 
     client->set_next_batch_token(res.at("next_batch"));
 
     client->sync(
             "",
             client->next_batch_token(),
             false,
             30000,
             std::bind(&sync_handler, client, std::placeholders::_1, std::placeholders::_2));
 }
 
 #ifdef WIN32
     string getpassword(const char *prompt, bool show_asterisk=true)
     {
         const char BACKSPACE=8;
         const char RETURN=13;
 
         string password;
         unsigned char ch=0;
 
         cout <<prompt<<endl;
 
         DWORD con_mode;
         DWORD dwRead;
 
         HANDLE hIn=GetStdHandle(STD_INPUT_HANDLE);
 
         GetConsoleMode( hIn, &con_mode );
         SetConsoleMode( hIn, con_mode & ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT) );
 
         while(ReadConsoleA( hIn, &ch, 1, &dwRead, NULL) && ch !=RETURN)
         {
             if(ch==BACKSPACE)
             {
                 if(password.length()!=0)
                 {
                     if(show_asterisk)
                         cout <<"\b \b";
                     password.resize(password.length()-1);
                 }
             }
             else
             {
                 password+=ch;
                 if(show_asterisk)
                     cout <<'*';
             }
         }
         cout <<endl;
         return password;
     }
 #else
     string getpassword(const char *prompt, bool show_asterisk=true)
     {
         return getpass("Password: ");
     }
 #endif
 
 int
 main()
 {
     std::string username, server, password;
 
     cout << "Username: ";
     std::getline(std::cin, username);
 
     cout << "HomeServer: ";
     std::getline(std::cin, server);
 
     password = getpassword("Password: ");
 
     auto client = std::make_shared<Client>(server);
 
     client->login(
             username, password, [client](const mtx::responses::Login &res, RequestErr err) {
                 if (err) {
                     cout << "There was an error during login: " << err->matrix_error.error
                          << "\n";
                     return;
                 }
 
                 cout << "Logged in as: " << res.user_id.to_string() << "\n";
                 client->set_access_token(res.access_token);
 
                 client->sync(
                         "",
                         "",
                         false,
                         0,
                         std::bind(
                                 &initial_sync_handler, client, std::placeholders::_1, std::placeholders::_2));
             });
 
     client->close();
 
     return 0;
 }