Added Signup Endpoint

backend/src/controllers/authentication.controller.ts

@@ -3,9 +3,10 @@ import {
   AuthenticationControllerInterface,
   AuthenticationServiceInterface,
 } from "../../types.js";
+import { BadRequestError } from "../errors/errors.js";
 
 class AuthenticationController implements AuthenticationControllerInterface {
-  constructor(private authentication: AuthenticationServiceInterface) {}
+  constructor(private authenticationService: AuthenticationServiceInterface) {}
 
   postLogin = async (
     req: Request,
@@ -21,6 +22,36 @@ class AuthenticationController implements AuthenticationControllerInterface {
     next: NextFunction
   ): Promise<void | Response<any, Record<string, any>>> => {
     // TODO: Implement postSignup controller (Ryan)
+    const bcrypt = require('bcrypt');
+    const saltRounds = 10; // Cost factor for hashing - 10 is a good balance between security and performance
+    var hashword = "failed";
+    try{
+      const email = req.body.email 
+      const password = req.body.password
+      const firstName = req.body.firstName
+      const lastName = req.body.lastName
+      //getting signup details from the body
+      if(email == null || password == null || firstName == null || lastName == null){
+        throw new BadRequestError("All fields must be submitted")
+      }
+      bcrypt.hash(password, saltRounds, (err: any, hash: string) => {
+        if (err) {
+          console.error('Error while hashing:', err);
+
+        } else {
+          // console.log('Hashed Password:', hash);
+          hashword = hash;
+        }
+      });
+      //encrypting password 
+      const createdUser = this.authenticationService.signup(email, hashword, firstName, lastName);//creating the user?
+      // req.session.user = createdUser; //session doesn't have a user?
+      return 
+    }
+    catch (err){
+      next(err)
+    }
+
   };
 
   postLogout = async (

backend/src/middlewares/session.middleware.ts

@@ -1,6 +1,6 @@
 import session from "express-session";
 import redis from "redis";
-import { SESSION_SECRET, REDIS_URL } from "../config/config";
+import { SESSION_SECRET, REDIS_URL } from "../config/config.js";
 const RedisStore = require("connect-redis")(session);
 
 const redisClient = redis.createClient({

backend/src/models/user.model.ts

@@ -1,6 +1,6 @@
 import { UserInterface } from "../../types.js";
 
-class User implements UserInterface {
+export class User implements UserInterface {
   constructor(
     private email: string,
     private password: string,

backend/src/services/authentication.service.ts

@@ -1,15 +1,17 @@
 import { UserRepositoryInterface } from "../../types";
-import UserRepository from "../repositories/user.repository";
+import {User} from "../models/user.model"
 
 class AuthenticationService implements AuthenticationService {
-  constructor(private UserRepository: UserRepositoryInterface) {}
+  constructor(private userRepository: UserRepositoryInterface) {}
 
   async login(): Promise<void> {
     // TODO: Implement login and initialize session (Anfaal)
   }
 
-  async signup(): Promise<void> {
+  async signup(email: string, password:string, firstName:string, lastName:string): Promise<void> {
     // TODO: Implement signup and initialize session (Ryan)
+    const newUser = new User(email,password,firstName,lastName)
+    this.userRepository.createUser(newUser)
   }
 
   async logout(): Promise<void> {

backend/test/authentication.test.ts

@@ -1,7 +1,27 @@
 import request from "supertest";
 import { assert } from "chai";
 import { http } from "./config.test.js";
+var bcrypt = require('bcrypt');
+const testUser = {
+  email:"[email protected]",
+  password:"$2b$10$5jUD1fhvp1YLSE1FpnEa5eVpOZTOp5wivb6DtvrkeKfIO0/ZTCAqG",
+  firstName:"Ryan",
+  lastName:"Ryan"
+}
 
 describe("Authentication", () => {
-  // TODO: Add tests for authentication and session management
+  it("Signup should return a 201 status code", async () => {
+    const res: request.Response = await http.post("/auth/signup").send({
+      email:testUser.email,
+      password:testUser.password,
+      firstName:testUser.firstName,
+      lastName:testUser.lastName
+  });
+    assert.equal(res.body.email,testUser.email);
+    assert.equal(res.body.firstName,testUser.firstName);
+    assert.equal(res.body.lastName,testUser.lastName);
+    bcrypt.compare("mySecurePassword123", res.body.password, function(err: any, result: boolean) {
+      assert(result);
+    });
+  });
 });

backend/types.ts

@@ -47,7 +47,7 @@ export interface AuthenticationControllerInterface {
 
 export interface AuthenticationServiceInterface {
   login(): Promise<void>;
-  signup(): Promise<void>;
+  signup(email: string, password:string, firstName:string, lastName:string): Promise<void>;
   logout(): Promise<void>;
 }