added

backend/.env

@@ -1,4 +1,4 @@
-mongoUrl = mongodb+srv://jackayron:[email protected].mongodb.net/streamspace?retryWrites=true&w=majority
+mongoUrl = mongodb+srv://khidki:[email protected].mongodb.net/StreamSpace?retryWrites=true&w=majority
 port = 8080
 accessKey = superman
 refreshKey = batman

backend/chat/chat.js → backend/chatting.js

@@ -2,29 +2,29 @@ const app=require("express")()
 const server=require("http").createServer(app)
 const io=require("socket.io")(server)
 let arr=[]
-io.on("connect",(socket)=>{
+io.on("connection",(socket)=>{
     console.log(socket.id)
-    socket.on("jroom",(data)=>{
-        const user=jroom(socket.id,data.name,data.roomno)
+    socket.on("joinroom",(data)=>{
+        const user=joinroom(socket.id,data.name,data.roomno)
         let name=`${user.name} has joined chat `
         let room=user.room
         socket.join(user.room)
-        socket.broadcast.emit("welcome_msg",({
+        socket.broadcast.emit("welcomemsg",({
             name,
             room
         }))
-        io.to(room).emit("room_no",room)
+        io.to(room).emit("roomno",room)
         socket.on("msg",(data)=>{
             let room=data.room
-            io.to(room).emit("incoming_msg",data)
+            io.to(room).emit("incomingmsg",data)
         })
         socket.on("exit",(data)=>{
-            socket.broadcast.emit("exit_msg",`${data.name} has leaved the Chat`)
+            socket.broadcast.emit("exitmsg",`${data.name} has leaved the Chat`)
         })
     })
 })
 
-function jroom(id,name,room) {
+function joinroom(id,name,room) {
     let obj={
         id,
         name,
@@ -34,4 +34,4 @@ function jroom(id,name,room) {
     return obj
 }
 
-server.listen(5050,()=>console.log("server running..."))
+server.listen(4500,()=>console.log("server running..."))

backend/db.js

@@ -0,0 +1,5 @@
+const mongoose=require("mongoose")
+require("dotenv").config()
+const connection=mongoose.connect(process.env.mongoUrl);
+
+module.exports={connection}

backend/dummy.txt

@@ -0,0 +1,2 @@
+hello backend
+hi backend

backend/index.js

@@ -1,52 +1,67 @@
-const express = require("express");
-const { connection } = require("./config/db");
-const { userRoute } = require("./routes/userRoute.routes");
-// const { auth } = require("./midleware/auth.middleware");
-const cookieParser = require("cookie-parser");
-const cors = require("cors");
-const session = require("express-session");
-const { otpRouter } = require("./routes/otproutes.routes");
-const app = express();
-app.use(express.json());
-app.use(cors());
-app.use(cookieParser());
-const port = process.env.port;
-require("dotenv").config();
+const express=require("express");
+const { connection } = require("./db");
+const { authentication } = require("./middleware/authentication");
+const { userRoute } = require("./routes/userRoute");
+const cookieParser = require('cookie-parser')
+const cors=require("cors");
+const app=express();
+app.use(express.json())
+app.use(cors())
+app.use(cookieParser())
+const port=process.env.port;
+require('dotenv').config();
+const expressWinston= require("express-winston")
+const winston= require("winston");
+require("winston-mongodb")
 
+app.use(expressWinston.logger({
+    transports: [
+      // new winston.transports.File({
+      //   level:"info",
+      //   json:true,
+      //   filename:"alllogs.json"
+      // }),
+      new winston.transports.MongoDB({
+        level:"silly",
+        db:process.env.mongoUrl,
+        json:true
+
+      })
+    ],
+    format: winston.format.combine(
+      winston.format.colorize(),
+      winston.format.json()
+    ),
+  }));
 
-// this is the home route---
-app.get("/", (req, res) => {
-  res.send("home page");
-});
 
-// attaching the user login and register routes----
-app.use("/users", userRoute);
-app.use(
-  session({
-    resave: true,
-    secret: "your secret",
-    saveUninitialized: true,
-  })
-);
+// this is the home route---
+app.get("/",(req,res)=>{
+    res.send("home page");
+})
 
 
-// app.use(auth)
-// app.get("/check",async(req,res)=>{
-//   try {
-//     res.status(200).send({success:"successful"})
-//   } catch (error) {
-//     res.status(404).send({err:error})
-//   }
-
-// })
+// attaching the user login and register routes----
+app.use("/users",userRoute)
+// user authentication----
+app.use(authentication)
 
-// listening and creating the mongosse connection
-app.listen(port, async () => {
+app.get("/check",async(req,res)=>{
   try {
-    await connection;
-    console.log("Db is connected");
+    res.status(200).send({success:"successful"})
   } catch (error) {
-    console.log({ err: error });
+    res.status(404).send({err:error})
   }
-  console.log(`server is running at port ${port}`);
-});
+
+})
+// listening and creating the mongosse connection
+app.listen(8998,async()=>{
+    try {
+        await connection
+        console.log(`server is running at port ${port}`);
+    } catch (error) {
+        console.log({"err":error});
+
+    }
+
+})

backend/middleware/authentication.js

@@ -0,0 +1,68 @@
+const jwt = require("jsonwebtoken");
+const { BlockModel } = require("../models/blockUser");
+const { UserModel } = require("../models/userModel");
+require("dotenv").config()
+const fetch = (...args) => import('node-fetch').then(({ default: fetch }) => fetch(...args));
+const authentication = async (req, res, next) => {
+
+    const token = req.cookies.token
+    const refreshToken = req.cookies.reftoken
+    const isBlacklisted = await BlockModel.find({token})
+
+    if (isBlacklisted) {
+        return res.status(401).send('Token is blacklisted');
+
+    }
+
+
+    if (!token) {
+        res.send("Login again")
+        return;
+    }
+    if (token) {
+        jwt.verify(token, process.env.accessKey, async (err, decode) => {
+            if (decode) {
+                req.body.userId = decode.userId;
+
+                const userData= await UserModel.findById({_id:decode.userId})
+                req.user=userData
+                if(!userData){
+                    return res.status(401).json({"err":"unauthorized"})
+                }
+                next()
+            } else {
+                const fetchdata = await fetch("https://wild-gold-betta-fez.cyclic.app/users/refresh", {
+                    headers: {
+                        cookie: `reftoken=${refreshToken}`
+                    }
+                }).then((res) => res.json())
+                if (fetchdata.err) {
+                    res.send("login first")
+                    return;
+                }
+                jwt.verify(fetchdata.token, process.env.accessKey, async (err, decode) => {
+                    if (decode) {
+                        res.cookie("token", fetchdata.token);
+                        req.body.userId = decode.userId;
+                        const userData= await UserModel.findById({_id:decode.userId})
+                        req.user=userData
+                        if(!userData){
+                            return res.status(401).json({"err":"unauthorized"})
+                        }
+                        next()
+                    } else {
+                        res.send("login first")
+                        return;
+                    }
+
+                })
+            }
+        })
+    } else {
+        res.send({ "Msg": "Please login" })
+    }
+}
+
+module.exports = {
+    authentication
+}

backend/models/blockUser.js

@@ -1,8 +1,8 @@
-const mongoose = require("mongoose");
+const mongoose=require("mongoose")
 
-const blockSchema = mongoose.Schema({
-  token: { type: String, required: true },
-});
+const blockSchema=mongoose.Schema({
+    token:{type:String,required:true}
+})
 
-const BlockModel = mongoose.model("blacklist", blockSchema);
-module.exports = { BlockModel };
+const BlockModel=mongoose.model("blog",blockSchema)
+module.exports={BlockModel}

backend/models/userModel.js

@@ -1,11 +1,10 @@
+const mongoose=require('mongoose')
 
-const mongoose = require("mongoose");
+const userSchema=mongoose.Schema({
+    name:{type:String,required:true},
+    email:{type:String,required:true},
+    password:{type:String,required:true} 
+})
 
-const userSchema = mongoose.Schema({
-  name: { type: String, required: true },
-  email: { type: String, required: true },
-  password: { type: String, required: true },
-});
-
-const UserModel = mongoose.model("user", userSchema);
-module.exports = { UserModel };
+const UserModel=mongoose.model("user",userSchema);
+module.exports={UserModel}