Final project - Tavan

backend/middleware/authMiddleware.js

@@ -0,0 +1,22 @@
+import { User } from "../models/User.js"
+
+  export const authenticateUser = async (req, res, next) => {
+    try {
+      const accessToken = req.header("Authorization")
+      const user = await User.findOne({ accessToken: accessToken })
+      if (user) {
+        req.user = user
+        next()
+      } else {
+        res.status(401).json({
+          message: "Authentication missing or invalid.",
+          loggedOut: true
+        })
+      }
+    } catch (error) {
+      res.status(500).json({
+        message: "Internal server error",
+        error: error.message
+      });
+    }
+  }

backend/models/Income.js

@@ -0,0 +1,19 @@
+import mongoose from 'mongoose'
+
+const incomeSchema = new mongoose.Schema({
+ amount: {
+   type: Number,
+   required: true,
+   default: 0,
+ },
+ month: {
+   type: String,
+   required: true,
+ },
+  createdAt: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+export const Income = mongoose.model("Income", incomeSchema);

backend/models/Spendings.js

@@ -0,0 +1,21 @@
+import mongoose from 'mongoose'
+
+const spendingsSchema = new mongoose.Schema({
+  category: {
+    type: String,
+    required: true,
+    enum: ["Rent", "Parking", "Insurance", "Broadband", "Phone", "Grocery", "Shopping", "Entertainment", "Restaurants", "Cafe", "Travel", "Others"]
+},
+  amount: {
+    type: Number,
+    required: true,
+    default: 0,
+  },
+  createdAt: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+
+export const Spendings = mongoose.model("Spendings", spendingsSchema);

backend/models/User.js

@@ -0,0 +1,26 @@
+import mongoose from 'mongoose'
+import crypto from 'crypto'
+
+
+const userSchema = new mongoose.Schema({
+ name: {
+   type: String,
+   required: true,
+ },
+ email: {
+   type: String,
+   required: true,
+   unique: true
+ },
+ password: {
+   type: String,
+   required: true,
+ },
+ accessToken: {
+   type: String,
+   default: () => crypto.randomBytes(128).toString('hex')
+ }
+});
+
+
+export const User = mongoose.model("User", userSchema);

backend/package.json

@@ -2,6 +2,7 @@
   "name": "project-final-backend",
   "version": "1.0.0",
   "description": "Server part of final project",
+  "type": "module",
   "scripts": {
     "start": "babel-node server.js",
     "dev": "nodemon server.js --exec babel-node"
@@ -12,9 +13,13 @@
     "@babel/core": "^7.17.9",
     "@babel/node": "^7.16.8",
     "@babel/preset-env": "^7.16.11",
+    "bcryptjs": "^3.0.2",
     "cors": "^2.8.5",
+    "dotenv": "^17.2.1",
     "express": "^4.17.3",
+    "express-list-endpoints": "^7.1.1",
+    "jsonwebtoken": "^9.0.2",
     "mongoose": "^8.4.0",
     "nodemon": "^3.0.1"
   }
-}
+}

backend/routes/incomeRoutes.js

@@ -0,0 +1,71 @@
+import express from "express";
+import { Income } from "../models/Income.js";
+import mongoose from "mongoose";
+
+const router = express.Router();
+
+// GET /income - Fetch the current income
+router.get("/", async (req, res) => {
+  try {
+    let income = await Income.findOne();
+    if (!income) {
+      income = await Income.create({ amount: 0 });
+    }
+    res.status(200).json({ income: income.amount });
+  } catch (error) {
+    console.error("Error fetching income:", error);
+    res.status(500).json({ error: "Server error" });
+  }
+});
+
+// GET /income/months
+router.get("/months", async (req, res) => {
+  try { 
+    const months = await Income.find({}, '_id month amount createdAt').sort({ createdAt: -1 });
+    res.json(months);
+  } catch (error) {
+    console.error("Error fetching months:", error);
+    res.status(500).json({ message: "Failed to fetch months"});
+  }
+});
+
+// POST /income - Add a new income
+router.post("/", async (req, res) => {
+  const { amount, month } = req.body;
+
+  if (typeof amount !== "number" || amount < 0) {
+    return res.status(400).json({ error: "Invalid income value" });
+  }
+
+  if (!month || typeof month !== "string") {
+    return res.status(400).json({ error: "Invalid month value" });
+  }
+
+  try {
+    const newIncome = await Income.create({month, amount});
+      res.status(201).json(newIncome);
+  } catch (error) {
+      res.status(400).json({ message: "Failed to add income", error: error.message });
+  }
+});
+
+// DELETE /income - Delete the income
+router.delete("/:id", async (req, res) => {
+  const { id } = req.params;
+
+  if (!mongoose.Types.ObjectId.isValid(id)) {
+    return res.status(400).json({ error: "Invalid income ID" });
+  }
+  try {
+    const deletedIncome = await Income.findByIdAndDelete(id); 
+    if (!deletedIncome) {
+      return res.status(404).json({ message: "Income not found" });
+    }
+    res.status(200).json({ message: "Income deleted successfully" });
+  } catch (error) {
+    console.error("Error deleting income:", error.message, error.stack);
+    return res.status(500).json({ error: "Server error" });
+  }
+});
+
+export default router;

backend/routes/spendingsRoutes.js

@@ -0,0 +1,57 @@
+import express from "express";
+import { Spendings } from "../models/Spendings.js";
+
+const router = express.Router();
+
+// POST - Add income
+router.post("/", async (req, res) => {
+  const { category, amount } = req.body;
+
+  try {
+    let newSpending = await Spendings.create({ category, amount});
+      res.status(201).json(newSpending);
+  } catch (error) {
+    res.status(400).json({ message: "Failed to add spending", error: error.message });
+  }
+});
+
+// GET - Get all spendings
+router.get("/", async (req, res) => {
+  try {
+    const spendings = await Spendings.find();
+    res.status(200).json(spendings);
+  } catch (error) {
+    res.status(500).json({ message: "Failed to fetch spendings", error: error.message });
+  }
+});
+
+// GET - Get total spendings
+router.get("/total", async (req, res) => {
+  try {
+    const total = await Spendings.aggregate([
+      { $group: {_id: null, totalAmount: { $sum: "$amount" } } },
+    ]);
+    console.log("Total Spendings Calculation:", total);
+    res.status(200).json({ total: total[0]?.totalAmount || 0 });
+  } catch (error) {
+    console.error("Error Fetching Total Spendings:", error.message); 
+    res.status(500).json({ message: "Failed to fetch total spendings", error: error.message });
+  }
+});
+
+router.delete("/:id", async (req, res) => {
+  const { id } = req.params;
+
+  try {
+    const deletedSpending = await Spendings.findByIdAndDelete(id); 
+    if (!deletedSpending) {
+      return res.status(404).json({ message: "Spending not found" });
+    }
+    res.status(200).json({ message: "Spending deleted successfully" });
+  } catch (error) {
+    console.error("Error deleting spending:", error.message, error.stack);
+    return res.status(500).json({ error: "Server error" });
+  }
+});
+
+export default router;

backend/routes/userRoutes.js

@@ -0,0 +1,131 @@
+import express from 'express';
+import bcrypt from 'bcryptjs';
+import jwt from 'jsonwebtoken'; 
+import { User } from '../models/User.js';
+import { authenticateUser } from '../middleware/authMiddleware.js';
+
+const router = express.Router()
+const JWT_SECRET = process.env.JWT_SECRET || 'your_secure_secret_key'; // Use environment variable for the secret key
+
+// POST - Register a new user
+router.post("/signup", async (req, res) => {
+  try {
+    const { name, email, password } = req.body
+
+      if (!name || !email || !password) {
+      return res.status(400).json({
+        success: false,
+        message: "Name, email, and password are required.",
+      });
+    }
+
+    const salt = bcrypt.genSaltSync()
+    const hashedPassword = bcrypt.hashSync(password, salt);
+    const user = new User({ name, email, password: hashedPassword
+    }) 
+
+    //await to not send response before database finished saving
+    await user.save()
+
+    // Generate a JWT token
+    const token = jwt.sign({ id: user._id, email: user.email }, JWT_SECRET, {
+    expiresIn: '1h', // Token expires in 1 hour
+    });
+
+    res.status(201).json({
+      success: true,
+      message: "User created successfully.",
+      response: {
+        id: user._id,
+        accessToken: token,
+      }
+    })
+
+  } catch (error) {
+    console.error("Signup error:", error)
+    res.status(400).json({
+      success: false,
+      message: "Failed to create user.",
+      response: error.message 
+    })
+  }
+ })
+
+
+ // POST - Login route
+router.post("/login", async (req, res) => {
+  try {
+    const { email, password } = req.body
+
+    if (!email || !password) {
+      return res.status(400).json({
+        success: false,
+        message: "Email and password are required.",
+      });
+    }
+
+    // Find user by email
+    const user = await User.findOne({ email })
+    if (!user) {
+      return res.status(404).json({
+        success: false,
+        message: "User not found with provided email.",
+      })
+    }
+
+    // Compare the provided password with the stored hashed password
+    const isPasswordValid = bcrypt.compareSync(password, user.password)
+    if (!isPasswordValid) {
+      return res.status(401).json({
+        success: false,
+        message: "Incorrect password. Please try again.",
+      })
+    }
+    // Generate a JWT token
+    const token = jwt.sign({ id: user._id, email: user.email }, JWT_SECRET, {
+      expiresIn: '1h', // Token expires in 1 hour
+    })
+
+    res.status(200).json({
+      success: true,
+      message: "Login successfull.",
+      response: {
+        id: user._id,
+        accessToken: token,
+      }
+    })
+
+  } catch (error) {
+    console.error("Login error:", error)
+    res.status(500).json({
+      success: false,
+      message: "Failed to login. Please try again.",
+      response: error.message 
+    })
+  }
+ })
+
+ // GET - Protected dashboard route
+ router.get("/dashboard", authenticateUser, async (req, res) => {
+  try {
+    res.status(200).json({
+      success: true,
+      message: "User authenticated successfully.",
+      response: {
+        id: req.user._id,
+        name: req.user.name,
+        email: req.user.email,
+      }
+    })
+  } catch (error) {
+    console.error("Dashboard error:", error)
+    res.status(500).json({
+      success: false,
+      message: "Failed to access dashboard.",
+      response: error.message 
+    })
+  }
+  })
+
+ export default router
+