BabelServer.hpp

Go to the documentation of this file.

//
// Created by cbihan on 05/10/2021.
//
 
#pragma once
 
#include "AsioTCPServer.hpp"
#include "AsioTCPConnection.hpp"
#include "Network/Message.hpp"
#include "Network/RFCCodes.hpp"
#include "Utilities/FreeList.hpp"
#include "User.hpp"
#include <array>
#include <functional>
#include "Call.hpp"
#include <iostream>
#include <algorithm>
#include <string>
#include <map>
#include <iomanip>
#include <sstream>
#include <utility>
 
namespace Babel
{
    class BabelServer : public AsioTCPServer<RFCCodes>
    {
    public:
 
        void onMessage(std::shared_ptr<ITCPConnection<RFCCodes>> client, Message<RFCCodes> &msg) override;
 
        bool onClientConnect(std::shared_ptr<ITCPConnection<RFCCodes>> client) override;
 
        void onClientDisconnect(std::shared_ptr<ITCPConnection<RFCCodes>> client) override;
 
        Message<RFCCodes> login(std::shared_ptr<ITCPConnection<RFCCodes>> connection, Message<RFCCodes> message);
 
        Message<RFCCodes> listUsers(std::shared_ptr<ITCPConnection<RFCCodes>> connection, Message<RFCCodes> message);
 
        Message<RFCCodes> callUser(std::shared_ptr<ITCPConnection<RFCCodes>> connection, Message<RFCCodes> message);
 
        Message<RFCCodes> joinCall(std::shared_ptr<ITCPConnection<RFCCodes>> connection, Message<RFCCodes> message);
 
        Message<RFCCodes> denyCall(std::shared_ptr<ITCPConnection<RFCCodes>> connection, Message<RFCCodes> message);
 
        Message<RFCCodes> hangUpCall(std::shared_ptr<ITCPConnection<RFCCodes>> connection, Message<RFCCodes> message);
 
    private:
 
        bool getUserByUsername(const std::string &username, User &user);
 
        bool isValidCallId(int callId) const;
 
        Message<RFCCodes> &getCallAllIPs(Message<RFCCodes> &m, const Call &call);
 
        std::shared_ptr<ITCPConnection<RFCCodes>> getConnectionById(uint64_t id) const;
 
        void messageAllParticipants(Call &call, const Message<RFCCodes> &m);
 
        void announceUserLeftCall(Call &call, const ITCPConnection<RFCCodes> &connectionLeaving);
 
 
        std::map<uint64_t, User> _users;
 
        FreeList<Call> ongoingCalls;
 
        struct RequestHandler
        {
            std::function<Message<RFCCodes>(std::shared_ptr<ITCPConnection<RFCCodes>>, Message<RFCCodes>)> method;
            bool loginRequired;
        };
 
        std::map<RFCCodes, RequestHandler> requestsHandlers{
            {RFCCodes::Login,
                             {
                                 [this](std::shared_ptr<ITCPConnection<RFCCodes>> c,
                                        Message<RFCCodes> m) { return this->login(std::move(c), std::move(m)); },
                                 false
                             }},
            {RFCCodes::ListUsers,
                             {
                                 [this](std::shared_ptr<ITCPConnection<RFCCodes>> c, Message<RFCCodes> m) {
                                     return this->listUsers(std::move(c), std::move(m));
                                 },
                                 false
                             }},
            {RFCCodes::CallUser, {
                                 [this](std::shared_ptr<ITCPConnection<RFCCodes>> c, Message<RFCCodes> m) {
                                     return this->callUser(std::move(c), std::move(m));
                                 },
                                 true
                             }},
            {RFCCodes::JoinCall,
                             {
                                 [this](std::shared_ptr<ITCPConnection<RFCCodes>> c, Message<RFCCodes> m) {
                                     return this->joinCall(std::move(c), std::move(m));
                                 },
                                 true
                             }},
            {RFCCodes::DenyCall,
                             {
                                 [this](std::shared_ptr<ITCPConnection<RFCCodes>> c, Message<RFCCodes> m) {
                                     return this->denyCall(std::move(c), std::move(m));
                                 },
                                 true
                             }},
            {RFCCodes::HangUp,
                             {
                                 [this](std::shared_ptr<ITCPConnection<RFCCodes>> c, Message<RFCCodes> m) {
                                     return this->hangUpCall(std::move(c), std::move(m));
                                 },
                                 true
                             }}
        };
 
    };
}