MWSE/Source/Services/Auth.js

const { Client } = require("../Client.js");
let {addService, addListener} = require("../WebSocket.js");

addListener('disconnect',(global, xclient)=>{
    const {intersection, pairs} = xclient.getSucureClients();
    for (const [clientid, client] of intersection)
    {
        client.send([
            {
                id: clientid
            },
            "peer/disconnect"
        ])
    }

    for (const [id, peer] of pairs)
    {
        peer.pairs.delete(xclient.id);
        xclient.pairs.delete(id);
    }
});

addService(({
    client,
    message,
    end,
    next
})=>{
    let {type,to,value,name} = message;
    
    switch(type)
    {
        case "auth/pair-system":{
            if(value == 'everybody')
            {
                client.requiredPair = true;
                end({status:"success"});
                client.sync('requiredPair');
            }
            if(value == 'disable')
            {
                client.requiredPair = false;
                end({status:"success"});
                client.sync('requiredPair');
                //CLIENT_UPDATE_PROP(client.id, 'requiredPair', client.requiredPair);
            }
            break;
        }
        case "my/socketid":{
            end(client.id);
            break;
        }
        case 'auth/public':{
            client.requiredPair = false;
            client.sync('requiredPair');
            return end({
                value: 'success',
                mode: 'public'
            })
        }
        case 'auth/private':{
            client.requiredPair = true;
            client.sync('requiredPair');
            return end({
                value: 'success',
                mode: 'private'
            })
        }
        case 'request/pair':{
            if(Client.clients.has(to)){
                return end({
                    status: 'fail',
                    message: 'CLIENT-NOT-FOUND'
                })
            };
            let pairclient = Client.clients.get(to);
            if(pairclient.pairs.has(client.id))
            {
                return end({
                    status: 'success',
                    message: 'ALREADY-PAIRED'
                })
            }
            if(client.pairs.has(to))
            {
                return end({
                    status: 'fail',
                    message: 'ALREADY-REQUESTED'
                })
            };
            end({
                status: 'success',
                message: 'REQUESTED'
            })
            client.peerRequest(pairclient);
            break;
        }
        case 'accept/pair':{
            if(Client.clients.has(to)){
                return end({
                    status: 'fail',
                    message: 'CLIENT-NOT-FOUND'
                })
            };
            let pairclient = Client.clients.get(to);
            if(pairclient.pairs.has(client.id))
            {
                return end({
                    status: 'success',
                    message: 'ALREADY-PAIRED'
                })
            }
            if(!client.pairs.has(to))
            {
                return end({
                    status: 'fail',
                    message: 'NOT-REQUESTED-PAIR'
                })
            }
            client.acceptPeerRequest(pairclient);
            break;
        }
        case 'reject/pair':{
            if(Client.clients.has(to)){
                return end({
                    status: 'fail',
                    message: 'CLIENT-NOT-FOUND'
                })
            };
            let pairclient = Client.clients.get(to);
            if(pairclient.pairs.has(client.id))
            {
                return end({
                    status: 'success',
                    message: 'ALREADY-PAIRED'
                })
            }
            if(!client.pairs.has(to))
            {
                return end({
                    status: 'fail',
                    message: 'NOT-REQUESTED-PAIR'
                })
            }
            client.rejectPeerRequest(pairclient);
            break;
        }
        case 'end/pair':{
            if(Client.clients.has(to)){
                return end({
                    status: 'fail',
                    message: 'CLIENT-NOT-FOUND'
                })
            };
            let pairclient = Client.clients.get(to);
            if(!pairclient.pairs.has(client.id))
            {
                return end({
                    status: 'success',
                    message: 'NOT-PAIRED'
                })
            }
            client.rejectPeerRequest(pairclient);
            break;
        }
        case 'pair/list':{
            end({
                type:'pair/list',
                value: client.pairList()
            })
            break;
        }
        case 'is/reachable':{
            if(Client.clients.has(to))
            {
                let otherPeer = Client.clients.get(to);
                if(otherPeer.requiredPair && !otherPeer.pairs.has(to))
                {
                    end(false);
                }else{
                    end(true);
                }
            }else{
                end(false);
            }
            break;
        }
        case 'auth/info':{
            client.info.set(name, value);
            let clients = client.getSucureClients();
            for (const [,spair] of clients.pairs)
            {
                spair.send([{
                    from: client.id,
                    name,
                    value
                },"pair/info"]);
            };
            for (const [,spair] of clients.roompairs)
            {
                spair.send([{
                    from: client.id,
                    name,
                    value
                },"pair/info"]);
            };
            process.send({
                type: 'AUTH/INFO',
                uuid: client.id,
                name,
                value
            });
            return end({
                status: 'success'
            });
        }
        case 'peer/info':{
            if(client.isSecure(message.peer))
            {
                let info = {};
                let peer = Client.clients.get(message.peer);
                peer.info.forEach((value, name) => info[name] = value);
                return end({
                    status: "success",
                    info
                });
            }else{
                return end({
                    status: "fail",
                    message: "unaccessible user"
                });
            }
        }
        default:{
            next();
        }
    }
});

process.on('message',({type, uuid, value, name}) => {
    switch(type)
    {
        case "AUTH/INFO":{
            let client = Client.clients.get(uuid);
            if(client)
            {
                client.info.set(name, value);
            }
            break;
        }
    }
})