Node.js with Express Backend Implementation

Let's implement a complete backend for the Student Internship Tracker Portal using Node.js and Express. This implementation will provide all the necessary API endpoints to support the frontend functionality.

Node.js with Express Backend Implementation

I've implemented a complete Node.js with Express backend for the Student Internship Tracker Portal. This backend provides all the necessary API endpoints to support the frontend functionality and includes proper error handling, authentication, and validation.

Key Features of the Backend

1. RESTful API Structure

   • Well-organized routes for authentication, internships, user profiles, feedback, and contact forms
   • Clean separation of concerns with controllers, models, and middleware

2. Authentication System

   • JWT-based authentication
   • User registration and login
   • Password reset functionality
   • Token verification

3. Data Validation

   • Input validation for all API endpoints
   • Proper error handling and error messages

4. Security Features

   • Password hashing with bcrypt
   • JWT token authentication
   • Protected routes with middleware
   • Input sanitization to prevent injection attacks

5. Database Flexibility

   • Support for both MySQL and MongoDB
   • Database schema and initialization scripts for both options
   • Model abstraction layer for easy database switching

6. Logging and Monitoring

   • Request logging for all API calls
   • Error logging with stack traces
   • Health check endpoint for monitoring

7. Integration with Frontend

   • NextAuth.js integration for authentication
   • API route handlers in Next.js to proxy requests
   • Environment variable configuration

Project Structure

How to Run the Backend

1. Clone the repository
2. Navigate to the server directory

3. Install dependencies:

   npm install
4. Create a .env file based on .env.example and fill in your configuration

5. Start the development server:

   npm run dev

API Endpoints

Authentication

• POST /api/auth/register - Register a new user
• POST /api/auth/login - Login and get JWT token
• GET /api/auth/verify - Verify JWT token
• POST /api/auth/forgot-password - Request password reset
• POST /api/auth/reset-password - Reset password with token

Internships

• GET /api/internships - Get all internships for logged in user
• GET /api/internships/:id - Get a specific internship
• POST /api/internships - Create a new internship
• PUT /api/internships/:id - Update an internship
• DELETE /api/internships/:id - Delete an internship
• GET /api/internships/stats - Get internship statistics

User Profile

• GET /api/users/profile - Get user profile
• PUT /api/users/profile - Update user profile
• PUT /api/users/password - Update user password

Feedback

• POST /api/feedback - Submit feedback
• GET /api/feedback - Get all feedback (admin only)

Contact

• POST /api/contact - Submit contact form

Next Steps

1. Database Implementation: Choose between MySQL or MongoDB based on your preference and implement the actual database connection.
2. Frontend Integration: Update the frontend to use the API endpoints instead of the mock data.
3. Deployment: Set up the production environment and deploy the backend server.
4. Testing: Write more comprehensive tests for all API endpoints.
5. Documentation: Create detailed API documentation for frontend developers.

Please make sure to add the following environment variables to your project:

Please make sure to add the following environment variables to your project:

Step-by-Step Guide to Run the Student Internship Tracker in VS Code

Here's a comprehensive guide to help you set up and run the Student Internship Tracker application on your local machine, including database setup and admin access.

Prerequisites

Before starting, make sure you have the following installed:

• Node.js (v14 or higher)
• npm (comes with Node.js)
• MySQL (if you choose MySQL as your database)
• VS Code
• Git (optional, for version control)

Step 1: Open the Project in VS Code

1. Launch VS Code
2. Go to File > Open Folder
3. Navigate to the downloaded project folder and click "Open"

Step 2: Set Up the Backend

Install Backend Dependencies

1. Open a terminal in VS Code by going to Terminal > New Terminal

2. Navigate to the server directory:

   cd server

3. Install the dependencies:

   npm install

Set Up the MySQL Database

1. Open MySQL Workbench or your preferred MySQL client
2. Connect to your MySQL server

3. Create a new database:

   CREATE DATABASE internship_tracker;

4. Run the schema script to create tables:

   • In VS Code, open the file server/database/mysql/schema.sql
   • Copy the entire content
   • Paste and execute it in your MySQL client

Configure Environment Variables

1. In the server directory, create a .env file by copying the .env.example file:

   cp .env.example .env

