Project Ashwini

A Comprehensive IoT-Ready Healthcare Management Platform for Clinics and Hospitals

Project Ashwini is an enterprise-grade, full-stack healthcare management system with multi-platform support, role-based access control, patient portal, mobile applications, and IoT device integration capabilities. The platform streamlines patient flow, vitals monitoring, prescription management, medical report analysis, and patient engagement.

Live Application Links:

Patient Portal - https://ashwini-patient.vercel.app Doctor's Portal - https://ashwini-unified-view.vercel.app Reception Portal - https://ashwini-frontend-main.vercel.app Patient Apk File- https://drive.google.com/file/d/1UoXjzWolk13Ztbwss2lLqTOc-DgAyMJZ/view?usp=sharing

📋 Table of Contents

Overview
System Architecture
Features
Tech Stack
Project Structure
Quick Start
Setup Instructions
User Roles & RBAC
API Endpoints
IoT Integration
Deployment
CI/CD & DevOps
Documentation
Usage Guide
Contributing
License

🎯 Overview

Project Ashwini is a complete healthcare ecosystem supporting multiple user types:

Staff Portals

Reception/Registration Staff: Patient registration and queue management
Nurses/Health Monitoring: Record patient vitals (manual or IoT-based)
Doctors: Comprehensive patient view with vitals, prescriptions, medical reports, and notes

Patient Portals

Patient Web Portal: Self-service access to health records, prescriptions, and visit history
Patient Mobile App: Native Android application for on-the-go health tracking

🏗️ System Architecture

┌─────────────────────────────────────────────────────────────────────────┐
│                       Project Ashwini Platform                          │
│            Multi-Portal Healthcare Management System                    │
└─────────────────────────────────────────────────────────────────────────┘

┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐
│  Main Frontend   │  │ Unified Frontend │  │  Patient Portal  │
│  (Port 4000)     │  │  (Port 3000)     │  │  (Vite)          │
│                  │  │                  │  │                  │
│ • Registration   │  │ • Doctor View    │  │ • Dashboard      │
│ • Health Monitor │  │ • Prescriptions  │  │ • Measurements   │
│ • Report Upload  │  │ • Patient Nav    │  │ • Prescriptions  │
└──────────────────┘  └──────────────────┘  └──────────────────┘
                                                      │
┌─────────────────────────────────────────────┐      │
│      Patient Mobile App (Android)           │      │
│                                             │      │
│  • Native Android (Capacitor)               │◄─────┘
│  • Health Tracking & Reports                │
│  • Offline Capability                       │
└─────────────────────────────────────────────┘
           │                    │                    │
           └────────────────────┼────────────────────┘
                                │
                    ┌───────────▼──────────┐
                    │   Django Backend     │
                    │   (Port 8000)        │
                    │                      │
                    │  • REST API          │
                    │  • JWT Auth          │
                    │  • RBAC              │
                    │  • PostgreSQL/SQLite │
                    └──────────────────────┘
                                │
                    ┌───────────▼──────────┐
                    │   External Services  │
                    │                      │
                    │  • Azure AI (OCR)    │
                    │  • Cloudinary        │
                    │  • IoT Devices       │
                    └──────────────────────┘

✨ Features

Current Features

Patient Management

Patient Registration: Complete demographic capture with auto-generated patient IDs
Queue Management: Real-time status tracking (waiting → checking → examined → completed)
Multi-Visit Support: Track visit history and patient journey
Patient Portal Integration: Link patients to user accounts for self-service access

Health Monitoring

Manual Vitals Entry: Blood pressure, temperature, SpO₂, heart rate, height, weight
Measurement History: Track vitals over time with trend analysis
IoT-Ready Framework: Pre-built models and endpoints for device integration
Real-time Updates: Automatic synchronization across all interfaces

Clinical Management

Prescription Management: Add/edit medicines with dose, type, and quantity
Prescription History: Track medication changes across visits
Doctor's Notes: Clinical observations and next visit scheduling
Patient Navigation: Easy previous/next patient browsing for doctors

