BackEnd.Server

Step-by-Step Plan to Code the **Job Connect Platform**

This plan will guide you through the process of creating a **Job Connect Platform** with features such as **authentication**, **job listing**, **application management**, and **user profiles** using **React.js** for the frontend and **Node.js with Express** for the backend.

---

**Part 1: Setting Up the Backend (Node.js & Express)**

 Step 1: Set Up the Project Directory

1. **Create a new directory** for the project:

   ```bash
   mkdir job-connect
   cd job-connect
   ```

2. **Initialize a new Node.js project**:

   ```bash
   npm init -y
   ```

3. **Install required dependencies**:

   ```bash
   npm install express mongoose bcryptjs jsonwebtoken dotenv
   npm install --save-dev nodemon
   ```

4. **Create the folder structure**:

   ```bash
   mkdir server
   cd server
   mkdir models routes controllers middleware config
   touch server.js
   ```

---

Step 2: Configure Environment Variables

1. **Create a `.env` file** in the `server` folder:

   ```bash
   touch .env
   ```

2. Add your MongoDB URI, JWT secret, and other environment variables:

   ```plaintext
   MONGO_URI=your_mongo_connection_string
   JWT_SECRET=your_jwt_secret_key
   ```

---

Step 3: Create Database Models

1. **Create `User.js` model** (`server/models/User.js`):

   ```js
   const mongoose = require("mongoose");

   const userSchema = new mongoose.Schema({
     username: {
       type: String,
       required: true,
     },
     email: {
       type: String,
       required: true,
       unique: true,
     },
     passwordHash: {
       type: String,
       required: true,
     },
     role: {
       type: String,
       enum: ["job_seeker", "recruiter"],
       required: true,
     },
   });

   module.exports = mongoose.model("User", userSchema);
   ```

2. **Create `Job.js` model** (`server/models/Job.js`):

   ```js
   const mongoose = require("mongoose");

   const jobSchema = new mongoose.Schema({
     title: {
       type: String,
       required: true,
     },
     companyName: {
       type: String,
       required: true,
     },
     location: {
       type: String,
       required: true,
     },
     jobDescription: {
       type: String,
       required: true,
     },
     createdBy: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "User",
       required: true,
     },
     datePosted: {
       type: Date,
       default: Date.now,
     },
   });

   module.exports = mongoose.model("Job", jobSchema);
   ```

3. **Create `Application.js` model** (`server/models/Application.js`):

   ```js
   const mongoose = require("mongoose");

   const applicationSchema = new mongoose.Schema({
     jobId: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "Job",
       required: true,
     },
     userId: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "User",
       required: true,
     },
     status: {
       type: String,
       enum: ["applied", "under review", "rejected", "accepted"],
       default: "applied",
     },
     dateApplied: {
       type: Date,
       default: Date.now,
     },
   });

   module.exports = mongoose.model("Application", applicationSchema);
   ```

---

Step 4: Create Authentication Logic

1. **Create Authentication Controller** (`server/controllers/authController.js`):

   ```js
   const bcrypt = require("bcryptjs");
   const jwt = require("jsonwebtoken");
   const User = require("../models/User");

   // Register User
   const registerUser = async (req, res) => {
     const { username, email, password, role } = req.body;
     try {
       const userExist = await User.findOne({ email });
       if (userExist) return res.status(400).json({ message: "User already exists!" });

       const salt = await bcrypt.genSalt(10);
       const passwordHash = await bcrypt.hash(password, salt);

       const newUser = new User({ username, email, passwordHash, role });
       await newUser.save();
       res.status(201).json({ message: "User registered successfully!" });
     } catch (error) {
       res.status(500).json({ message: "Server error!" });
     }
   };

   // Login User
   const loginUser = async (req, res) => {
     const { email, password } = req.body;
     try {
       const user = await User.findOne({ email });
       if (!user) return res.status(400).json({ message: "User not found!" });

       const isMatch = await bcrypt.compare(password, user.passwordHash);
       if (!isMatch) return res.status(400).json({ message: "Invalid credentials!" });

       const token = jwt.sign({ userId: user._id, role: user.role }, process.env.JWT_SECRET, { expiresIn: "1h" });
       res.status(200).json({ token });
     } catch (error) {
       res.status(500).json({ message: "Server error!" });
     }
   };

   module.exports = { registerUser, loginUser };
   ```

2. **Create Authentication Routes** (`server/routes/authRoutes.js`):

   ```js
   const express = require("express");
   const { registerUser, loginUser } = require("../controllers/authController");

   const router = express.Router();

   router.post("/register", registerUser);
   router.post("/login", loginUser);

   module.exports = router;
   ```

---
Step 5: Create Job Listing Logic

1. **Create Job Controller** (`server/controllers/jobController.js`):

   ```js
   const Job = require("../models/Job");

   // Create Job Listing
   const createJob = async (req, res) => {
     const { title, companyName, location, jobDescription } = req.body;
     const job = new Job({ title, companyName, location, jobDescription, createdBy: req.userId });
     try {
       await job.save();
       res.status(201).json({ message: "Job posted successfully!" });
     } catch (error) {
       res.status(500).json({ message: "Error creating job!" });
     }
   };

   module.exports = { createJob };
   ```

2. **Create Job Routes** (`server/routes/jobRoutes.js`):

   ```js
   const express = require("express");
   const { createJob } = require("../controllers/jobController");
   const { protect } = require("../middleware/authMiddleware");

   const router = express.Router();

   router.post("/jobs", protect, createJob);

   module.exports = router;
   ```

---

Step 6: Middleware for Protecting Routes

1. **Create Authentication Middleware** (`server/middleware/authMiddleware.js`):

   ```js
   const jwt = require("jsonwebtoken");

   const protect = (req, res, next) => {
     const token = req.header("x-auth-token");
     if (!token) return res.status(401).json({ message: "No token, authorization denied" });

     try {
       const decoded = jwt.verify(token, process.env.JWT_SECRET);
       req.userId = decoded.userId;
       req.role = decoded.role;
       next();
     } catch (error) {
       res.status(401).json({ message: "Token is not valid" });
     }
   };

   module.exports = { protect };
   ```

---

Step 7: Set Up the Server

1. **Create the Express server** (`server/server.js`):

   ```js
   const express = require("express");
   const mongoose = require("mongoose");
   const dotenv = require("dotenv");
   const authRoutes = require("./routes/authRoutes");
   const jobRoutes = require("./routes/jobRoutes");

   dotenv.config();

   const app = express();

   app.use(express.json());
   app.use("/api/auth", authRoutes);
   app.use("/api", jobRoutes);

   const start = async () => {
     try {
       await mongoose.connect(process.env.MONGO_URI);
       console.log("Connected to MongoDB");
       app.listen(5000, () => console.log("Server running on port 5000"));
     } catch (error) {
       console.error(error);
     }
   };

   start();
   ```

---