Initial commit

Author: prince04-coder

.gitignore

@@ -0,0 +1,3 @@
+
+.env
+node_modules

app.js

@@ -0,0 +1,18 @@
+const express = require('express');
+const mongoose = require('mongoose');
+const routes = require('./routes/index');
+require('dotenv').config();
+
+const app = express();
+const port = process.env.PORT || 3000;
+
+app.use(express.json());
+app.use('/api', routes);
+
+mongoose.connect(process.env.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true })
+    .then(() => console.log('MongoDB connected'))
+    .catch(err => console.log(err));
+
+app.listen(port, () => {
+    console.log(`Server is running on port ${port}`);
+});

config/database.js

@@ -0,0 +1,17 @@
+const mongoose = require('mongoose');
+require('dotenv').config();
+
+const connectDB = async () => {
+    try {
+        await mongoose.connect(process.env.MONGODB_URI, {
+            useNewUrlParser: true,
+            useUnifiedTopology: true
+        });
+        console.log('MongoDB connected');
+    } catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+};
+
+module.exports = connectDB;

controllers/authController.js

@@ -0,0 +1,114 @@
+const bcrypt = require('bcrypt');
+const speakeasy = require('speakeasy');
+const emailSender = require('../utils/emailSender');
+const jwtHelper = require('../utils/jwtHelper');
+const User = require('../models/User');
+
+// Temporary storage for OTPs during registration
+const otpStore = {};
+
+// Step 1: Register and send OTP
+exports.register = async (req, res) => {
+  try {
+    const { name, email, password, role, club } = req.body;
+
+    // Check if user already exists
+    const existingUser = await User.findOne({ email });
+    if (existingUser) {
+      return res.status(400).json({ error: 'Email already registered' });
+    }
+
+    // Generate OTP
+    const otp = speakeasy.totp({
+      secret: process.env.OTP_SECRET, // Use a strong secret
+      encoding: 'base32',
+    });
+
+    // Store OTP temporarily
+    otpStore[email] = {
+      name,
+      password,
+      role,
+      club,
+      otp,
+      expiresAt: Date.now() + 5 * 60 * 1000, // OTP valid for 5 minutes
+    };
+
+    // Send OTP via email
+    await emailSender.sendEmail(
+      email,
+      'Verify Your Email',
+      `Your OTP for registration is: ${otp}. It is valid for 5 minutes.`
+    );
+
+    res.status(200).json({ message: 'OTP sent to your email for verification' });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+// Step 2: Verify OTP and create user
+exports.verifyOtp = async (req, res) => {
+  try {
+    const { email, otp } = req.body;
+
+    const storedOtp = otpStore[email];
+    if (!storedOtp) {
+      return res.status(400).json({ error: 'OTP not found or expired' });
+    }
+
+    // Check if OTP matches and has not expired
+    if (storedOtp.otp !== otp || storedOtp.expiresAt < Date.now()) {
+      return res.status(400).json({ error: 'Invalid or expired OTP' });
+    }
+
+    // Hash the password and save the user
+    const hashedPassword = await bcrypt.hash(storedOtp.password, 10);
+    const newUser = new User({
+      name: storedOtp.name,
+      email,
+      password: hashedPassword,
+      role: storedOtp.role,
+      club: storedOtp.club,
+    });
+    await newUser.save();
+
+    // Clear OTP after successful verification
+    delete otpStore[email];
+
+    res.status(201).json({ message: 'User registered and verified successfully', user: newUser });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+// Login with 2FA
+exports.login = async (req, res) => {
+  try {
+    const { email, password } = req.body;
+    const user = await User.findOne({ email });
+
+    if (!user || !(await bcrypt.compare(password, user.password))) {
+      return res.status(400).json({ error: 'Invalid email or password' });
+    }
+
+    const token = jwtHelper.signToken({ id: user._id, role: user.role, club: user.club });
+    res.status(200).json({ message: 'Login successful', token });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+exports.logout = (req, res) => {
+  res.status(200).json({ message: 'Logout successful' });
+};
+
+exports.validateToken = (req, res) => {
+  try {
+    const token = req.header('Authorization')?.replace('Bearer ', '');
+    const decoded = jwtHelper.verifyToken(token);
+    res.status(200).json({ valid: true, user: decoded });
+  } catch (error) {
+    res.status(401).json({ valid: false, error: 'Invalid or expired token' });
+  }
+};

controllers/inventoryController.js

@@ -0,0 +1,44 @@
+const Inventory = require('../models/inventoryModel');
+
+exports.addInventory = async (req, res) => {
+  try {
+    const { name, description, quantity } = req.body;
+    const inventory = new Inventory({ name, description, quantity, addedBy: req.user._id });
+    await inventory.save();
+    res.status(201).json({ message: 'Inventory item added', inventory });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+exports.updateInventory = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const updates = req.body;
+    const inventory = await Inventory.findByIdAndUpdate(id, updates, { new: true });
+    if (!inventory) return res.status(404).json({ error: 'Item not found' });
+    res.status(200).json({ message: 'Inventory updated', inventory });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+exports.deleteInventory = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const inventory = await Inventory.findByIdAndDelete(id);
+    if (!inventory) return res.status(404).json({ error: 'Item not found' });
+    res.status(200).json({ message: 'Inventory deleted', inventory });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+exports.getAllInventory = async (req, res) => {
+  try {
+    const inventory = await Inventory.find();
+    res.status(200).json({ inventory });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};

controllers/requestController.js

@@ -0,0 +1,77 @@
+const Request = require('../models/requestModel');
+
+exports.createRequest = async (req, res) => {
+  try {
+    const { items } = req.body;
+    const request = new Request({ club: req.user.club, coordinator: req.user._id, items });
+    await request.save();
+    res.status(201).json({ message: 'Request created', request });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+exports.cancelRequest = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const request = await Request.findByIdAndUpdate(id, { status: 'canceled' }, { new: true });
+    if (!request) return res.status(404).json({ error: 'Request not found' });
+    res.status(200).json({ message: 'Request canceled', request });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+exports.getAllRequests = async (req, res) => {
+  try {
+    const requests = await Request.find().populate('coordinator', 'name email');
+    res.status(200).json({ requests });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+exports.getMyRequests = async (req, res) => {
+  try {
+    const requests = await Request.find({ club: req.user.club }).populate('coordinator', 'name email');
+    res.status(200).json({ requests });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+exports.getRequestsByClub = async (req, res) => {
+  try {
+    const { clubName } = req.params;
+    const requests = await Request.find({ club: clubName }).populate('coordinator', 'name email');
+    res.status(200).json({ requests });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+exports.getRequestsByItem = async (req, res) => {
+  try {
+    const { itemId } = req.params;
+    const requests = await Request.find({ 'items.inventoryId': itemId }).populate('coordinator', 'name email');
+    res.status(200).json({ requests });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+exports.updateRequestStatus = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { status } = req.body;
+    const validStatuses = ['approved', 'rejected'];
+    if (!validStatuses.includes(status)) {
+      return res.status(400).json({ error: 'Invalid status' });
+    }
+    const request = await Request.findByIdAndUpdate(id, { status }, { new: true });
+    if (!request) return res.status(404).json({ error: 'Request not found' });
+    res.status(200).json({ message: 'Request status updated', request });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};

db.js

@@ -0,0 +1,23 @@
+
+const mongoose = require('mongoose');
+
+//mongodb uri
+const MONGO_URI = process.env.MONGO_URI;
+
+const connectDb = async () => {
+  // Check if MONGO_URI is defined
+  if (!MONGO_URI) {
+    console.error('MongoDB URI is not defined. Please add MONGO_URI in your .env file.');
+    process.exit(1);  // Exit the process with failure code
+  }
+
+  try {
+    await mongoose.connect(MONGO_URI);
+    console.log('Mongoose connected to MongoDB Atlas');
+  } catch (err) {
+    console.error(`Failed to connect to MongoDB: ${err.message}`);
+    process.exit(1);  // Exit the process if there's an error
+  }
+};
+
+module.exports = connectDb;

middlewares/authMiddleware.js

@@ -0,0 +1,33 @@
+const jwtHelper = require('../utils/jwtHelper');
+const User = require('../models/User');
+
+// Middleware to check if the user is authenticated
+const authenticate = async (req, res, next) => {
+  try {
+    const token = req.header('Authorization')?.replace('Bearer ', '');
+    if (!token) {
+      return res.status(401).json({ error: 'Access denied. No token provided.' });
+    }
+
+    const decoded = jwtHelper.verifyToken(token);
+    const user = await User.findById(decoded.id);
+    if (!user) {
+      return res.status(401).json({ error: 'Invalid user.' });
+    }
+
+    req.user = user; // Attach user to request object
+    next();
+  } catch (error) {
+    res.status(401).json({ error: 'Unauthorized access.' });
+  }
+};
+
+// Middleware to check for specific roles (e.g., 'core' or 'club')
+const authorize = (role) => (req, res, next) => {
+  if (req.user.role !== role) {
+    return res.status(403).json({ error: 'Forbidden: Insufficient permissions.' });
+  }
+  next();
+};
+
+module.exports = { authenticate, authorize };

models/User.js

@@ -0,0 +1,31 @@
+const mongoose = require('mongoose');
+
+const userSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+    },
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+    password: {
+      type: String,
+      required: true,
+    },
+    role: {
+      type: String,
+      enum: ['core', 'club'],
+      required: true,
+    },
+    club: {
+      type: String, // Optional, only for 'club' users
+      default: null,
+    },
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model('User', userSchema);

models/index.js

@@ -0,0 +1,14 @@
+const mongoose = require('mongoose');
+
+const sampleSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    value: {
+        type: Number,
+        required: true
+    }
+});
+
+module.exports = mongoose.model('SampleModel', sampleSchema);