Medical Report Analysis

Report Upload: Support for images and PDFs
AI-Powered OCR: Azure Document Intelligence integration for text extraction
Key Phrase Analysis: Automatic extraction of important medical terms
Cloud Storage: Cloudinary integration for production deployments

Authentication & Security

JWT-Based Authentication: Secure token-based auth with 1-hour access tokens and 7-day refresh tokens
Rate Limiting: Protection against brute force attacks (5 login attempts/minute, 3 registrations/hour per IP)
Required SECRET_KEY: No default secret key - must be explicitly configured in environment
Role-Based Access Control (RBAC): Five user roles (Admin, Doctor, Nurse, Reception, Patient)
Portal-Specific Access: Automatic routing based on user role
Consent Management: GDPR-compliant consent logging
CORS Configuration: Configured for mobile app compatibility (Android/iOS)

Patient Portal Features

Personal Dashboard: Overview of health metrics and upcoming visits
Measurement Tracking: View vitals history with interactive charts
Prescription Access: Current and historical prescriptions
Visit History: Comprehensive record of past consultations
Profile Management: Update contact information and preferences

Mobile Application

Native Android App: Built with Capacitor for native performance
Offline Support: Access health data without internet
Push Notifications: Appointment reminders and health alerts
Responsive Design: Optimized for mobile devices
CI/CD Pipeline: GitHub Actions for automated builds

IoT-Ready Architecture

Device Management Models: Complete device registration and tracking system
Measurement Session Tracking: Workflow for device-initiated measurements
ESP32 Integration: Sample code and setup guide for IoT devices
RESTful Device APIs: Pre-built endpoints for device communication
Real-time Synchronization: Automatic updates when devices submit data

🛠️ Tech Stack

Backend

Framework: Django 4.2+ with Django REST Framework
Authentication: djangorestframework-simplejwt (JWT tokens)
Database: SQLite (development) / PostgreSQL (production)
API: RESTful JSON APIs with CORS support
AI Integration: Azure Document Intelligence for OCR
Storage: Cloudinary for media files (production)
Server: Gunicorn with Whitenoise for static files

Frontend Stack

Main Frontend (Staff Portal)

Framework: React 18+ with Create React App
UI: Bootstrap 5 + Custom CSS
HTTP: Axios
Routing: React Router v6
Markdown: react-markdown with remark-gfm
Port: 4000