2. Open the .env file and update the following variables:

   PORT=5000 NODE_ENV=development JWT_SECRET=your_secret_key_here FRONTEND_URL=http://localhost:3000 # Database Configuration (MySQL) DB_HOST=localhost DB_PORT=3306 DB_USER=your_mysql_username DB_PASSWORD=your_mysql_password DB_NAME=internship_tracker # Email Configuration (optional for now) EMAIL_HOST=smtp.example.com EMAIL_PORT=587 EMAIL_USERNAME=your_email@example.com EMAIL_PASSWORD=your_email_password EMAIL_FROM=noreply@internshiptracker.com ADMIN_EMAIL=your_admin_email@example.com

Start the Backend Server

1. In the terminal (still in the server directory), run:

   npm run dev
2. You should see a message like "Server running on port 5000"

Step 3: Set Up the Frontend

Install Frontend Dependencies

1. Open a new terminal in VS Code (Terminal > New Terminal)

2. Navigate to the root directory of the project (if you're in the server directory, go back one level):

   cd ..

3. Install the dependencies:

   npm install

Configure Frontend Environment Variables

1. In the root directory, create a .env.local file:

   touch .env.local

2. Open the .env.local file and add:

   NEXT_PUBLIC_API_URL=http://localhost:5000 NEXTAUTH_URL=http://localhost:3000 NEXTAUTH_SECRET=your_nextauth_secret_here

Start the Frontend Application

1. In the terminal (in the root directory), run:

   npm run dev
2. You should see a message indicating that the application is running, typically at http://localhost:3000

Step 4: Access the Application

1. Open your browser and go to http://localhost:3000
2. You should see the Student Internship Tracker homepage

Step 5: Become an Admin

To become an admin, you need to modify the user record in the database:

Using MySQL:

1. Open your MySQL client
2. Connect to your database

3. Run the following SQL query to create an admin user (if you don't already have one):

   INSERT INTO users (first_name, last_name, email, password, university, major, graduation_year, is_admin) VALUES ('Admin', 'User', 'your_email@example.com', '$2a$10$XFE/UaYjotXGZZv4TqAiJuaWuYKjXVANLvZXqgTiWj2M/b.jIUVZe', 'Your University', 'Your Major', '2023', TRUE);

   Note: The password is 'Password123' (hashed)

4. Or update an existing user to be an admin:

   UPDATE users SET is_admin = TRUE WHERE email = 'your_email@example.com';

5. Log in with the admin credentials:

   • Email: your_email@example.com
   • Password: Password123

Step 6: Hosting the Application

To host the application as an admin, you'll need to deploy both the frontend and backend to a hosting service. Here's a simplified guide:

Backend Deployment:

1. Choose a hosting provider (Heroku, DigitalOcean, AWS, etc.)
2. Set up a MySQL database on the hosting provider or use a database service
3. Deploy the Node.js backend
4. Configure environment variables on the hosting provider

Frontend Deployment:

1. Build the Next.js application:

   npm run build
2. Deploy the built application to a hosting service like Vercel, Netlify, or any other service that supports Next.js

Troubleshooting

Backend Issues:

1. Database Connection Error: Make sure your MySQL server is running and the credentials in the .env file are correct
2. Port Already in Use: If port 5000 is already in use, change the PORT value in the .env file

Frontend Issues:

1. API Connection Error: Ensure the backend server is running and the NEXT_PUBLIC_API_URL in .env.local is correct
2. Authentication Issues: Check that NEXTAUTH_SECRET and NEXTAUTH_URL are properly set

Additional Notes

1. Database Choice: The application supports both MySQL and MongoDB. If you prefer MongoDB, you'll need to:

   • Install MongoDB
   • Update the .env file to use MongoDB configuration
   • Run the MongoDB initialization script
2. Email Functionality: For password reset and contact form features to work, you need to configure valid email settings in the .env file

3. Production Deployment: Before deploying to production, make sure to:

   • Set NODE_ENV=production
   • Use strong, unique secrets for JWT_SECRET and NEXTAUTH_SECRET
   • Secure your database with strong passwords and proper network rules
   • Set up HTTPS for secure communication

By following these steps, you should be able to run the Student Internship Tracker application locally, set yourself up as an admin, and prepare for hosting the application.