AlumniVerse/docs/SRS.md

# AlumniVerse - Software Requirements Specification

## Project Overview

**AlumniVerse** is a web-based alumni network management platform built with React/TypeScript frontend and Django REST API backend.

## Tech Stack

- **Frontend**: React with TypeScript, Tailwind CSS
- **Backend**: Django with Django REST Framework
- **Database**: MySQL (development), PostgreSQL (production)
- **Authentication**: JWT with optional Multi-Factor Authentication (MFA)
- **Real-time**: WebSockets via Django Channels and Redis for messaging and notifications

## 🚀 Core Features

### 👤 User & Access

- Email-based registration and login (JWT)
- Optional multi-factor authentication (MFA)
- Roles: Alumni, Staff, Admin
- Password reset & session timeout

### 🧑‍🎓 Alumni Directory

- Rich profiles (education, work, location)
- Filtered search + map view
- Connection requests & privacy settings

### 📅 Events

- Host online/offline events
- Register, track attendance, and integrate calendars
- Support for paid events (Stripe/PayPal)

### 💼 Jobs & Careers

- Post jobs, apply, and upload resumes
- Set alerts and book career sessions
- Track certifications and skills

### 💬 Messaging

- Real-time 1:1 and group chat (WebSockets)
- File sharing, search, and message history
- Forums with moderation tools

### 📚 Learning & Mentorship

- Enroll in courses, track progress
- Get certifications
- Match with mentors and follow learning paths

### 💰 Donations

- One-time or recurring donations
- Campaigns and receipt generation

### 📊 Analytics

- User activity and event insights
- Custom reports and dashboards
- Fundraising and donation metrics

## 🔧 Technical Overview

### 💻 Frontend (What users see)

- Built with modern tools (React, TypeScript) for a fast and smooth experience
- Works well on phones, tablets, and computers
- Clean and responsive design using Tailwind CSS
- Forms, buttons, and pages that update quickly and feel like an app

### 🧠 Backend (What powers the system)

- Built with Django (Python) to handle logic, data, and security
- Uses an API system so frontend and backend can talk to each other
- Handles login, user roles, events, messages, and more
- Includes admin panel to manage users, jobs, events, etc.

### 🔐 Security

- Passwords are safely encrypted
- Login uses secure tokens (JWT)
- Optional two-step verification for better protection
- Private data is kept safe and only visible to the right users

### 💬 Real-Time Messaging

- Users can chat instantly — like WhatsApp or Messenger
- System uses WebSocket technology to send and receive messages live
- Group chats and file sharing are also supported

### 🗃️ Database

- Stores all information (users, messages, jobs, etc.) in a structured way
- Uses MySQL during development and PostgreSQL in live servers

### 💸 Payments & Events

- Supports paid event registrations and donations (via Stripe or PayPal)
- Sends confirmation emails after payments
- Can sync with Google or Outlook Calendar

### 📊 Dashboard & Reports

- Admins can view analytics like:
  - Active users
  - Event attendance
  - Job applications
  - Donation totals
- Reports can be downloaded when needed

### 🚀 Deployment & Hosting

- Runs on reliable servers using modern web hosting tools
- Sends emails, handles chat, stores files, and keeps things running smoothly

### Database Schema (Key Entities) (Subjected to Change)

```
Users: id, email, password_hash, role, created_at, updated_at
Profiles: user_id, first_name, last_name, bio, location, graduation_year
Events: id, title, description, date, capacity, location, event_type
Jobs: id, title, company, description, requirements, salary_range
Messages: id, sender_id, recipient_id, content, timestamp
Donations: id, user_id, amount, campaign_id, payment_status
```

### API Endpoints (Core)(Can be Added/Modified)

```
Authentication:
POST /api/auth/login
POST /api/auth/register
POST /api/auth/refresh

Alumni Directory:
GET /api/alumni?filters
GET /api/alumni/{id}
PUT /api/alumni/{id}

Events:
GET /api/events
POST /api/events
POST /api/events/{id}/register

Jobs:
GET /api/jobs
POST /api/jobs
POST /api/jobs/{id}/apply

Messages:
GET /api/messages
POST /api/messages
WebSocket: /ws/chat/

Donations:
POST /api/donations
GET /api/donations/history
```

## 🧑‍💻 Development Requirements

### 💻 System Requirements