Unified Frontend (Doctor's Portal)

Framework: React 18+ with Create React App
UI: Bootstrap 5 + Custom CSS
HTTP: Axios
Routing: React Router v6
Port: 3000

Patient Portal (Web)

Framework: React 18+ with Vite
UI: Custom CSS with modern gradients
HTTP: Axios
Routing: React Router v6
Charts: Recharts for health data visualization

Patient Mobile App

Framework: React 18+ with Vite
Native: Capacitor 6.0
Platform: Android (iOS capable)
UI: Responsive mobile-first design
Charts: Recharts for health metrics
Build: Gradle-based Android build system

IoT Integration

Device: ESP32 microcontrollers
Protocol: HTTP/REST
Language: Arduino (C++)

Deployment & DevOps

Backend: Render.com (or Heroku)
Frontend: Vercel
Mobile: Google Play Store (Android)
CI/CD: GitHub Actions for Android builds
Version Control: Git/GitHub

Development Tools

Python: 3.8+
Node.js: 16+
Package Managers: pip, npm
Scripts: PowerShell automation scripts
Android Studio: For mobile development

📁 Project Structure

Ashwini/
├── .github/                          # GitHub Configuration
│   ├── workflows/
│   │   └── android-build.yml         # CI/CD for Android app builds
│   └── ANDROID_BUILD_SETUP.md
│
├── backend/                          # Django Backend (Port 8000)
│   ├── ashwini_backend/              # Main Django project
│   │   ├── settings.py               # Django configuration (CORS, JWT, DB)
│   │   ├── urls.py                   # Root URL routing
│   │   ├── wsgi.py                   # WSGI application
│   │   └── asgi.py                   # ASGI application
│   │
│   ├── patients/                     # Patient Management App
│   │   ├── models.py                 # Patient, VisitHistory, ConsentLog
│   │   ├── views.py                  # Patient CRUD APIs
│   │   ├── serializers.py            # Patient serializers
│   │   ├── auth_models.py            # CustomUser with RBAC roles
│   │   ├── auth_views.py             # JWT login/register/role endpoints
│   │   ├── auth_serializers.py       # Authentication serializers
│   │   ├── auth_urls.py              # Auth API routes
│   │   ├── patient_portal_views.py   # Patient portal-specific views
│   │   ├── patient_portal_urls.py    # Patient portal API routes
│   │   ├── permissions.py            # Custom permission classes
│   │   ├── urls.py                   # Patient API routes
│   │   └── admin.py                  # Django admin configuration
│   │
│   ├── measurements/                 # Vitals/Measurements App
│   │   ├── models.py                 # Measurement model (IoT-ready)
│   │   ├── views.py                  # Measurement CRUD APIs
│   │   ├── serializers.py            # Measurement serializers
│   │   └── urls.py                   # Measurement API routes
│   │
│   ├── prescriptions/                # Prescription Management App
│   │   ├── models.py                 # Prescription, PrescriptionHistory
│   │   ├── serializers.py            # Prescription serializers
│   │   └── admin.py                  # Admin interface
│   │
│   ├── devices/                      # IoT Device Management App
│   │   ├── models.py                 # Device, MeasurementSession models
│   │   ├── views.py                  # Device command/measurement APIs
│   │   ├── urls.py                   # Device API routes
│   │   └── admin.py                  # Device admin interface
│   │
│   ├── reports/                      # Medical Report Analysis App
│   │   ├── models.py                 # Report model
│   │   ├── views.py                  # Report upload & analysis APIs
│   │   ├── services.py               # Azure AI integration
│   │   ├── storage.py                # Cloudinary custom storage
│   │   ├── serializers.py            # Report serializers
│   │   └── urls.py                   # Report API routes
│   │
│   ├── media/                        # Uploaded files (development)
│   │   └── reports/
│   │
│   ├── manage.py                     # Django CLI
│   ├── requirements.txt              # Python dependencies
│   ├── db.sqlite3                    # SQLite database (development)
│   ├── build.sh                      # Render.com build script
│   ├── start.sh                      # Render.com start script
│   └── Procfile                      # Heroku deployment config
│
├── frontend-main/                    # Main Frontend - Staff Portal (Port 4000)
│   ├── src/
│   │   ├── components/
│   │   │   ├── RegistrationDashboard.js    # Patient registration UI
│   │   │   ├── HealthMonitoringStation.js  # Vitals entry UI
│   │   │   ├── ReportAnalysis.js           # Report upload & AI analysis
│   │   │   ├── Login.js                    # Staff authentication
│   │   │   └── RoleProtectedRoute.js       # RBAC route guard
│   │   ├── App.js                    # Main routing & navigation
│   │   ├── api.js                    # Axios API client
│   │   └── index.js                  # React entry point
│   ├── public/
│   │   └── index.html
│   ├── package.json                  # Dependencies & scripts
│   ├── vercel.json                   # Vercel deployment config
│   └── .env                          # API URL configuration
│
├── frontend-unified/                 # Doctor's Dashboard (Port 3000)
│   ├── src/
│   │   ├── components/
│   │   │   ├── PatientView.js        # Comprehensive patient view
│   │   │   ├── Login.js              # Doctor authentication
│   │   │   └── RoleProtectedRoute.js # RBAC route guard
│   │   ├── App.js                    # Patient navigation & switching
│   │   ├── api.js                    # Axios API client
│   │   └── index.js                  # React entry point
│   ├── public/
│   │   └── index.html
│   ├── package.json                  # Dependencies & scripts
│   ├── vercel.json                   # Vercel deployment config
│   └── .env                          # API URL configuration
│
├── frontend-patient/                 # Patient Web Portal (Vite)
│   ├── src/
│   │   ├── pages/
│   │   │   ├── Login.jsx             # Patient login
│   │   │   ├── Register.jsx          # Patient registration
│   │   │   ├── Dashboard.jsx         # Health overview
│   │   │   ├── Measurements.jsx      # Vitals history with charts
│   │   │   ├── Prescription.jsx      # Current & past prescriptions
│   │   │   ├── Visits.jsx            # Visit history
│   │   │   └── Profile.jsx           # Profile management
│   │   ├── components/               # Reusable UI components
│   │   ├── context/                  # Auth context
│   │   ├── routes/                   # Route configuration
│   │   └── api/                      # API client
│   ├── index.html
│   ├── package.json                  # Vite & dependencies
│   ├── vite.config.js                # Vite configuration
│   ├── vercel.json                   # Vercel deployment
│   └── README.md                     # Patient portal documentation
│
├── frontend-patient-mobile/          # Patient Mobile App (Android)
│   ├── android/                      # Android native project
│   │   ├── app/
│   │   │   └── src/main/
│   │   │       ├── AndroidManifest.xml
│   │   │       ├── res/              # App resources
│   │   │       └── assets/           # Web assets
│   │   ├── build.gradle              # Android build config
│   │   ├── gradle.properties
│   │   └── gradlew                   # Gradle wrapper
│   │
│   ├── src/                          # React source (same as patient portal)
│   │   ├── pages/
│   │   ├── components/
│   │   ├── context/
│   │   ├── routes/
│   │   └── api/
│   │
│   ├── resources/                    # App icons & splash screens
│   │   ├── icon.png
│   │   └── splash.png
│   │
│   ├── capacitor.config.json         # Capacitor configuration
│   ├── package.json                  # Capacitor & dependencies
│   ├── vite.config.js                # Vite configuration
│   ├── setup.ps1                     # Windows setup script
│   ├── setup.sh                      # Linux/Mac setup script
│   ├── ICON_SETUP_GUIDE.md           # Icon generation guide
│   └── README.md                     # Mobile app documentation
│
├── IoT-Integration/                  # IoT Device Code
│   └── iot_integration_with_api/
│       ├── iot_integration_with_api.ino  # ESP32 Arduino code
│       └── keys.h                    # WiFi & API credentials
│
├── Documentation/                    # Comprehensive Documentation
│   ├── API_DOCUMENTATION.md          # Complete API reference
│   ├── ARCHITECTURE.md               # System architecture details
│   ├── CI_CD.md                      # CI/CD implementation guide
│   ├── DEPLOYMENT_GUIDE.md           # Production deployment guide
│   ├── DEPLOYMENT_CHECKLIST.md       # Pre-deployment checklist
│   ├── ESP32_SETUP_GUIDE.md          # ESP32 device setup
│   ├── IOT_INTEGRATION.md            # IoT integration guide
│   ├── MOBILE_APP_SUMMARY.md         # Mobile app overview
│   ├── QUICKSTART.md                 # 5-minute quick start
│   ├── SUPERUSER_GUIDE.md            # Admin user guide
│   └── USER_GUIDE.md                 # End-user documentation
│
├── RBAC.md                           # Role-based access control guide
├── Ashwini_Project_Report.md         # Complete project report
│
├── setup.ps1                         # Complete project setup (Windows)
├── start-servers.ps1                 # Start all servers (Windows)
├── render.yaml                       # Render.com deployment config
├── LICENSE                           # Project license
└── README.md                         # This file

🚀 Quick Start

Option 1: Automated Setup (Windows - Recommended)

# Clone the repository
git clone https://github.com/yourusername/ashwini.git
cd ashwini

# Run automated setup script
.\setup.ps1

# Start all servers in separate windows
.\start-servers.ps1

Option 2: Quick Start Guide

See QUICKSTART.md for a detailed 5-minute setup guide.

Option 3: Manual Setup

Follow the detailed instructions in the Setup Instructions section below.

📝 Setup Instructions

Prerequisites

Python 3.8 or higher
Node.js 16 or higher
pip (Python package manager)
npm (Node package manager)
Android Studio (optional, for mobile development)

Backend Setup

Navigate to backend directory:
```
cd backend
```

Create a virtual environment (recommended):

python -m venv venv
.\venv\Scripts\Activate      # Windows
# source venv/bin/activate   # Linux/Mac

Install dependencies:
```
pip install -r requirements.txt
```
Configure environment variables (REQUIRED):

Create a .env file in the backend/ directory:
```
# Generate a secure SECRET_KEY (REQUIRED)
python -c "from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())"
```
Add to backend/.env:
```
SECRET_KEY=your-generated-secret-key-here
DEBUG=True
ALLOWED_HOSTS=localhost,127.0.0.1
```
⚠️ IMPORTANT: The application will not start without SECRET_KEY set in environment variables. See .env.example for all available configuration options.

Run database migrations:

python manage.py makemigrations
python manage.py migrate

Create superuser (for Django admin):
```
python manage.py createsuperuser
```
Follow the prompts to set username, email, and password.
Start the Django server:
```
python manage.py runserver 0.0.0.0:8000
```
Backend will be available at: http://localhost:8000 Admin interface at: http://localhost:8000/admin API root at: http://localhost:8000/api/

Frontend Setup - Main Portal (Registration + Health Monitoring)

Open a new terminal and navigate to frontend-main:
```
cd frontend-main
```
Install dependencies:
```
npm install
```
Configure environment (.env file should contain):
```
REACT_APP_API_URL=http://localhost:8000
```
Start the development server:
```
npm start
```
Main Frontend will be available at: http://localhost:4000

Frontend Setup - Unified Portal (Doctor's Dashboard)

Open a new terminal and navigate to frontend-unified:
```
cd frontend-unified
```
Install dependencies:
```
npm install
```
Configure environment (.env file should contain):
```
REACT_APP_API_URL=http://localhost:8000
```
Start the development server:
```
npm start
```
Unified Frontend will be available at: http://localhost:3000

Frontend Setup - Patient Portal (Web)

Open a new terminal and navigate to frontend-patient:
```
cd frontend-patient
```
Install dependencies:
```
npm install
```

Configure API in src/api/axios.js:

const API_URL = 'http://localhost:8000';

Start the development server:
```
npm run dev
```
Patient Portal will be available at: http://localhost:5173 (or similar Vite port)

Mobile App Setup (Android)

See frontend-patient-mobile/README.md for detailed setup instructions.

Quick setup:

cd frontend-patient-mobile
npm install
npx cap sync android
npm run android    # Opens Android Studio

Verify Installation

With all servers running, you should have:

Backend API: http://localhost:8000/api/
Django Admin: http://localhost:8000/admin
Main Frontend: http://localhost:4000
Unified Frontend: http://localhost:3000
Patient Portal: http://localhost:5173

👥 User Roles & RBAC

Project Ashwini implements comprehensive Role-Based Access Control (RBAC) with five distinct user roles:

Role Overview

Role	Portal Access	Permissions
ADMIN	All portals	Full system access, user management, all operations
DOCTOR	Unified Portal	Patient view, prescriptions, notes, complete consultations
NURSE	Main Portal	Health monitoring, vitals entry, patient status updates
RECEPTION	Main Portal	Patient registration, queue management
PATIENT	Patient Portal	Personal health data, prescriptions, visit history

Authentication

JWT-based: Secure token authentication for all API calls
Login Endpoints: Separate login APIs for staff and patients
Role Verification: Automatic role checking on protected routes
Session Management: Token refresh mechanism for extended sessions

Example Users

After running python manage.py createsuperuser, you can create additional users via Django admin or registration APIs.

Test Accounts (create these in Django admin for testing):

Doctor: username: doctor1, password: <your-password>, Role: DOCTOR
Nurse: username: nurse1, password: <your-password>, Role: NURSE
Reception: username: reception1, password: <your-password>, Role: RECEPTION

See RBAC.md for complete RBAC implementation details.

📡 API Endpoints

Authentication

Method	Endpoint	Description
POST	`/api/auth/login/`	Staff login (returns JWT token + role)
POST	`/api/auth/register/`	Staff registration
GET	`/api/auth/role/`	Get current user's role
POST	`/api/patient-portal/auth/login/`	Patient login
POST	`/api/patient-portal/auth/register/`	Patient registration

Patient Management

Method	Endpoint	Description
GET	`/api/patients/`	List all patients (supports `?status=` filter)
POST	`/api/patients/`	Create new patient (auto-generates ID)
GET	`/api/patients/<id>/`	Get patient details with latest measurement
PUT/PATCH	`/api/patients/<id>/`	Update patient (partial updates allowed)
DELETE	`/api/patients/<id>/`	Delete patient
GET	`/api/patients/<id>/history/`	Get patient visit history

Prescription Management

Method	Endpoint	Description
GET	`/api/patients/<id>/prescription/`	Get patient's current prescription
PUT/PATCH	`/api/patients/<id>/prescription/`	Update prescription medicines
GET	`/api/patients/<id>/prescription/history/`	Get prescription history

Prescription Format:

{
  "medicines": [
    {
      "name": "Paracetamol",
      "dose": "twice a day",
      "type": "Tablet",
      "quantity": "Full"
    }
  ]
}

Measurement Management

Method	Endpoint	Description
GET	`/api/patients/<id>/measurements/`	Get all measurements (history)
GET	`/api/patients/<id>/measurements/latest/`	Get latest measurement
POST	`/api/patients/<id>/measurements/`	Create manual measurement

Measurement Format:

{
  "blood_pressure": "120/80",
  "temperature": 98.6,
  "spo2": 98.0,
  "heart_rate": 72.0,
  "height": 170,
  "weight": 70
}

Medical Reports

Method	Endpoint	Description
GET	`/api/reports/`	List all reports
POST	`/api/reports/`	Upload new report with OCR analysis
GET	`/api/reports/<id>/`	Get report details
GET	`/api/reports/patient/<patient_id>/`	Get all reports for a patient

IoT Device Endpoints

Method	Endpoint	Description
GET	`/api/devices/`	List all registered devices
GET	`/api/devices/<device_id>/command/`	Device polls for commands
POST	`/api/devices/<device_id>/measurements/`	Device submits measurements

Patient Portal APIs

Method	Endpoint	Description
GET	`/api/patient-portal/dashboard/`	Patient dashboard data
GET	`/api/patient-portal/measurements/`	Patient's measurement history
GET	`/api/patient-portal/prescriptions/`	Patient's prescriptions
GET	`/api/patient-portal/visits/`	Patient's visit history
PUT	`/api/patient-portal/profile/`	Update patient profile

See API_DOCUMENTATION.md for complete API reference with request/response examples.

🔌 IoT Integration

Project Ashwini is designed with IoT integration in mind. The system includes:

IoT Components

Device Management: Register and track IoT devices
Measurement Sessions: Workflow for device-initiated measurements
Command Polling: Devices poll for patient measurement instructions
Data Submission: Devices POST vitals data to the backend

ESP32 Integration

Sample ESP32 code is provided in IoT-Integration/iot_integration_with_api/

Setup Steps:

Install Arduino IDE with ESP32 support
Configure WiFi credentials in keys.h
Set API URL in keys.h
Upload code to ESP32
Register device in Django admin

Integration Points

Backend:

backend/devices/views.py - Device API endpoints
backend/devices/models.py - Device and MeasurementSession models

Frontend:

frontend-main/src/components/HealthMonitoringStation.js - IoT device UI placeholders

See IOT_INTEGRATION.md and ESP32_SETUP_GUIDE.md for detailed integration instructions.

🚀 Deployment

Production Deployment

The system is designed for easy cloud deployment:

Backend (Render.com)

# Connect GitHub repository to Render
# Use render.yaml for automatic configuration
# Set environment variables in Render dashboard

Frontend (Vercel)

# Frontend-main
cd frontend-main
vercel --prod

# Frontend-unified
cd frontend-unified
vercel --prod

# Frontend-patient
cd frontend-patient
vercel --prod

Mobile App (Google Play Store)

GitHub Actions workflow automatically builds APK on push to main branch.

# Manual build
cd frontend-patient-mobile
npm run build
npx cap sync android
# Open in Android Studio and build release APK

See DEPLOYMENT_GUIDE.md and DEPLOYMENT_CHECKLIST.md for complete deployment instructions.

� CI/CD & DevOps

Current CI/CD Implementation

Project Ashwini has implemented automated CI/CD pipelines for continuous integration and deployment:

1. GitHub Actions - Android Build Pipeline

Location: .github/workflows/android-build.yml
Purpose: Automated Android APK builds for patient mobile app
Triggers: Push to main/develop, pull requests, manual dispatch
Features:
- Automated dependency installation
- React app build and Capacitor sync
- Android debug APK generation
- Artifact upload (30-day retention)
- Automatic PR comments with download links

Accessing APK:

Go to GitHub Actions tab
Select latest "Build Android APK" workflow
Download from Artifacts section

2. Render.com - Backend Auto-Deploy

Configuration: render.yaml (Infrastructure as Code)
Deployment: Automatic on push to connected branch
Features:
- Python 3.11 runtime
- PostgreSQL database
- Automatic migrations via build.sh
- Health check monitoring
- Zero-downtime deployments

3. Vercel - Frontend Auto-Deploy

Components: All 3 React frontends (Reception, Doctor, Patient portals)
Deployment: Automatic on git push
Features:
- Preview deployments for pull requests
- CDN distribution and edge caching
- Automatic environment variable management
- Instant cache invalidation

Live Deployments:

Reception Portal: https://ashwini-frontend-main.vercel.app
Doctor's Portal: https://ashwini-unified-view.vercel.app
Patient Portal: https://ashwini-patient.vercel.app

CI/CD Maturity: ~30%

✅ Implemented:

Continuous Deployment for all components
Automated build pipelines
Preview environments for testing
Infrastructure as Code (IaC)

🔄 Future Enhancements:

Automated testing (unit, integration, E2E)
Code quality checks (linting, formatting)
Security scanning (dependencies, vulnerabilities)
Staging environment setup
Release automation and versioning

See CI_CD.md for detailed CI/CD documentation, workflow configurations, and future enhancement plans.

�📚 Documentation

Comprehensive documentation is available:

Document	Description
API_DOCUMENTATION.md	Complete API reference
ARCHITECTURE.md	System architecture and design
DEPLOYMENT_GUIDE.md	Production deployment guide
DEPLOYMENT_CHECKLIST.md	Pre-deployment checklist
SECURITY_IMPROVEMENTS.md	Security enhancements & rate limiting
CI_CD.md	CI/CD implementation guide
IOT_INTEGRATION.md	IoT device integration
ESP32_SETUP_GUIDE.md	ESP32 hardware setup
RBAC.md	Role-based access control
QUICKSTART.md	5-minute quick start
USER_GUIDE.md	End-user documentation
SUPERUSER_GUIDE.md	Admin user guide
MOBILE_APP_SUMMARY.md	Mobile app overview
Ashwini_Project_Report.md	Complete project report

📖 Usage Guide

For Registration Staff

Access Main Frontend at http://localhost:4000
Login with RECEPTION or ADMIN role
Click "Registration Dashboard"
Fill patient details form and click "Register Patient"
View patient queue in real-time
Patient status starts as "waiting"

For Health Monitoring Staff

Access Main Frontend at http://localhost:4000
Login with NURSE or ADMIN role
Click "Health Monitoring Station"
Select a patient from dropdown
Click "Start Health Check" if patient is waiting
Enter vitals manually in the form
Click "Save Measurement"
Patient status updates to "examined"

For Doctors

Access Unified Frontend at http://localhost:3000
Login with DOCTOR or ADMIN role
Use "Previous Patient" / "Next Patient" buttons to navigate
Review patient information and latest vitals
Add medicines to prescription
Add clinical notes in "Doctor's Notes" section
Set next visit date if needed
Click "Mark as Completed" when finished

For Patients

Web Portal:

Access Patient Portal at http://localhost:5173
Register or login with patient credentials
View dashboard with health overview
Navigate to Measurements, Prescriptions, or Visits
Update profile information

Mobile App:

Install Android APK on device
Login with patient credentials
Access health data on-the-go
View charts and historical data

See USER_GUIDE.md for detailed usage instructions.

🤝 Contributing

Contributions are welcome! Please follow these guidelines:

Fork the repository
Create a feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'Add some AmazingFeature')
Push to the branch (git push origin feature/AmazingFeature)
Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

Django and Django REST Framework communities
React and Vite communities
Capacitor for mobile app capabilities
Azure AI for OCR services
All contributors and testers

📞 Support

For questions, issues, or support:

Open an issue on GitHub
Check documentation in the /docs folder
Review existing issues and discussions

Project Ashwini - Empowering Healthcare with Technology 🏥💙

Name		Name	Last commit message	Last commit date
.github		.github
Documentation		Documentation
IoT-Integration/iot_integration_with_api		IoT-Integration/iot_integration_with_api
backend		backend
frontend-main		frontend-main
frontend-patient-mobile		frontend-patient-mobile
frontend-patient		frontend-patient
frontend-unified		frontend-unified
.gitignore		.gitignore
LICENSE		LICENSE
RBAC.md		RBAC.md
README.md		README.md
SECURITY_UPDATE_SETUP.md		SECURITY_UPDATE_SETUP.md
render.yaml		render.yaml
setup.ps1		setup.ps1
start-servers.ps1		start-servers.ps1

Latest commit

History

Folders and files

Repository files navigation

Project Ashwini

Live Application Links:

Patient Portal - https://ashwini-patient.vercel.app Doctor's Portal - https://ashwini-unified-view.vercel.app Reception Portal - https://ashwini-frontend-main.vercel.app Patient Apk File- https://drive.google.com/file/d/1UoXjzWolk13Ztbwss2lLqTOc-DgAyMJZ/view?usp=sharing

📋 Table of Contents

🎯 Overview

Staff Portals

Patient Portals

🏗️ System Architecture

✨ Features

Current Features

Patient Management

Health Monitoring

Clinical Management

Medical Report Analysis

Authentication & Security

Patient Portal Features

Mobile Application

IoT-Ready Architecture

🛠️ Tech Stack

Backend

Frontend Stack

Main Frontend (Staff Portal)

Unified Frontend (Doctor's Portal)

Patient Portal (Web)

Patient Mobile App

IoT Integration

Deployment & DevOps

Development Tools

📁 Project Structure

🚀 Quick Start

Option 1: Automated Setup (Windows - Recommended)

Option 2: Quick Start Guide

Option 3: Manual Setup

📝 Setup Instructions

Prerequisites

Backend Setup

Frontend Setup - Main Portal (Registration + Health Monitoring)

Frontend Setup - Unified Portal (Doctor's Dashboard)

Frontend Setup - Patient Portal (Web)

Mobile App Setup (Android)

Verify Installation

👥 User Roles & RBAC

Role Overview

Authentication

Example Users

📡 API Endpoints

Authentication

Patient Management

Prescription Management

Measurement Management

Medical Reports

IoT Device Endpoints

Patient Portal APIs

🔌 IoT Integration

IoT Components

ESP32 Integration

Integration Points

🚀 Deployment

Production Deployment

Backend (Render.com)

Frontend (Vercel)

Mobile App (Google Play Store)

� CI/CD & DevOps

Current CI/CD Implementation

1. GitHub Actions - Android Build Pipeline

2. Render.com - Backend Auto-Deploy

3. Vercel - Frontend Auto-Deploy

CI/CD Maturity: ~30%

�📚 Documentation

📖 Usage Guide

For Registration Staff

For Health Monitoring Staff

For Doctors

For Patients

🤝 Contributing

📄 License