Edosaic — Student Management System

Edosaic — a portmanteau of Education and Mosaic — is a comprehensive, role-based Student Management System built with Django. It unifies every facet of academic administration into a single, secure platform for schools, colleges, universities, and coaching centers.

The platform includes STAN, an AI chatbot powered by Groq's Llama 3.1 8B that delivers real-time institutional insights from your live data.

Key Features

• Multi-Tenant Architecture — Complete data isolation between institutions on a shared codebase
• 7 Role-Based Dashboards — Chairman, Director, HOD, Faculty, Student, Accountant, and Librarian with tailored permissions
• AI-Powered Assistant (STAN) — Context-aware chatbot that queries your live institutional data
• Full Academic Workflow — Courses, branches, subjects, faculty assignments, attendance, exams, results, and grade tracking
• Library & Event Management — Book inventory, issue/return tracking, fine management, and event scheduling
• OAuth Authentication — Google and GitHub login with invite-code-based self-registration
• Dual Theme UI — Light mode with professional gradients and dark mode with glassmorphism
• Responsive Design — Fully functional on desktop, tablet, and mobile
• Production-Ready — Dockerized with Gunicorn, PostgreSQL, and auto-deploy via Render.com

Tech Stack

Layer	Technology
Backend	Django 6.0.7, Python 3.12
Database	PostgreSQL 16 (SQLite for dev)
Auth	django-allauth 65.x (OAuth + credentials)
AI Chat	Groq API (Llama 3.1 8B)
Frontend	Custom CSS (dual-theme), Lucide Icons, Chart.js
Deployment	Docker, Render.com
Static Files	Whitenoise

Architecture

Role Hierarchy

Chairman
  └── Director
        └── HOD (Head of Department)
              └── Faculty
                    └── Student
                        └── Parent

Accountant and Librarian are staff roles with institution-wide access to fees/finances and library operations respectively.

Multi-Tenant Design

Every data model includes a ForeignKey to Institution, ensuring complete data isolation between organizations on a shared codebase. Each institution gets a unique invite code for self-registration.

Request Flow

Browser → Django Views (role-gated) → Templates (per-role) → Response
                ↕
           Django ORM → PostgreSQL (per-institution)
                ↕
         STAN Chatbot → Groq API (Llama 3.1 8B)

All views are function-based with @login_required and manual role checks. The dashboard router redirects users based on their role field.

Database Model

The system comprises 21 models across two Django apps:

Accounts

Model	Key Fields	Purpose
User	role, institution (FK)	Extends AbstractUser with role-based access

Core — Institution & People

Model	Key Fields	Purpose
Institution	name, slug, invite_code	Multi-tenant container
Chairman	institution (O2O)	Institution owner
Director	department, courses (M2M)	Manages HODs
HOD	department, courses (M2M)	Manages faculty
Faculty	courses (M2M), students (M2M)	Teaches & mentors
Student	course (FK), branch (FK)	Enrolled learner

Core — Academic

Model	Key Fields	Purpose
Course	name, code, department	Academic program
Branch	course (FK)	Specialization track
Subject	course, branch (FKs), credits	Course subject
FacultyTeaching	faculty, course, subject	Faculty-subject assignment
StudentCourse	student, course	Enrollment record

Core — Academics & Finance

Model	Key Fields	Purpose
Attendance	student, date, status	Daily attendance
Exam	course, exam_type, total_marks	Exam definition
ExamResult	exam, student, marks	Per-exam scores
Result	student, course, grade	Final course grade
Fee	student, amount, fee_type, status	Fee tracking

Core — Library

Model	Key Fields	Purpose
Book	title, author, isbn, total_copies	Book inventory
BookIssue	book, student, due_date, status	Issue/return tracking
BookFine	book_issue, amount, status	Late fine management

Core — Events & Audit

Model	Key Fields	Purpose
Event	title, event_type, start_date	Institutional events
AuditLog	action, username, role	Activity audit trail

