Add Bookings ft

back-end/package.json

@@ -24,8 +24,8 @@
     "jsonwebtoken": "^9.0.2",
     "mongoose": "^8.9.2",
     "multer": "^1.4.5-lts.1",
-    "wretch": "^2.11.0",
-    "zod": "^3.24.2"
+    "wretch": "3.0.3",
+    "zod": "^4.1.12"
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",

back-end/src/controllers/auth.controller.ts

@@ -24,21 +24,21 @@ export class AuthController {
         lastName,
         dateOfBirth,
       } = req.body;
-      
+
       if (password !== verifyPassword) {
         res.error("Passwords do not match");
         return;
       }
-      
+
       const existingUser = await User.findOne({
         $or: [{ email }, { phoneNumber }],
       });
-      
+
       if (existingUser) {
         res.error("User already exists");
         return;
       }
-      
+
       const user = new User({
         email,
         password,
@@ -52,50 +52,47 @@ export class AuthController {
         email,
         phoneNumber,
       });
-      
+
       user.profile = profile._id as any;
-      
+
       await Promise.all([user.save(), profile.save()]);
-      
+
       res.success(req.body, "User registered successfully");
     } catch (error) {
       console.error("Registration error:", error);
       res.error("An error occurred", 500);
     }
   }
 
-  static async login(
-    req: Request<{}, {}, IUserLogin>,
-    res: Response
-  ): Promise<void> {
+  static async login(req: Request<{}, {}, IUserLogin>, res: Response) {
     try {
       const { email, password } = req.body;
-      
+
       const user = await User.findOne({ email });
-      
+
       if (!user) {
         res.error("INVALID_CREDENTIALS");
         return;
       }
-      
+
       const isValidPassword = await user.comparePassword(password);
-      
+
       if (!isValidPassword) {
         res.error("INVALID_CREDENTIALS");
         return;
       }
-      
+
       const tokenPayload = {
         userId: user._id as string,
         roles: user.roles,
       };
-      
+
       const accessToken = tokenUtils.generateAccessToken(tokenPayload);
       const refreshToken = tokenUtils.generateRefreshToken(tokenPayload);
-      
+
       user.refreshTokens.push({ token: refreshToken, createdAt: new Date() });
       await user.save();
-      
+
       res.success(
         {
           tokens: {
@@ -113,53 +110,53 @@ export class AuthController {
   static async refreshToken(
     req: Request<{}, {}, IRefreshTokenPayload>,
     res: Response
-  ): Promise<void> {
+  ) {
     try {
       const { refreshToken } = req.body;
-      
+
       const user = await User.findOne({
         "refreshTokens.token": refreshToken,
       });
-      
+
       if (!user) {
         res.error("Unauthorized", 401);
         return;
       }
-      
+
       try {
         const decoded = verifyRefreshToken(refreshToken);
-        
+
         if (
           typeof decoded === "string" ||
           (user._id as string).toString() !== decoded.userId
         ) {
           res.error("Unauthorized", 401);
           return;
         }
-        
+
         user.refreshTokens = user.refreshTokens.filter((token) => {
           const tokenAge = Date.now() - token.createdAt.getTime();
           return tokenAge < 7 * 24 * 60 * 60 * 1000; // 7 days
         });
-        
+
         const tokenPayload = {
           userId: user._id as string,
           roles: user.roles,
         };
-        
+
         const newAccessToken = tokenUtils.generateAccessToken(tokenPayload);
         const newRefreshToken = tokenUtils.generateRefreshToken(tokenPayload);
-        
+
         user.refreshTokens = user.refreshTokens.filter(
           (token) => token.token !== refreshToken
         );
         user.refreshTokens.push({
           token: newRefreshToken,
           createdAt: new Date(),
         });
-        
+
         await user.save();
-        
+
         res.success(
           {
             accessToken: newAccessToken,
@@ -175,4 +172,4 @@ export class AuthController {
       res.error("An error occurred", 500);
     }
   }
-}
+}

back-end/src/controllers/booking.controller.ts

@@ -0,0 +1,76 @@
+import { Response } from "express";
+import { Booking } from "../models/booking.model";
+import { Ride } from "../models/ride.model";
+import { Types } from "mongoose";
+import { AuthRequest } from "../middleware/auth.middleware";
+import { isUserInRide } from "../utils/rideUtils";
+import { StatusCodes } from "http-status-codes";
+import { ICreateBookingPayload } from "@/schemas/bookingSchema";
+
+export class BookingController {
+  static async createBooking(
+    req: AuthRequest<{}, {}, ICreateBookingPayload>,
+    res: Response
+  ) {
+    try {
+      const { rideId } = req.body;
+      const passengerId = req.user?.userId;
+
+      if (!Types.ObjectId.isValid(rideId)) {
+        return res.error("Invalid Ride ID", StatusCodes.BAD_REQUEST);
+      }
+
+      const rideDoc = await Ride.findById(rideId);
+      if (!rideDoc) {
+        return res.error("Ride not found", StatusCodes.NOT_FOUND);
+      }
+
+      if (!rideDoc.isBookable()) {
+        return res.error(
+          "Ride is not available for booking.",
+          StatusCodes.BAD_REQUEST
+        );
+      }
+
+      if (rideDoc.driver.toString() === passengerId) {
+        return res.error(
+          "Driver cannot book their own ride.",
+          StatusCodes.BAD_REQUEST
+        );
+      }
+
+      if (await isUserInRide(passengerId!, rideId)) {
+        return res.error(
+          "User already in ride or has pending booking.",
+          StatusCodes.BAD_REQUEST
+        );
+      }
+
+      rideDoc.passengers.push({
+        user: new Types.ObjectId(passengerId),
+        seatsBooked: 1,
+        status: "pending",
+      });
+      await rideDoc.save();
+
+      const booking = await Booking.create({
+        passenger: passengerId,
+        driver: rideDoc.driver,
+        ride: rideId,
+        status: "pending",
+      });
+
+      return res.success(
+        { status: booking.status },
+        "Booking created successfully.",
+        StatusCodes.CREATED
+      );
+    } catch (error) {
+      return res.error(
+        "Server Error",
+        StatusCodes.INTERNAL_SERVER_ERROR,
+        error
+      );
+    }
+  }
+}