Adnan skeleton

backend/.gitignore

@@ -1,3 +1,4 @@
 node_modules
 .env
-PDFs/*
+PDFs/*
+pdf-uploads/*

backend/openAIInterface.js → backend/controllers/aiController.js

@@ -16,7 +16,14 @@ const {MessagesPlaceholder} = require('@langchain/core/prompts');
 const axios = require('axios');
 
 // vectorize the pdf file into a local vector store
-const vectorizePDF = async (pdfPath) => {
+// param: pdfPath
+exports.vectorizePDF = async(req, res) => {
+  const { pdfPath } = req.body;
+
+  if(!pdfPath) {
+    return res.status(400);
+  }
+
   const fullPdfPath = `./${pdfPath}.pdf`;
   const VECTOR_STORE_PATH = `./${pdfPath}.index`;
 
@@ -28,7 +35,6 @@ const vectorizePDF = async (pdfPath) => {
   } else {
     // If the vector store file doesn't exist, create it
     console.log('Creating vector store...');
-
     //const text = fs.readFileSync("murder_mystery_show.txt", "utf8");    // for .txt files
     const dataBuffer = fs.readFileSync(fullPdfPath);
     const data = await pdf(dataBuffer);
@@ -54,52 +60,81 @@ const genSessionID = async () => {
 }
 
 // generate a new conversation, return the sessionId
-const createConvo = async (pdfName) => {
+// param: pdfName
+// response: convID of new convo
+exports.createConvo = async(req, res) => {
+  const { pdfName } = req.body;
+
+  if(!pdfName ) {
+    return res.status(400);
+  }
+
   const id = await genSessionID();
   const postData = {
     "convID": id,
     "pdfName": pdfName,
     "qaSequence": []
   };
 
-  axios.post('http://localhost:3500/api/createConversation', postData)
+  await axios.post('http://localhost:3500/api/createConversation', postData)
     .catch(error => {
       console.error('Error:', error);
     });
 
-  return id;
+  res.status(201).json({ convID: id });
 }
 
 
-const convo = {
+exports.convo = {
   chatHistory: [],
 
   // upon switching to a new chat, update local chatHistory with chat history from mongoDB
-  updateHistory: async function(id) {
-    axios.get('http://localhost:3500/api/getConversation/?convID=' + id)
+  // params: convID
+  // response: qaSequence
+  updateHistory: async (req, res) => {
+    const { id } = req.body;
+    if(!id ) {
+      return res.status(400);
+    }
+    console.log("id: ", id);
+
+    axios.post('http://localhost:3500/api/getConversation/?convID=' + id)
     .then(response => {
 
       // clear local chatHistory
-      this.chatHistory = [];
-
+      exports.convo.chatHistory = [];
+      
       // Access the chat history from the response data
       const QAs = response.data.qaSequence;
+      console.log('here');
+      console.log(QAs);
       QAs.forEach(document => {
         const question = document.question;
         const answer = document.answer;
 
         // add entries to chat history
-        this.chatHistory.push(new HumanMessage(question));
-        this.chatHistory.push(new AIMessage(answer));
+        exports.convo.chatHistory.push(new HumanMessage(question));
+        exports.convo.chatHistory.push(new AIMessage(answer));
       });
+      // return the qaSequence in the response to display on frontend
+      res.status(201).json({ qaSequence: QAs });
     })
       .catch(error => {
         console.error('Error:', error);
       }); 
   },
 
   // pass in user input to chat bot
-  askQuestion: async function(id, pdfPath, user_input) {
+  // params: convID, pdfPath, user_input
+  // response: AI response
+  askQuestion: async (req, res) => {
+    const { id, pdfPath, input } = req.body;
+    const user_input = `${input}`;
+
+    if(!id || !pdfPath || !user_input) {
+      return res.status(400);
+    }
+
     const model = new ChatOpenAI({});
 
     // vector store retriever
@@ -153,8 +188,8 @@ const convo = {
     });
 
     // add entries to chat history
-    this.chatHistory.push(new HumanMessage(user_input));
-    this.chatHistory.push(new AIMessage(response.answer));
+    exports.convo.chatHistory.push(new HumanMessage(user_input));
+    exports.convo.chatHistory.push(new AIMessage(response.answer));
 
     // add entries to database
     const putData = {
@@ -165,13 +200,16 @@ const convo = {
       .catch(error => {
         console.error('Error:', error);
       }); 
-
-    return response.answer;
+
+    res.status(201).json({
+      message: response.answer
+    });
 
   }
+
 }
 
 
 
 
-module.exports = {vectorizePDF, createConvo, convo};
+//module.exports = {vectorizePDF, createConvo, convo};

backend/controllers/authController.js

@@ -0,0 +1,49 @@
+const users = require('../model/userlogin');
+const bcrypt = require('bcryptjs');
+const jwt = require('jsonwebtoken');
+
+require('dotenv').config();
+
+const handleLogin = async (req, res) => {
+    const { username, password } = req.body;
+    if (!username || !password) {
+        return res.status(400).json({ message: 'Username and Password are required.' });
+    }
+    const user = await users.findOne({ username: username }).exec();
+    if (!user) {
+        return res.sendStatus(401);
+    }
+    const match = await bcrypt.compare(password, user.password);
+    if (match) {
+        const convos = []; // Implement later
+        const accessToken = jwt.sign({ username: user.username }, process.env.ACCESS_TOKEN_SECRET, { expiresIn: '5m' });
+        const refreshToken = jwt.sign({ username: user.username }, process.env.REFRESH_TOKEN_SECRET, { expiresIn: '1d' });
+
+        user.refreshToken = refreshToken;
+        const result = await user.save();
+        console.log(result);
+
+        res.cookie('jwt', refreshToken, { httpOnly: true, sameSite: 'None', maxAge: 86400000 });
+        res.json({ convos, accessToken }); // Array of conversation objects, implement later
+    } else {
+        res.sendStatus(401);
+    }
+}
+
+const getUserName = async (req, res) => {
+    const token = req.headers['authorization']?.split(' ')[1]; // Bearer token
+    if (!token) {
+        return res.status(401).json({ message: 'No token provided.' });
+    }
+
+    try {
+        const decoded = jwt.verify(token, process.env.ACCESS_TOKEN_SECRET);
+        return res.json({ username: decoded.username });
+    } catch (error) {
+        return res.status(403).json({ message: 'Invalid token.' });
+    }
+};
+
+
+
+module.exports = { handleLogin, getUserName }

backend/controllers/conversationController.js

@@ -1,6 +1,6 @@
 const Conversation = require("../model/conversation");
 
-const fetchConversation = async (req, res) => {
+exports.fetchConversation = async (req, res) => {
   try {
     const convID = req.query.convID;
     if (!convID) {
@@ -17,8 +17,7 @@ const fetchConversation = async (req, res) => {
   }
 };
 
-
-const newConversation = async(req, res) => {
+exports.newConversation = async(req, res) => {
   try {
     const { convID, pdfName, qaSequence } = req.body;
 
@@ -38,7 +37,7 @@ const newConversation = async(req, res) => {
   }
 }
 
-const addQA = async(req, res) => {
+exports.addQA = async(req, res) => {
   try {
     const { convID } = req.params;
     const { question, answer } = req.body;
@@ -59,5 +58,3 @@ const addQA = async(req, res) => {
     console.error(err);
   }
 }
-
-module.exports = { fetchConversation, newConversation, addQA }

backend/controllers/fileController.js

@@ -0,0 +1,46 @@
+const multer = require('multer');
+const path = require('path');
+const fs = require('fs');
+
+// Helper function to ensure directory exists
+const ensureDirSync = (dirPath) => {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        console.log('UserID:', req.body.userId);
+        console.log('ConversationID:', req.body.conversationId);
+        const userId = req.body.userId;
+        const conversationId = req.body.conversationId;
+        if (!userId || !conversationId) {
+            return cb(new Error("Missing user ID or conversation ID"), false);
+        }
+
+        const uploadPath = path.join('pdf-uploads', userId);
+        ensureDirSync(uploadPath);
+        cb(null, uploadPath);
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+        //cb(null, `${file.fieldname}-${Date.now()}${path.extname(file.originalname)}`);
+    }
+});
+
+const upload = multer({ storage: storage });
+
+exports.uploadFile = upload.single('file');
+
+exports.handleFileUpload = (req, res) => {
+    if (!req.file) {
+        return res.status(400).send('No file uploaded.');
+    }
+    res.send({
+        message: 'File uploaded successfully.',
+        path: req.file.path,
+        fileName: req.file.filename,
+        conversationID: req.conversationId
+    });
+};

backend/controllers/logoutController.js

@@ -0,0 +1,31 @@
+const users = require('../model/userlogin');
+// const jwt = require('jsonwebtoken');
+// require('dotenv').config();
+
+const handleLogout = async (req, res) => {
+    // On client frontend, also delete access token
+
+
+    const cookies = req.cookies;
+    if (!cookies?.jwt) {
+        return res.sendStatus(204);
+    }
+    const refreshToken = cookies.jwt;
+
+    // Is refreshtoken in db?
+    const user = await users.findOne({ refreshToken }).exec();
+    if (!user) {
+        res.clearCookie('jwt', { httpOnly: true, maxAge: 86400000 });
+        return res.sendStatus(403);
+    }
+
+    // Delete refreshToken in db
+    user.refreshToken = '';
+    const result = await user.save();
+    console.log(result);
+
+    res.clearCookie('jwt', { httpOnly: true, maxAge: 86400000 });
+    res.sendStatus(204);
+}
+
+module.exports = { handleLogout }

backend/controllers/refreshTokenController

@@ -0,0 +1,24 @@
+const users = require('../model/userlogin');
+const jwt = require('jsonwebtoken');
+
+const handleRefreshToken = async (req, res) => {
+    const cookies = req.cookies;
+    if (!cookies?.jwt) {
+        return res.sendStatus(401);
+    }
+    const refreshToken = cookies.jwt;
+
+    const user = await users.findOne({ refreshToken }).exec();
+    if (!user) {
+        return res.sendStatus(403);
+    }
+    jwt.verify(refreshToken, process.env.REFRESH_TOKEN_SECRET, (err, decoded) => {
+        if (err || user.username !== decoded.username) {
+            return res.sendStatus(403);
+        }
+        const accessToken = jwt.sign({ username: user.username }, process.env.ACCESS_TOKEN_SECRET, { expiresIn: '30s' });
+        res.json({ accessToken });
+    });
+}
+
+module.exports = { handleRefreshToken }

backend/controllers/registerController.js

@@ -0,0 +1,29 @@
+const users = require('../model/userlogin');
+const bcrypt = require('bcryptjs');
+const jwt = require('jsonwebtoken');
+require('dotenv').config();
+
+const handleNewUser = async (req, res) => {
+    const { username, password } = req.body;
+    if (!username || !password) {
+        return res.status(400).json({ message: 'Username and Password are required.' });
+    }
+    const duplicate = await users.findOne({ username: username }).exec();
+    if (duplicate) {
+        return res.sendStatus(409);
+    }
+    try {
+        const hashword = await bcrypt.hash(password, 10);
+        const result = await users.create({
+            "username": username,
+            "password": hashword
+        });
+
+        console.log(result);
+        res.status(201).json({ message: 'Registration successful' });
+    } catch (err) {
+        res.status(500).json({ message: err.message });
+    }
+}
+
+module.exports = { handleNewUser }