server.js

require("dotenv").config();
const express = require("express");
const http = require("http");
const socket = require("socket.io");
const bodyParser = require('body-parser');
const path = require("path");
const jwt = require('jsonwebtoken');
const jwt_decode = require('jwt-decode');
const crypto = require("crypto");
const cookieParser = require('cookie-parser');

const withAuth = require('./middleware');
const createPayment = require('./Stripe/createPayment');
const createStripeCustomer = require('./Stripe/createStripeCustomer');


const secret = process.env.SECRET;

const app = express();
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(cookieParser());

const server = http.createServer(app);
const io = socket(server);
const port = process.env.PORT || 8000;

var firebase = require("firebase/app");
require("firebase/auth");
require("firebase/firestore");


var firebaseConfig = {
    apiKey: process.env.API_KEY,
    authDomain: "professionall.firebaseapp.com",
    projectId: "professionall",
    storageBucket: "professionall.appspot.com",
    messagingSenderId: "628673579093",
    appId: "1:628673579093:web:cbb614b2bf2ed592fc2cdc",
    measurementId: "G-LT02G7RWYZ"
};

firebase.initializeApp(firebaseConfig);

const firestore = firebase.firestore();


var nodemailer = require('nodemailer');

app.get('/checkToken', withAuth, function(req, res) {
    res.sendStatus(200);
});

var transporter = nodemailer.createTransport({
    service: 'hotmail',
    auth: {
        user: process.env.EMAIL,
        pass: process.env.PASSWORD
    }
}); 



app.post('/api/login/', async(req, res) => {
    console.log(req.body);

    var theUser = {};
    //const newDoc = await firestore.collection('users').add(req.body);
    await firebase.auth().signInWithEmailAndPassword(req.body.email, req.body.password)
        .then((userCredential) => {
            // Signed in 
            theUser = userCredential;

        })
        .catch((error) => {
            var errorCode = error.code;
            var errorMessage = error.message;
            // ..
            res.status(400).send(`${errorMessage} and ${errorCode}`);
        });

    console.log(theUser);
    var email = theUser.user.email;
    var user = theUser.user.uid;

    const callDoc = firestore.collection('users').doc(user);
    var doc = await callDoc.get();
    var user_data = doc.data();

    const payload = {
        email: email,
        user: user,
        role: user_data.role,
        stripe_id: user_data.stripe_id,
        name: user_data.name
    };

    const token = jwt.sign(payload, secret, {
        expiresIn: '24h'
    });
    res.cookie('token', token, { httpOnly: true })
        .sendStatus(200);

});

app.get('/logout', function(req, res) {
    res.cookie('token', null, { maxAge: 0 })
        .sendStatus(200);
});

app.get('/api/decode/', async(req, res) => {
    const token = req.cookies.token;
    if (!token) res.status(400).send("Authentication issue")
    console.log(token);
    var decoded = jwt_decode(token, process.env.SECRET);
    console.log(jwt_decode(token, process.env.SECRET));
    res.status(201).send(decoded);

});


app.post('/api/register/', async(req, res) => {
    //const newDoc = await firestore.collection('users').add(req.body);
    let uid = "";
    await firebase.auth().createUserWithEmailAndPassword(req.body.email, req.body.password)
        .then((userCredential) => {
            // Signed in 
            var user = userCredential.user.uid;
            var email = userCredential.user.email;


            firestore.collection('users').doc(user).set({
                name: req.body.name,
                appointments: [],
                role: 'user',
                email: email
            })


            uid = user;
        })
        .catch((error) => {
            var errorCode = error.code;
            var errorMessage = error.message;
            // ..
            res.status(400).send(`${errorMessage} and ${errorCode}`);
        });


    const customer_stripe_id = await createStripeCustomer(req.body.name, req.body.email);
    firestore.collection('users').doc(uid).update({ stripe_id: customer_stripe_id })


    const payload = {
        email: req.body.email,
        user: uid,
        role: "user",
        stripe_id: customer_stripe_id,
        name: req.body.name
    };

    const token = jwt.sign(payload, secret, {
        expiresIn: '24h'
    });
    res.cookie('token', token, { httpOnly: true })
        .sendStatus(200);
});


app.post('/api/reset/', async(req, res) => {
    console.log(req.body);

    firebase.auth().sendPasswordResetEmail(
            req.body.email)
        .then(function() {
            console.log("sent");
        })
        .catch(function(error) {
            console.log(error);
        });

});


