Merge pull request #1333 from Ayushmaanagarwal1211/newbanch

Optmized the Api's Performance

website3.0/src/app/api/averagetime/route.js

@@ -1,32 +1,47 @@
-import Blogs from "@utils/models/blog";  // Importing Mongoose model for blog collection
-import mongoose from "mongoose";  // Importing Mongoose for MongoDB interactions
-import { NextResponse } from "next/server";  // Importing Next.js server response utility
+import Blogs from "@utils/models/blog"; // Importing Mongoose model for blog collection
+import mongoose from "mongoose"; // Importing Mongoose for MongoDB interactions
+import { NextResponse } from "next/server"; // Importing Next.js server response utility
 
+// Use a global variable to manage MongoDB connection
+let isConnected = false;
+
+const connectToDatabase = async () => {
+  if (isConnected) return;
+  const { MONGO_URI } = process.env;
+  await mongoose.connect(MONGO_URI);
+  isConnected = true;
+};
 
 export async function POST(req) {
-    try {
-        // Parse JSON payload from request body
-        const payload = await req.json();
-
-        const { MONGO_URI } = process.env;  
-        // Connect to MongoDB using Mongoose
-        await mongoose.connect(MONGO_URI);
-        let blog=await Blogs.findById(payload.id)
-
-        // Create a new instance of Blogs model with the received payload
-        blog.average=(blog.average+payload.time)
-        await Blogs.findByIdAndUpdate(payload.id,{
-            $set:blog
-        })
-
-        // Save the new blog record to MongoDB
-
-
-        // Return success response with saved blog details
-        return NextResponse.json({ success: true });
-    } catch (error) {
-        console.error("Error in POST /api/blog:", error);
-        return NextResponse.json({ success: false, error: error.message });
+  try {
+    // Parse JSON payload from request body
+    const payload = await req.json();
+    const { id, time } = payload;
+
+    if (!id || typeof time !== 'number') {
+      return NextResponse.json({ success: false, error: "Invalid input" }, { status: 400 });
     }
-}
 
+    // Connect to MongoDB
+    await connectToDatabase();
+
+    // Fetch the blog document
+    const blog = await Blogs.findById(id);
+
+    if (!blog) {
+      return NextResponse.json({ success: false, error: "Blog not found" }, { status: 404 });
+    }
+
+    // Update the average time
+    blog.average = (blog.average + time) / 2;
+
+    // Save the updated blog document
+    await blog.save();
+
+    // Return success response
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error("Error in POST /api/blog:", error);
+    return NextResponse.json({ success: false, error: error.message }, { status: 500 });
+  }
+}

website3.0/src/app/api/blockblog/route.js