Roadmap

• Mobile App — Native Android/iOS apps for students and faculty
• Real-Time Notifications — Email, SMS, and in-app alerts for attendance, fees, and results
• Payment Gateway Integration — Online fee payment via Razorpay/Stripe
• Timetable Generator — Automated class scheduling with conflict detection
• Report Card Generator — PDF report cards with institution branding
• LMS Integration — Link subjects to uploaded study materials and assignments
• Parent Dashboard — Enhanced monitoring with push notifications
• Analytics Dashboard — Advanced charts, trend analysis, and exportable reports
• OAuth Expansion — Microsoft and LinkedIn login support
• STAN Enhancements — Multi-language support, voice input, and proactive alerts

Project Structure

sms-django/
├── sms_django/           # Project configuration (settings, urls, wsgi)
├── accounts/             # Authentication, user model, OAuth, landing page
├── core/                 # Business logic, models, dashboards, AI chat
├── templates/            # HTML templates
│   ├── components/       # Reusable sidebar templates
│   ├── admin_panel/      # Admin dashboard pages
│   ├── faculty/          # Faculty dashboard
│   ├── student/          # Student dashboard
│   ├── parent/           # Parent dashboard
│   └── accounts/         # Login, register, landing, role-select
├── static/css/           # theme.css, style.css, auth.css, chat.css, landing.css
├── Dockerfile
├── docker-compose.yml
└── render.yaml

Getting Started

Prerequisites

• Python 3.12+
• PostgreSQL (or SQLite for development)
• Groq API key (for STAN chatbot)

Local Development

git clone https://github.com/Satendra90390/Edosaic.git
cd Edosaic

python -m venv venv
venv\Scripts\activate        # Windows
# source venv/bin/activate   # macOS/Linux

pip install -r requirements.txt

cp .env.example .env
# Edit .env with your values

python manage.py migrate
python manage.py createsuperuser
python seed.py               # Optional: seed demo data

python manage.py runserver

Environment Variables

DJANGO_SECRET_KEY=your-secret-key
DEBUG=True
ALLOWED_HOSTS=localhost,127.0.0.1

# OAuth (optional)
GOOGLE_CLIENT_ID=
GOOGLE_CLIENT_SECRET=
GITHUB_CLIENT_ID=
GITHUB_CLIENT_SECRET=

# AI Chatbot (optional)
GROQ_API_KEY=

Docker Deployment

docker compose up -d --build
docker compose exec web python manage.py migrate
docker compose exec web python manage.py createsuperuser

Render.com Deployment

The included render.yaml enables automatic deployment. Connect your GitHub repository to Render, and it will configure the web service and PostgreSQL database automatically.

Demo Credentials

After running python seed.py:

Role	Username	Password
Chairman	admin	admin123
Faculty	faculty1	pass1234
Student	student1	pass1234
Parent	parent1	pass1234

FAQ

Question	Answer
Who is Edosaic for?	Schools, colleges, universities, and coaching centers that need a centralized academic management platform.
What roles are supported?	Seven roles across the hierarchy: Chairman, Director, HOD, Faculty, Student, Accountant, and Librarian — each with a dedicated dashboard and permission set.
Can I run it without Docker?	Yes. The project runs with python manage.py runserver and SQLite for local development. Docker is optional and intended for production.
Is STAN mandatory?	No. STAN (AI chatbot) requires a Groq API key. Without it, all other features work normally.
How do I get started quickly?	Clone the repo, run python seed.py, and log in with the demo credentials above. The seed script populates sample data for all roles.
How do I deploy to production?	Use Docker Compose with PostgreSQL, or deploy via Render.com using the included render.yaml. See the Deployment Guide.
Is OAuth required?	No. Users can register via email/password or institution invite codes. Google and GitHub OAuth are optional.
How is data isolated between institutions?	Every model has a ForeignKey to Institution, ensuring complete data separation on a shared codebase.

License

MIT License