app.post('/api/appointment/create', async(req, res) => {

    //create email to inform expert that he has a new appointment pending

    const appointment = {
        customer: req.body.customer,
        expert: req.body.expert,
        day: req.body.day,
        hour: req.body.hour,
        price: req.body.price,
        service: req.body.service,
        uuid: crypto.randomBytes(16).toString("hex"),
        status: 0,
        professional_time:0,
        user_time:0
    };

    const newDoc = await firestore.collection('appointments').add(appointment);

    const app_id = newDoc.id;

    await firestore.collection('users').doc(appointment.customer).update({
        appointments: firebase.firestore.FieldValue.arrayUnion(app_id)
    })

    

    const exp = firestore.collection('users').doc(appointment.expert);
    var exp_data = await exp.get();
    var dataa = exp_data.data();
    
    let hoursOff = dataa.hoursOff

    if(!hoursOff[req.body.day])hoursOff[req.body.day]=[]

    hoursOff[req.body.day].push(req.body.hour)
    
    await firestore.collection('users').doc(appointment.expert).update({
        appointments: firebase.firestore.FieldValue.arrayUnion(app_id),
        hoursOff: hoursOff
    })
    
    res.status(200).send("ok");
});

app.post('/api/appointment/review', async(req, res) => {

    const appointment_id = req.body.appointment;
    const review = req.body.review;
    const customer = req.body.customer;
    const rating = req.body.rating;
    const professional_id = req.body.expert;

    console.log(req.body)
    const appointment = await firestore.collection('appointments').doc(appointment_id).get();
    const appointment_data = appointment.data();
    console.log(appointment_data);

    await firestore.collection('users').doc(professional_id).collection('reviews').add({
        customer: customer,
        review: review,
        rating: rating
    })


    res.status(200).send("ok");
});

app.get('/api/search', async(req, res) => {
    const search = req.query.search.toLowerCase();
    console.log(search)
    let results = [];
    const users = await firestore.collection('users').get();

    users.forEach(doc => {
        const user_data = doc.data();
        if (user_data.role == "professional") {
            if (user_data.profession.toLowerCase() == search) {
                results.push({
                    name: user_data.name,
                    job: user_data.profession,
                    info: user_data.about,
                    id: doc.id,
                    url: user_data.photo,
                    rating: user_data.stars
                });
            }
        }
    })

    res.status(200).send(results);

})

app.get('/api/user/get', async(req, res) => {
    let user = req.query.user || req.body.user;
    const callDoc = firestore.collection('users').doc(user);
    var doc = await callDoc.get();

    var data = doc.data();

    let reviews = [];
    let average = 0;
    let number=0;
    const reviewsDic = await firestore.collection('users/'+user+'/reviews').get();
    reviewsDic.docs.forEach((document) => {
        const data = document.data();
        reviews.push(data)
        
        average+=parseFloat(data.rating)
        number++;
    });
    
    data.reviews = reviews;


    data.stars = parseFloat(average/number).toFixed(1);


    


    if (req.query.appointments) {
        let appointments = data.appointments;
        const fullAppointments = [];

        for (var i = 0; i < appointments.length; i++) {

            const appointment = firestore.collection('appointments').doc(appointments[i]);
            var appointment_data = await appointment.get();

            var theData = appointment_data.data();

            theData.appointment_id = appointments[i]



            const expert = firestore.collection('users').doc(theData.expert);
            var expert_data = await expert.get();
            expert_data = expert_data.data();
            theData.expert_name = expert_data.name


            const customer = firestore.collection('users').doc(theData.customer);
            var customer_data = await customer.get();
            customer_data = customer_data.data();

            theData.customer_name = customer_data.name;
            //get experts name 
            fullAppointments.push(theData);

        }

        data.appointments = fullAppointments;
    }

    res.status(201).send(data);
});


app.post('/api/appointment/approve/', async(req, res) => {
    await firestore.collection('appointments').doc(req.body.id).update({
        status: req.body.status
    })

    const message = req.body.status == 1?"confirmed":"denied";

    const appointment = firestore.collection('appointments').doc(req.body.id);
    var appointment_data = await appointment.get();
    var theData = appointment_data.data();

    const customer_id = theData.customer;
    const expert_id = theData.expert;


    const cust = firestore.collection('users').doc(customer_id);
    var cust_data = await cust.get();
    const customer = cust_data.data();

    const exp = firestore.collection('users').doc(expert_id);
    var exp_data = await exp.get();
    const expert = exp_data.data();


    var mailOptions = {
        from: {
            name: 'Find Expert Online',
            address: process.env.EMAIL
        },
        to: customer.email,
        subject: 'Your Appointment',
        text: `Your appointment with ${expert.name} at ${theData.day + ","+theData.hour} for "${theData.service}" has been ${message}.`
    };
    
    transporter.sendMail(mailOptions, function(error, info){
        if (error) {
        console.log(error);
        } else {
        console.log('Email sent: ' + info.response);
        }
    });
    
    


    res.status(200).send("ok");

});

