app.js

require('dotenv/config');

const express = require('express')
const app = express();
const server = require('http').Server(app);
const session = require('express-session')
const io = require('socket.io')(server);
const path = require('path');

//const redis = require('redis')
const redis = require('redis-url').connect();
const RedisStore = require('connect-redis')(session)
/*var passportSocketIo = require('passport.socketio');*/
//const cookieParser = require('cookie-parser');
const cookieParser = require('cookie-parser')(process.env.SECRET_KEY_BASE); // <- your secret here

var indexRouter = require('./routes/index');
//const cors = require('cors')

var parser = require('fast-xml-parser');

const RingDaemon = require('./RingDaemon.js');
const passport = require('passport')
    , LocalStrategy = require('passport-local').Strategy;

const sessionStore = new RedisStore({ client: redis });


/*
    Configuation for Passeport Js
*/

// app.use(express.static('public'));
// app.use(cookieParser());
// app.use(bodyParser());
app.use(session({
    store: sessionStore,
    resave: false,
    saveUninitialized: false,
    cookie: {
        secure: process.env.ENVIRONMENT !== 'development' && process.env.ENVIRONMENT !== 'test',
        maxAge: 2419200000
    },
    secret: process.env.SECRET_KEY_BASE
}));

app.use(passport.initialize());
app.use(passport.session());
// app.use(app.router);
//app.use(cors())

/*
    Share sessions between Passport.js and Socket.io
*/

function logSuccess() {
    console.log("passportSocketIo authorized user with Success 😁");
}

function logFail() {
    console.log("passportSocketIo failed to authorized user 👺");
}

/*
io.use(passportSocketIo.authorize({
    key: 'connect.sid',
    secret: process.env.SECRET_KEY_BASE,
    store: sessionStore,
    passport: passport,
    cookieParser: cookieParser,
    //success: logSuccess(),
    // fail: logFail(),
}));
*/

/*

    tempAccounts holds users accounts while tempting to authenticate them on Jams.
    connectedUsers  holds users accounts after they got authenticated by Jams.

    Users should be removed from connectedUsers when receiving a disconnect 
    web socket call

*/
const tempAccounts = {};
const connectedUsers = {};

const callbackMap = {
    "IncomingAccountMessage": (accountId, from, message) => {
        console.log("Received message: " + accountId + " " + from + " " + message["text/plain"]);

        if (parser.validate(message["text/plain"]) === true) {
            console.log(message["text/plain"]);
        } else {

            user = connectedUsers[accountId];
            console.log(user.socketId)
            io.to(user.socketId).emit('receivedMessage', message["text/plain"]);
            //io.emit('receivedMessage', message["text/plain"]);
        }
    },
    "RegistrationStateChanged": (accountId, state, /*int*/ code, detail) => {
        console.log("RegistrationStateChanged: " + accountId + " " + state + " " + code + " " + detail);
        if (state === "REGISTERED") {
            if (tempAccounts[accountId]) {

                const ctx = tempAccounts[accountId];
                ctx.newUser.accountId = accountId;
                ctx.newUser.jamiId = jami.dring.getAccountDetails(accountId).get("Account.username");
                //connectedUsers[accountId] = ctx.newUser;
                ctx.done(null, ctx.newUser);
                delete tempAccounts[accountId];
            }
        } else if (state === "ERROR_AUTH") {
            done(null, false);
            //remove account
        }
    }
}
const jami = new RingDaemon(callbackMap);

passport.serializeUser(function (user, done) {
    console.log(user)
    connectedUsers[user.accountId] = user;
    console.log("=============================SerializeUser called " + user.accountId)
    done(null, user.accountId);
});


const deserializeUser = (id, done) => {
    console.log("=============================DeserializeUser called on: " + id + " " + connectedUsers[id])
    done(null, connectedUsers[id]);
};
passport.deserializeUser(deserializeUser);

//var tempAccountId = '';

passport.use(new LocalStrategy(
    (username, password, done) => {
        const newUser = {};
        newUser.username = username;
        //newUser.socketid = 

        const template = jami.dring.getAccountTemplate("RING");

        /*
            For test purpose we are not checking if a user can SSO using Jams,
            instead we juste create a new user an get he's or her's newly created accountId
        */
        template.set("Account.managerUri", "https://jams.savoirfairelinux.com");
        template.set("Account.managerUsername", username);
        template.set("Account.archivePassword", password);

        const accountId = jami.dring.addAccount(template);

        const newProps = jami.getAccountDetails(accountId);
        console.log(newProps);
        //Object.entries(newProps).forEach(v => console.log(v[0], v[1]))
        //tempAccountId = accountId;
        newUser.accountId = accountId;
        console.log("AccountId: " + accountId);
        connectedUsers[accountId] = newUser;
        tempAccounts[accountId] = { done, newUser };

        //return done(null, newUser);

        /*User.findOne({ username: username }, function (err, user) {
            if (err) { return done(err); }
            if (!user) {
                return done(null, false, { message: 'Incorrect username.' });
            }
            if (!user.validPassword(password)) {
                return done(null, false, { message: 'Incorrect password.' });
            }
            return done(null, user);
        });*/
    }
));

app.post('/api/login', passport.authenticate('local'), function (req, res) {
    res.json({ loggedin: true });
});
app.use('/', indexRouter);

/* GET React App */

app.use(express.static(path.join(__dirname, 'public')))

app.use(function (req, res, next) {
    res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

server.listen(3000);

io.on('connection', (socket) => {
    console.log("Client just connected !")
    socket.on('SendMessage', (data) => {
        console.log("Message " + data.text + " sent to " + data.destinationId + " by " + socket.session.user.accountId);
        const msgMap = new jami.dring.StringMap();
        msgMap.set('text/plain', data.text);
        jami.dring.sendAccountTextMessage(socket.session.user.accountId, data.destinationId, msgMap);
    });
});


io.use((socket, next) => {
    cookieParser(socket.handshake, {}, (err) => {
        if (err) {
            console.log("error in parsing cookie");
            return next(err);
        }
        if (!socket.handshake.signedCookies) {
            console.log("no secureCookies|signedCookies found");
            return next(new Error("no secureCookies found"));
        }
        sessionStore.get(socket.handshake.signedCookies["connect.sid"], (err, session) => {
            socket.session = session;
            if (!err && !session) err = new Error('session not found');
            if (err) {
                console.log('failed connection to socket.io:', err);
            } else {
                console.log(session);
                console.log('successful connection to socket.io ' + session.passport.user);
                const userKey = session.passport.user;
                deserializeUser(userKey, (err, user) => {
                    console.log("deserializeUser: " + user)
                    if (err)
                        return next(err, true);
                    if (!user)
                        return next("User not found", false);

                    console.log("User associated socket id: " + socket.id)
                    user.socketId = socket.id;
                    socket.session.user = user;
                    console.log("User added to session --------> " + user.accountId);
                    /*data[auth.userProperty] = user;
                    data[auth.userProperty].logged_in = true;*/
                    //auth.success(data, accept);
                    next(err, true);
                });
            }
        });
    });
});