Refactor/login register

backend/db.js → backend/config/db.js

@@ -5,10 +5,8 @@ dotenv.config();
 const connectDB = async () => {
   try {
     const ConnectDB = process.env.MONGODB_URI;
-    await mongoose.connect(ConnectDB, {
-      useNewUrlParser: true,
-      useUnifiedTopology: true,
-    });
+    //Removing the options as they are no longer needed from mongoose6+
+    await mongoose.connect(ConnectDB);
     console.log("MongoDB Connected");
   } catch (error) {
     console.error("MongoDB Connection Error:", error);

backend/config/passportConfig.js

@@ -0,0 +1,67 @@
+const passport = require("passport");
+const GoogleStrategy = require("passport-google-oauth20").Strategy;
+const isIITBhilaiEmail = require("../utils/isIITBhilaiEmail");
+const User = require("../models/userSchema");
+
+// Google OAuth Strategy
+passport.use(
+  new GoogleStrategy(
+    {
+      clientID: process.env.GOOGLE_CLIENT_ID,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+      callbackURL: `${process.env.BACKEND_URL}/auth/google/verify`, // Update with your callback URL
+    },
+    async (accessToken, refreshToken, profile, done) => {
+      // Check if the user already exists in your database
+      if (!isIITBhilaiEmail(profile.emails[0].value)) {
+        console.log("Google OAuth blocked for: ", profile.emails[0].value);
+        return done(null, false, {
+          message: "Only @iitbhilai.ac.in emails are allowed.",
+        });
+      }
+      try {
+        const user = await User.findOne({ username: profile.emails[0].value });
+
+        if (user) {
+          // If user exists, return the user
+          return done(null, user);
+        }
+        // If user doesn't exist, create a new user in your database
+        const newUser = new User({
+          username: profile.emails[0].value,
+          role: "STUDENT",
+          strategy: "google",
+          personal_info: {
+            name: profile.displayName || "No Name",
+            email: profile.emails[0].value,
+            profilePic:
+              profile.photos && profile.photos.length > 0
+                ? profile.photos[0].value
+                : "https://www.gravatar.com/avatar/?d=mp",
+          },
+          onboardingComplete: false,
+        });
+
+        await newUser.save();
+        return done(null, newUser);
+      } catch (error) {
+        return done(error);
+      }
+    },
+  ),
+);
+
+passport.serializeUser((user, done) => {
+  done(null, user);
+});
+
+passport.deserializeUser(async (userKey, done) => {
+  try {
+    let user = await User.findById(userKey._id);
+    done(null, user);
+  } catch (err) {
+    done(err);
+  }
+});
+
+module.exports = passport;

backend/models/achievementSchema.js

@@ -0,0 +1,58 @@
+const mongoose = require("mongoose");
+//achievements collection
+const achievementSchema = new mongoose.Schema({
+  achievement_id: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+  user_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "User",
+    required: true,
+  },
+  title: {
+    type: String,
+    required: true,
+  },
+  description: String,
+  category: {
+    type: String,
+    required: true,
+  },
+  type: {
+    type: String,
+  },
+  level: {
+    type: String,
+  },
+  date_achieved: {
+    type: Date,
+    required: true,
+  },
+  position: {
+    type: String,
+  },
+  event_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Event",
+    default: null, // optional
+  },
+  certificate_url: String,
+  verified: {
+    type: Boolean,
+    default: false,
+  },
+  verified_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "User",
+    default: null,
+  },
+  created_at: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+const Achievement = mongoose.model("Achievement", achievementSchema);
+module.exports = Achievement;

backend/models/eventSchema.js

@@ -0,0 +1,118 @@
+const mongoose = require("mongoose");
+
+//events collection
+const eventSchema = new mongoose.Schema({
+  event_id: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+  title: {
+    type: String,
+    required: true,
+  },
+  description: String,
+  category: {
+    type: String,
+    enum: ["cultural", "technical", "sports", "academic", "other"],
+  },
+  type: {
+    type: String,
+  },
+  organizing_unit_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Organizational_Unit",
+    required: true,
+  },
+  organizers: [
+    {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+    },
+  ],
+  schedule: {
+    start: Date,
+    end: Date,
+    venue: String,
+    mode: {
+      type: String,
+      enum: ["online", "offline", "hybrid"],
+    },
+  },
+  registration: {
+    required: Boolean,
+    start: Date,
+    end: Date,
+    fees: Number,
+    max_participants: Number,
+  },
+  budget: {
+    allocated: Number,
+    spent: Number,
+    sponsors: [
+      {
+        type: String,
+      },
+    ],
+  },
+  status: {
+    type: String,
+    enum: ["planned", "ongoing", "completed", "cancelled"],
+    default: "planned",
+  },
+  participants: [
+    {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+    },
+  ],
+  winners: [
+    {
+      user: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "User",
+      },
+      position: String, // e.g., "1st", "2nd", "Best Speaker", etc.
+    },
+  ],
+  feedback_summary: {
+    type: Object, // You can define structure if fixed
+  },
+  media: {
+    images: [String],
+    videos: [String],
+    documents: [String],
+  },
+  room_requests: [
+    {
+      date: { type: Date, required: true },
+      time: { type: String, required: true },
+      room: { type: String, required: true },
+      description: { type: String },
+      status: {
+        type: String,
+        enum: ["Pending", "Approved", "Rejected"],
+        default: "Pending",
+      },
+      requested_at: {
+        type: Date,
+        default: Date.now,
+      },
+      reviewed_by: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "User",
+      },
+    },
+  ],
+  created_at: {
+    type: Date,
+    default: Date.now,
+  },
+  updated_at: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+const Event = mongoose.model("Event", eventSchema);
+module.exports = Event;

backend/models/feedbackSchema.js

@@ -0,0 +1,69 @@
+const mongoose = require("mongoose");
+
+//feedback collection
+const feedbackSchema = new mongoose.Schema({
+  feedback_id: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+  type: {
+    type: String,
+    required: true,
+  },
+  target_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    //required: true,
+    // We'll dynamically interpret this field based on target_type
+  },
+  target_type: {
+    type: String,
+    required: true,
+  },
+  feedback_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "User",
+    required: true,
+  },
+  // category: {
+  //   type: String,
+  //   enum: ['organization', 'communication', 'leadership'],
+  //   required: true
+  // },
+  rating: {
+    type: Number,
+    min: 1,
+    max: 5,
+  },
+  comments: {
+    type: String,
+  },
+  is_anonymous: {
+    type: Boolean,
+    default: false,
+  },
+  is_resolved: {
+    type: Boolean,
+    default: false,
+  },
+  actions_taken: {
+    type: String,
+    default: "",
+  },
+  created_at: {
+    type: Date,
+    default: Date.now,
+  },
+  resolved_at: {
+    type: Date,
+    default: null,
+  },
+  resolved_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "User",
+    default: null,
+  },
+});
+
+const Feedback = mongoose.model("Feedback", feedbackSchema);
+module.exports = Feedback;