app.post('/api/appointments/time', async(req, res) => {
    const appointment_id = req.body.id;
    const role = req.body.role;


    const appointment = firestore.collection('appointments').doc(appointment_id);
    var appointment_data = await appointment.get();

    var theData = appointment_data.data();

    console.log(theData);

    let professional_time = theData.professional_time?theData.professional_time+10:10;
    let user_time = theData.user_time?theData.user_time+10:10;

    if(role == 'professional'){
        await firestore.collection('appointments').doc(appointment_id).update({
            professional_time:professional_time
        })
    }else{
        await firestore.collection('appointments').doc(appointment_id).update({
            user_time: user_time
        })
    }

    


    res.status(201).send("ok");
});




app.get('/api/expert/getAppointment', async(req, res) => {
    const callDoc = firestore.collection('users').doc('uDOmxlKpwHvQaJ0N1Dds');
    var doc = await callDoc.get();
    console.log(doc.data());
    res.status(201).send(doc.data());
});


app.post('/api/user/edit', async(req, res) => {
    const user = db.collection('users').doc(req.body.id);

    res = await user.update({ name: req.body.name });

});

app.post('/api/expert/edit', async(req, res) => {
    const expert = req.body.expert;

    console.log(req.body)
    firestore.collection('users').doc(expert).update(req.body)

    res.status(200).send("ok");

});



app.post('/api/stripe/createCustomer', async(req, res) => {
    const name = req.body.name;
    const email = req.body.email;
    const customer_fb_id = req.body.id;

    const customer_stripe_id = await createStripeCustomer(name, email);

    firestore.collection('users').doc(customer_fb_id).update({ stripe_id: customer_stripe_id })

    res.status(200).send("ok");

});


app.get('/api/appointment/:id', async(req, res) => {
    const id = req.params.id.toString();

    const appointment = firestore.collection('appointments').doc(id);
    var appointment_data = await appointment.get();
    var theData = appointment_data.data();

    res.status(200).send(theData);

});



app.post('/api/stripe/createPayment', async(req, res) => {
    const customer = req.body.id;
    const price = req.body.price;
    const appointment_id = req.body.appointment;

    const stripe_pi_id = await createPayment(customer, price);

    if (stripe_pi_id) firestore.collection('appointments').doc(appointment_id).update({ status: 2 })


    res.status(200).send("ok");

});





//instead of const rooms we will access firebase and see if in the assigned uuid room someone is currently inside and waiting
//every time a user enters or leaves the room we have to keep a log about his time of arrival and departure from the room
const rooms = {};
const chats = {};

io.on("connection", socket => {

    socket.on("profile", profile_id => {

        const callDoc = firestore.collection('users').doc(profile_id);
        var doc;
        (async() => {
            doc = await callDoc.get();
        })();

    });

    socket.on("join room", roomID => {
        console.log("the socket is:" + socket.id)
        console.log(rooms[roomID])

        if (rooms[roomID]) {
            const me = rooms[roomID].find(id => id === socket.id);
            if (!me) rooms[roomID].push(socket.id);

        } else {
            rooms[roomID] = [socket.id];
        }
        const otherUser = rooms[roomID].find(id => id !== socket.id);

        if (otherUser) {
            socket.emit("other user", otherUser);
            socket.to(otherUser).emit("user joined", socket.id);
        } else {
            socket.emit("no user", "23");
        }
    });

    socket.on("join chat", roomID => {

        if (chats[roomID]) {
            chats[roomID].push(socket.id);
        } else {
            chats[roomID] = [socket.id];
        }
        const otherUser = chats[roomID].find(id => id !== socket.id);

        if (otherUser) {
            socket.emit("other user chat", otherUser);
            socket.to(otherUser).emit("user joined chat", socket.id);
        }
        socket.emit("your id", socket.id);

    });

    socket.on("send message", body => {
        io.emit("message", body)
    })

    socket.on("offer", payload => {
        io.to(payload.target).emit("offer", payload);
    });

    socket.on("answer", payload => {
        io.to(payload.target).emit("answer", payload);
    });

    socket.on("ice-candidate", incoming => {
        io.to(incoming.target).emit("ice-candidate", incoming.candidate);
    });
});

if (process.env.PROD) {
    app.use(express.static(path.join(__dirname, './client/build')));
    app.get('*', (req, res) => {
        res.sendFile(path.join(__dirname, './client/build/index.html'));
    })
}


server.listen(port, () => console.log(`🚀🚀🚀🚀🚀server is running on port ${port}🚀🚀🚀 `));