@@ -1,39 +1,58 @@
-import Blogs from "@utils/models/blog";  // Importing Mongoose model for blog collection
-import user from "@utils/models/user";
-import mongoose from "mongoose";  // Importing Mongoose for MongoDB interactions
-import { NextResponse } from "next/server";  // Importing Next.js server response utility
+import Blogs from "@utils/models/blog"; // Importing Mongoose model for blog collection
+import User from "@utils/models/user"; // Importing Mongoose model for user collection
+import mongoose from "mongoose"; // Importing Mongoose for MongoDB interactions
+import { NextResponse } from "next/server"; // Importing Next.js server response utility
+
+// Use a global variable to manage MongoDB connection
+let isConnected = false;
+
+const connectToDatabase = async () => {
+  if (isConnected) return;
+  const { MONGO_URI } = process.env;
+  await mongoose.connect(MONGO_URI);
+  isConnected = true;
+};
 
 export async function GET() {
-    const { MONGO_URI } = process.env;  
-    // Connect to MongoDB using Mongoose
-    await mongoose.connect(MONGO_URI);
-    let data = [];
-    data = await Blogs.find();
-    return NextResponse.json({data});
+  try {
+    await connectToDatabase();
+
+    // Fetch all blog documents
+    const blogs = await Blogs.find();
+
+    return NextResponse.json({ data: blogs });
+  } catch (error) {
+    console.error("Error fetching blogs:", error);
+    return NextResponse.json({ success: false, error: error.message }, { status: 500 });
+  }
 }
 
 export async function POST(req) {
-    try {
-        // Parse JSON payload from request body
-        const {user_id,blog_id} = await req.json();
-
-        const { MONGO_URI } = process.env;  
-
-        // Connect to MongoDB using Mongoose
-        await mongoose.connect(MONGO_URI);
-
-        // Create a new instance of Blogs model with the received payload
-        let user1 = await user.findById(user_id)
-        user1.blockedBlogs.push(blog_id)
-        // Save the new blog record to MongoDB
-        const result = await user1.save();
-        // Return success response with saved blog details
-        return NextResponse.json({success: true });
-    } catch (error) {
-        console.error("Error in POST /api/blog:", error);
-        return NextResponse.json({ success: false, error: error.message });
+  try {
+    // Parse JSON payload from request body
+    const { user_id, blog_id } = await req.json();
+
+    if (!user_id || !blog_id) {
+      return NextResponse.json({ success: false, error: "Invalid input" }, { status: 400 });
     }
-}
 
+    await connectToDatabase();
 
+    // Find the user and update blockedBlogs
+    const userToUpdate = await User.findById(user_id);
+
+    if (!userToUpdate) {
+      return NextResponse.json({ success: false, error: "User not found" }, { status: 404 });
+    }
 
+    if (!userToUpdate.blockedBlogs.includes(blog_id)) {
+      userToUpdate.blockedBlogs.push(blog_id);
+      await userToUpdate.save();
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    console.error("Error in POST /api/block-blog:", error);
+    return NextResponse.json({ success: false, error: error.message }, { status: 500 });
+  }
+}

website3.0/src/app/api/changepass/route.js

@@ -1,29 +1,58 @@
 import mongoose from "mongoose"; // Importing Mongoose for MongoDB interactions
 import { NextResponse } from "next/server"; // Importing Next.js server response utility
-import { Resend } from "resend";
-import user from "@utils/models/user"; // Importing Mongoose model for newsletter subscription
-let jwt = require("jsonwebtoken");
+import jwt from "jsonwebtoken"; // Importing JSON Web Token for decoding
+import bcrypt from "bcrypt"; // Importing bcrypt for hashing passwords
+import User from "@utils/models/user"; // Importing Mongoose model for user collection
 
-// import {Emailtemplate} from '../../../../components/Emailtemplate'
-const bcrypt = require("bcrypt");
+const { MONGO_URI, JWT_SECRET } = process.env; // Ensure JWT_SECRET is also set in environment variables
+
+// Helper function to connect to MongoDB
+const connectToDatabase = async () => {
+  if (mongoose.connection.readyState === 0) {
+    await mongoose.connect(MONGO_URI);
+  }
+};
 
 export async function POST(req) {
   try {
-    const { MONGO_URI } = process.env;
-    const { token, password } = await req.json(); // Extract email from request body
-    //for connecting with db
-    await mongoose.connect(MONGO_URI);
-    // for finding the user
-    let user1 = await jwt.decode(token);
+    // Parse JSON payload from request body
+    const { token, password } = await req.json();
+
+    if (!token || !password) {
+      return NextResponse.json({ success: false, error: "Token and password are required" }, { status: 400 });
+    }
+
+    // Connect to MongoDB
+    await connectToDatabase();
+
+    // Decode and verify the token
+    let decodedToken;
+    try {
+      decodedToken = jwt.verify(token, JWT_SECRET); // Verify token using secret
+    } catch (error) {
+      return NextResponse.json({ success: false, error: "Invalid or expired token" }, { status: 401 });
+    }
+
+    const { email } = decodedToken;
+
+    // Hash the new password
     const hashedPassword = await bcrypt.hash(password, 10);
-    await user.updateOne(
-      { email: user1 },
+
+    // Update the user password
+    const result = await User.updateOne(
+      { email },
       { $set: { password: hashedPassword } }
     );
-    //returning user for correct pass
-    return NextResponse.json({ success: true }, { status: "200" });
+
+    if (result.nModified === 0) {
+      return NextResponse.json({ success: false, error: "User not found or password is unchanged" }, { status: 404 });
+    }
+
+    // Return success response
+    return NextResponse.json({ success: true }, { status: 200 });
+
   } catch (error) {
-    console.error("Error in POST /api/check-email:", error);
-    return NextResponse.json({ success: false, error: error.message });
+    console.error("Error in POST /api/reset-password:", error);
+    return NextResponse.json({ success: false, error: "Server error" }, { status: 500 });
   }
 }

website3.0/src/app/api/checkusername/route.js

@@ -1,38 +1,80 @@
-import user from "@utils/models/user"; // Importing Mongoose model for newsletter subscription
 import mongoose from "mongoose"; // Importing Mongoose for MongoDB interactions
-import nodemailer from "nodemailer"; // Importing nodemailer to send welcome email
+import user from "@utils/models/user"; // Importing Mongoose model for user collection
 import { NextResponse } from "next/server"; // Importing Next.js server response utility
-const bcrypt = require('bcrypt');
-const saltRounds = 10;
 
+const MONGO_URI = process.env.MONGO_URI; // Ensure this is defined in your environment
+
+// Helper function to connect to MongoDB
+const connectToDatabase = async () => {
+  if (mongoose.connection.readyState === 0) {
+    await mongoose.connect(MONGO_URI);
+  }
+};
+
+// POST endpoint for user registration
 export async function POST(req) {
-        const { MONGO_URI } = process.env; 
-        let {email,username,password,image}=await req.json()
-        await mongoose.connect(MONGO_URI);
+  try {
+    const { email, username, password, image } = await req.json();
+
+    // Validate input
+    if (!email || !username || !password) {
+      return NextResponse.json({ success: false, msg: "Email, username, and password are required" }, { status: 400 });
+    }
 
-        let res=await user.find({username:username})
-        if(res.length>0){
-            return NextResponse.json({ success: false,msg:"This Username is not available "},{status:"200"});
+    await connectToDatabase();
 
-        }else{
-            return NextResponse.json({ success: true},{status:"200"});
+    // Check if username already exists
+    const existingUser = await user.findOne({ username });
+    if (existingUser) {
+      return NextResponse.json({ success: false, msg: "This username is already taken" }, { status: 409 });
+    }
 
-        }
-
+    // Hash the password before saving
+    const hashedPassword = await bcrypt.hash(password, saltRounds);
+
+    // Create a new user
+    const newUser = new user({
+      email,
+      username,
+      password: hashedPassword,
+      image,
+    });
+    await newUser.save();
+
+    // Return success response
+    return NextResponse.json({ success: true, msg: "User registered successfully" }, { status: 201 });
+  } catch (error) {
+    console.error("Error in POST /api/register:", error);
+    return NextResponse.json({ success: false, error: "Server error" }, { status: 500 });
+  }
 }
+
+// PUT endpoint for updating username
 export async function PUT(req) {
-    const { MONGO_URI } = process.env; 
-    let {id,username}=await req.json()
-
-    let res=await user.findByIdAndUpdate(id,{
-        $set:{
-            username:username
-        }
-    },{new:true})
-        return NextResponse.json({ success: true},{status:"200"});
-
-
-
-}
+  try {
+    const { id, username } = await req.json();
+
+    if (!id || !username) {
+      return NextResponse.json({ success: false, msg: "User ID and username are required" }, { status: 400 });
+    }
+
+    await connectToDatabase();
 
+    // Find user by ID and update username
+    const updatedUser = await user.findByIdAndUpdate(
+      id,
+      { $set: { username } },
+      { new: true, runValidators: true }
+    );
 
+    if (!updatedUser) {
+      return NextResponse.json({ success: false, msg: "User not found" }, { status: 404 });
+    }
+
+    // Return success response
+    return NextResponse.json({ success: true, msg: "Username updated successfully" }, { status: 200 });
+  } catch (error) {
+    console.error("Error in PUT /api/update-username:", error);
+    return NextResponse.json({ success: false, error: "Server error" }, { status: 500 });
+  }
+}