- **Operating System**: Linux (recommended because I use that 😂), macOS, or Windows (WSL works well)
- **Python**: 3.10 or later
- **Node.js**: 18 or later (required for React + Vite)
- **npm** or **pnpm**: Latest stable version
- **MySQL**: 8.x (for development)
- **PostgreSQL**: 14+ (optional, for production testing)
- **Redis**: 6.x or later (for WebSocket and caching)
- **Docker** (optional): For containerized development

---

### 🔧 Development Tools

- **Code Editor**: VS Code or Neovim (with your favorite plugins)
- **Version Control**: Git + GitHub
- **API Testing & Documentation**: Swagger or Django REST Framework’s built-in documentation UI
- **Browser DevTools**: Chrome or Firefox (for frontend debugging)

### 📦 Backend Setup (Django)

- Create and activate virtual environment
- Install dependencies via `pip` or `uv`
- Set up `.env` file with:
  - `SECRET_KEY`
  - `DEBUG`
  - `DB_CONFIG` (MySQL/Postgres)
  - `REDIS_URL`
  - `EMAIL_CONFIG`
- Run database migrations: `python manage.py migrate`
- Start development server: `python manage.py runserver`

### 💻 Frontend Setup (React + Tailwind)

- Navigate to the frontend directory
- Install dependencies: `npm install` or `pnpm install`
- Start dev server: `npm run dev`
- Tailwind is pre-configured using `postcss` and `autoprefixer`
- Axios is used to connect to the backend API

### 🔄 Real-time Features

- Redis server must be running locally
- WebSocket is enabled via Django Channels
- Use `daphne` or `uvicorn` for running ASGI app in dev
- Configure CORS and allowed origins for frontend-backend communication

### 🧪 Testing & Linting

- Django tests: `python manage.py test`
- React tests: `npm run test`
- Linting:
  - Python: `ruff` or `flake8`
  - JavaScript/TS: `eslint` + `prettier`
- Git pre-commit hooks (optional): Set up using `pre-commit`

### 🐳 Docker (Optional Dev Workflow)

- Dockerfile and `docker-compose.yml` included
- Run full stack with: `docker-compose up`
- Supports live-reloading in both frontend and backend

### 📝 Other Requirements

- Keep code modular and reusable
- Follow project naming conventions and folder structure
- Write docstrings, comments, and maintain clean commits
- Regularly pull and merge from the main branch

---

> ✅ Tip: Use a `.env.example` file to share config structure with the team.

## User Roles & Permissions (Will be Added/Modified)

**Alumni:**

- View/edit own profile
- Search directory
- Register for events
- Apply for jobs
- Send messages
- Make donations

**Staff:**

- Manage events
- Moderate content
- View analytics
- Manage job postings

**Admin:**

- Full system access
- User management
- System configuration
- Analytics access

## Development Phases

**The development will be divided into the following phases:**
**Most of the process may not be possible to cover all the phases**

### 1. Planning & Requirement Analysis

- Finalize feature list and project scope
- Define user roles and access levels
- Design database schema and API endpoints
- Prepare wireframes and UI mockups

### 2. Backend Development (Django)

- Set up Django project with REST Framework and Channels
- Implement user authentication (JWT + MFA)
- Build core APIs for Alumni Directory, Events, Jobs, Messaging, etc.
- Integrate Redis for caching and WebSocket support
- Write unit tests for backend functionality

### 3. Frontend Development (React + Vite + Tailwind)

- Initialize React project with TypeScript and Tailwind CSS
- Build reusable UI components aligned with wireframes
- Connect frontend to backend APIs using Axios
- Implement real-time messaging via WebSocket connection
- Add client-side validation and error handling
- Write frontend tests for critical components

### 4. Integration & Testing

- Test full user flows end-to-end (registration, messaging, events)
- Perform cross-browser and responsiveness testing
- Fix bugs and optimize performance
- Use Swagger or DRF docs to validate API contracts

### 5. Deployment & Monitoring (It May not be Possible to cover all the steps in this phase)

- Prepare production environment (PostgreSQL, Redis, Docker)
- Deploy backend and frontend (e.g., on VPS, cloud provider)
- Set up SSL, domain, and environment variables
- Monitor logs and app performance post-deployment
- Collect user feedback for future improvements

---

> 🔑 Tip: Follow Agile iterations with regular commits, code reviews, and testing in each phase for smoother delivery.

---

**Document Version:** 0.1
**Last Updated:** June 15, 2025
**Target Audience:** Development Team