From 99569ad457c1e40a26ec84cbd5b6c070481875f1 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Sun, 21 Sep 2025 05:18:15 +0000 Subject: [PATCH] Refactor: Update project structure and configurations This commit introduces significant changes to the project structure, including: - **New Dockerfiles**: Added Dockerfiles for backend and frontend services. - **Updated docker-compose.yml**: Refactored docker-compose for better service management and health checks. - **New README and DEPLOYMENT guides**: Added comprehensive documentation for project setup and deployment. - **Backend restructuring**: Introduced migrations, models, routes, and utility modules for better organization. - **Frontend setup**: Configured React app with routing, state management, and API services. - **AI Service integration**: Set up a basic AI service with Flask and YOLO for image analysis. - **Environment variable management**: Updated .env.example for comprehensive configuration. - **Monorepo setup**: Modified package.json to support workspaces for backend and frontend. Co-authored-by: rajrasal0806 --- .env.example | 62 +- DEPLOYMENT.md | 493 ++++++++++++++++ README.md | 187 +++++++ ai-services/Dockerfile | 57 ++ ai-services/app.py | 454 +++++++++++++++ ai-services/requirements.txt | 15 + backend/Dockerfile | 42 ++ backend/migrations/001_create_users_table.js | 29 + backend/migrations/002_create_issues_table.js | 59 ++ .../003_create_gamification_tables.js | 57 ++ backend/migrations/004_create_admin_tables.js | 67 +++ backend/package.json | 55 ++ backend/src/app.js | 147 +++++ backend/src/config/database.js | 42 ++ backend/src/config/redis.js | 76 +++ backend/src/middleware/authMiddleware.js | 132 +++++ backend/src/middleware/errorMiddleware.js | 73 +++ backend/src/models/Issue.js | 313 +++++++++++ backend/src/models/User.js | 189 +++++++ backend/src/routes/authRoutes.js | 379 +++++++++++++ backend/src/routes/gamificationRoutes.js | 371 ++++++++++++ backend/src/routes/issueRoutes.js | 390 +++++++++++++ backend/src/utils/aiDetection.js | 250 +++++++++ backend/src/utils/fileUpload.js | 188 +++++++ backend/src/utils/logger.js | 29 + docker-compose.yml | 144 ++++- frontend/Dockerfile | 37 ++ frontend/package.json | 62 ++ frontend/src/App.js | 110 ++++ frontend/src/contexts/AuthContext.js | 296 ++++++++++ frontend/src/pages/Home.js | 451 +++++++++++++++ frontend/src/pages/ReportIssue.js | 528 ++++++++++++++++++ frontend/src/services/api.js | 242 ++++++++ frontend/tailwind.config.js | 83 +++ mobile/lib/core/router/app_router.dart | 130 +++++ .../home/presentation/pages/home_page.dart | 132 +++++ .../presentation/widgets/hero_section.dart | 105 ++++ mobile/lib/main.dart | 69 +++ mobile/pubspec.yaml | 103 ++++ package.json | 53 +- scripts/setup.sh | 242 ++++++++ scripts/start-dev.sh | 108 ++++ 42 files changed, 6990 insertions(+), 61 deletions(-) create mode 100644 DEPLOYMENT.md create mode 100644 README.md create mode 100644 ai-services/Dockerfile create mode 100644 ai-services/app.py create mode 100644 ai-services/requirements.txt create mode 100644 backend/Dockerfile create mode 100644 backend/migrations/001_create_users_table.js create mode 100644 backend/migrations/002_create_issues_table.js create mode 100644 backend/migrations/003_create_gamification_tables.js create mode 100644 backend/migrations/004_create_admin_tables.js create mode 100644 backend/package.json create mode 100644 backend/src/app.js create mode 100644 backend/src/config/database.js create mode 100644 backend/src/config/redis.js create mode 100644 backend/src/middleware/authMiddleware.js create mode 100644 backend/src/middleware/errorMiddleware.js create mode 100644 backend/src/models/Issue.js create mode 100644 backend/src/models/User.js create mode 100644 backend/src/routes/authRoutes.js create mode 100644 backend/src/routes/gamificationRoutes.js create mode 100644 backend/src/routes/issueRoutes.js create mode 100644 backend/src/utils/aiDetection.js create mode 100644 backend/src/utils/fileUpload.js create mode 100644 backend/src/utils/logger.js create mode 100644 frontend/Dockerfile create mode 100644 frontend/package.json create mode 100644 frontend/src/App.js create mode 100644 frontend/src/contexts/AuthContext.js create mode 100644 frontend/src/pages/Home.js create mode 100644 frontend/src/pages/ReportIssue.js create mode 100644 frontend/src/services/api.js create mode 100644 frontend/tailwind.config.js create mode 100644 mobile/lib/core/router/app_router.dart create mode 100644 mobile/lib/features/home/presentation/pages/home_page.dart create mode 100644 mobile/lib/features/home/presentation/widgets/hero_section.dart create mode 100644 mobile/lib/main.dart create mode 100644 mobile/pubspec.yaml create mode 100755 scripts/setup.sh create mode 100755 scripts/start-dev.sh diff --git a/.env.example b/.env.example index 9dace28..1a9c5e0 100644 --- a/.env.example +++ b/.env.example @@ -1,14 +1,54 @@ -# .env.example - copy to .env and fill values -POSTGRES_USER=vighn -POSTGRES_PASSWORD=vighnpass -POSTGRES_DB=vighnview -POSTGRES_PORT=5432 +# Database Configuration +DATABASE_URL=postgresql://username:password@localhost:5432/vighnview +REDIS_URL=redis://localhost:6379 -# Backend server config -BACKEND_PORT=5000 +# JWT Configuration +JWT_SECRET=your-super-secret-jwt-key-here +JWT_REFRESH_SECRET=your-super-secret-refresh-key-here +JWT_EXPIRES_IN=24h +JWT_REFRESH_EXPIRES_IN=7d -# Google Cloud Vision API key (DON'T commit) -AI_API_KEY=YOUR_GOOGLE_VISION_API_KEY +# File Storage +AWS_ACCESS_KEY_ID=your-aws-access-key +AWS_SECRET_ACCESS_KEY=your-aws-secret-key +AWS_REGION=us-east-1 +AWS_S3_BUCKET=vighnview-uploads -# Used by frontend to call backend in dev or production -NEXT_PUBLIC_BACKEND_URL=http://localhost:5000 +# Google Cloud (Alternative to AWS) +GOOGLE_CLOUD_PROJECT_ID=your-project-id +GOOGLE_CLOUD_STORAGE_BUCKET=vighnview-uploads + +# Maps API +GOOGLE_MAPS_API_KEY=your-google-maps-api-key + +# AI/ML Services +AI_SERVICE_URL=http://localhost:5000 +TENSORFLOW_MODEL_PATH=./models/issue-detection-model + +# Email Configuration +SMTP_HOST=smtp.gmail.com +SMTP_PORT=587 +SMTP_USER=your-email@gmail.com +SMTP_PASS=your-app-password + +# Push Notifications +FCM_SERVER_KEY=your-fcm-server-key +FCM_PROJECT_ID=your-fcm-project-id + +# Development +NODE_ENV=development +PORT=3000 +FRONTEND_URL=http://localhost:3001 +MOBILE_APP_URL=http://localhost:3000 + +# Rate Limiting +RATE_LIMIT_WINDOW_MS=900000 +RATE_LIMIT_MAX_REQUESTS=100 + +# Security +BCRYPT_ROUNDS=12 +CORS_ORIGIN=http://localhost:3001,http://localhost:3000 + +# Monitoring +SENTRY_DSN=your-sentry-dsn +LOG_LEVEL=info \ No newline at end of file diff --git a/DEPLOYMENT.md b/DEPLOYMENT.md new file mode 100644 index 0000000..bea98d2 --- /dev/null +++ b/DEPLOYMENT.md @@ -0,0 +1,493 @@ +# VighnView Deployment Guide + +This guide covers deploying VighnView to production environments. + +## 🏗️ Architecture Overview + +``` +┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ +│ Load Balancer │ │ CDN/Static │ │ Monitoring │ +│ (Nginx/ALB) │ │ (CloudFront) │ │ (Grafana) │ +└─────────┬───────┘ └─────────┬───────┘ └─────────┬───────┘ + │ │ │ + └──────────────────────┼──────────────────────┘ + │ + ┌─────────────┴─────────────┐ + │ Application Layer │ + │ (Docker Containers) │ + └─────────────┬─────────────┘ + │ + ┌─────────────┴─────────────┐ + │ Data & Storage Layer │ + │ (PostgreSQL + Redis) │ + └───────────────────────────┘ +``` + +## 🚀 Deployment Options + +### Option 1: Docker Compose (Recommended for Small-Medium Scale) + +#### Prerequisites +- Docker and Docker Compose installed +- Domain name configured +- SSL certificate (Let's Encrypt recommended) + +#### Steps + +1. **Clone and Setup** +```bash +git clone https://github.com/your-org/vighnview.git +cd vighnview +cp .env.example .env +# Edit .env with production values +``` + +2. **Configure Environment Variables** +```bash +# Database +DATABASE_URL=postgresql://username:password@postgres:5432/vighnview +REDIS_URL=redis://redis:6379 + +# Security +JWT_SECRET=your-super-secure-jwt-secret +JWT_REFRESH_SECRET=your-super-secure-refresh-secret + +# File Storage +AWS_ACCESS_KEY_ID=your-aws-access-key +AWS_SECRET_ACCESS_KEY=your-aws-secret-key +AWS_S3_BUCKET=vighnview-prod-uploads + +# Production Settings +NODE_ENV=production +PORT=3000 +FRONTEND_URL=https://your-domain.com +``` + +3. **Deploy with Docker Compose** +```bash +docker-compose -f docker-compose.prod.yml up -d +``` + +### Option 2: Kubernetes (Recommended for Large Scale) + +#### Prerequisites +- Kubernetes cluster (EKS, GKE, AKS) +- kubectl configured +- Helm installed + +#### Steps + +1. **Create Namespace** +```bash +kubectl create namespace vighnview +``` + +2. **Deploy with Helm** +```bash +helm install vighnview ./helm-chart \ + --namespace vighnview \ + --set image.tag=latest \ + --set ingress.host=your-domain.com +``` + +### Option 3: Cloud Platform (AWS/GCP/Azure) + +#### AWS Deployment + +1. **Using AWS App Runner** +```bash +# Create apprunner.yaml +version: 1.0 +runtime: nodejs18 +build: + commands: + build: + - npm install + - npm run build +run: + runtime-version: 18 + command: npm start + network: + port: 3000 + env: + - name: NODE_ENV + value: production +``` + +2. **Using AWS ECS with Fargate** +```bash +# Create task definition +aws ecs register-task-definition \ + --cli-input-json file://task-definition.json +``` + +#### Google Cloud Platform + +1. **Using Cloud Run** +```bash +gcloud run deploy vighnview-backend \ + --source ./backend \ + --platform managed \ + --region us-central1 \ + --allow-unauthenticated +``` + +2. **Using App Engine** +```bash +gcloud app deploy ./app.yaml +``` + +## 🗄️ Database Setup + +### PostgreSQL Production Setup + +1. **Create Production Database** +```sql +CREATE DATABASE vighnview_prod; +CREATE USER vighnview_user WITH PASSWORD 'secure_password'; +GRANT ALL PRIVILEGES ON DATABASE vighnview_prod TO vighnview_user; +``` + +2. **Run Migrations** +```bash +cd backend +npm run migrate +``` + +3. **Seed Initial Data** +```bash +npm run seed +``` + +### Redis Production Setup + +1. **Configure Redis** +```bash +# redis.conf +bind 0.0.0.0 +port 6379 +requirepass your_redis_password +maxmemory 2gb +maxmemory-policy allkeys-lru +``` + +## 🔒 Security Configuration + +### SSL/TLS Setup + +1. **Using Let's Encrypt with Certbot** +```bash +certbot --nginx -d your-domain.com +``` + +2. **Using Cloudflare** +- Add your domain to Cloudflare +- Enable SSL/TLS encryption +- Configure security headers + +### Security Headers + +```nginx +# nginx.conf +add_header X-Frame-Options "SAMEORIGIN" always; +add_header X-Content-Type-Options "nosniff" always; +add_header X-XSS-Protection "1; mode=block" always; +add_header Referrer-Policy "strict-origin-when-cross-origin" always; +add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';" always; +``` + +### Environment Security + +```bash +# Use secrets management +export JWT_SECRET=$(aws secretsmanager get-secret-value --secret-id vighnview/jwt-secret --query SecretString --output text) +export DATABASE_URL=$(aws secretsmanager get-secret-value --secret-id vighnview/database-url --query SecretString --output text) +``` + +## 📊 Monitoring & Logging + +### Application Monitoring + +1. **Using Prometheus + Grafana** +```yaml +# prometheus.yml +global: + scrape_interval: 15s + +scrape_configs: + - job_name: 'vighnview-backend' + static_configs: + - targets: ['backend:3000'] +``` + +2. **Using DataDog** +```bash +# Install DataDog agent +DD_API_KEY=your-api-key DD_SITE="datadoghq.com" bash -c "$(curl -L https://s3.amazonaws.com/dd-agent/scripts/install_script.sh)" +``` + +### Log Management + +1. **Using ELK Stack** +```yaml +# docker-compose.logging.yml +version: '3.8' +services: + elasticsearch: + image: elasticsearch:7.14.0 + environment: + - discovery.type=single-node + ports: + - "9200:9200" + + logstash: + image: logstash:7.14.0 + volumes: + - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf + + kibana: + image: kibana:7.14.0 + ports: + - "5601:5601" +``` + +2. **Using CloudWatch (AWS)** +```bash +# Install CloudWatch agent +wget https://s3.amazonaws.com/amazoncloudwatch-agent/amazon_linux/amd64/latest/amazon-cloudwatch-agent.rpm +sudo rpm -U ./amazon-cloudwatch-agent.rpm +``` + +## 🔄 CI/CD Pipeline + +### GitHub Actions + +```yaml +# .github/workflows/deploy.yml +name: Deploy to Production + +on: + push: + branches: [main] + +jobs: + deploy: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + + - name: Setup Node.js + uses: actions/setup-node@v3 + with: + node-version: '18' + + - name: Install dependencies + run: npm install + + - name: Run tests + run: npm test + + - name: Build application + run: npm run build + + - name: Deploy to AWS + run: | + aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin $ECR_REGISTRY + docker build -t $ECR_REGISTRY/vighnview:$GITHUB_SHA . + docker push $ECR_REGISTRY/vighnview:$GITHUB_SHA +``` + +### GitLab CI/CD + +```yaml +# .gitlab-ci.yml +stages: + - test + - build + - deploy + +test: + stage: test + script: + - npm install + - npm test + +build: + stage: build + script: + - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA . + - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA + +deploy: + stage: deploy + script: + - kubectl set image deployment/vighnview vighnview=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHA +``` + +## 📈 Performance Optimization + +### Backend Optimization + +1. **Enable Compression** +```javascript +// app.js +const compression = require('compression'); +app.use(compression()); +``` + +2. **Database Connection Pooling** +```javascript +// database.js +const pool = new Pool({ + connectionString: process.env.DATABASE_URL, + max: 20, + idleTimeoutMillis: 30000, + connectionTimeoutMillis: 2000, +}); +``` + +3. **Redis Caching** +```javascript +// cache.js +const redis = require('redis'); +const client = redis.createClient({ + url: process.env.REDIS_URL, + retry_strategy: (options) => { + if (options.error && options.error.code === 'ECONNREFUSED') { + return new Error('The server refused the connection'); + } + if (options.total_retry_time > 1000 * 60 * 60) { + return new Error('Retry time exhausted'); + } + if (options.attempt > 10) { + return undefined; + } + return Math.min(options.attempt * 100, 3000); + } +}); +``` + +### Frontend Optimization + +1. **Code Splitting** +```javascript +// App.js +const LazyComponent = React.lazy(() => import('./LazyComponent')); + +function App() { + return ( + Loading...}> + + + ); +} +``` + +2. **Service Worker for Caching** +```javascript +// sw.js +const CACHE_NAME = 'vighnview-v1'; +const urlsToCache = [ + '/', + '/static/js/bundle.js', + '/static/css/main.css' +]; + +self.addEventListener('install', (event) => { + event.waitUntil( + caches.open(CACHE_NAME) + .then((cache) => cache.addAll(urlsToCache)) + ); +}); +``` + +## 🔧 Maintenance + +### Database Maintenance + +1. **Regular Backups** +```bash +#!/bin/bash +# backup.sh +pg_dump $DATABASE_URL > backup_$(date +%Y%m%d_%H%M%S).sql +aws s3 cp backup_*.sql s3://vighnview-backups/ +``` + +2. **Database Optimization** +```sql +-- Analyze tables for better query planning +ANALYZE; + +-- Reindex for better performance +REINDEX DATABASE vighnview_prod; +``` + +### Application Updates + +1. **Zero-Downtime Deployment** +```bash +# Rolling update with Docker Swarm +docker service update --image vighnview:latest vighnview_backend +``` + +2. **Health Checks** +```bash +# Health check endpoint +curl -f http://localhost:3000/health || exit 1 +``` + +## 📞 Support & Troubleshooting + +### Common Issues + +1. **Database Connection Issues** +```bash +# Check database connectivity +psql $DATABASE_URL -c "SELECT 1;" +``` + +2. **Memory Issues** +```bash +# Monitor memory usage +docker stats +``` + +3. **Performance Issues** +```bash +# Check slow queries +SELECT query, mean_time, calls +FROM pg_stat_statements +ORDER BY mean_time DESC +LIMIT 10; +``` + +### Log Analysis + +```bash +# View application logs +docker logs vighnview_backend --tail 100 -f + +# Search for errors +grep -i error /var/log/vighnview/app.log +``` + +## 📋 Production Checklist + +- [ ] Environment variables configured +- [ ] Database migrations run +- [ ] SSL certificates installed +- [ ] Security headers configured +- [ ] Monitoring setup +- [ ] Backup strategy implemented +- [ ] Health checks configured +- [ ] Load balancer configured +- [ ] CDN setup +- [ ] Error tracking configured +- [ ] Performance monitoring active +- [ ] Log aggregation working +- [ ] CI/CD pipeline tested +- [ ] Disaster recovery plan ready + +--- + +For more detailed information, refer to the individual component documentation in each directory. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..8cfac51 --- /dev/null +++ b/README.md @@ -0,0 +1,187 @@ +# VighnView - Smart Civic Monitoring Platform + +A comprehensive civic reporting and smart governance platform that evolves through 6 phases to create a complete monitoring ecosystem. + +## 🌟 Vision +Transform civic issue reporting from reactive to proactive through AI-powered detection, gamification, and multi-source data integration. + +## 📋 Phase Overview + +### Phase 1: Civic Reporting App & Website ✅ +- Cross-platform mobile app (Flutter) + website (React.js) +- AI-powered issue detection (TensorFlow Lite, YOLOv8) +- Gamification with points system and leaderboards +- Progress tracking and anonymous reporting + +### Phase 2: Camera Network Integration 📹 +- Traffic signal CCTV integration +- Police van camera feeds +- Dashcam integration for autos/cabs +- Local CCTV network integration + +### Phase 3: Drone Surveillance Network 🚁 +- Self-manufactured low-cost drones +- Market drone integration (DJI) +- On-demand drone scanning + +### Phase 4: Satellite Imagery 🛰 +- ISRO/third-party satellite data integration +- ML models for change detection +- GIS mapping and analysis + +### Phase 5: Centralized Data Integration 🔗 +- Scalable cloud architecture (AWS/GCP/Azure) +- Real-time dashboards (Power BI/Tableau/Grafana) +- Public transparency portal + +### Phase 6: Full Automation & Smart Governance 🤖 +- AI predictions and IoT sensors +- Automated workflow management +- Self-learning system improvements + +## 🏗️ Architecture + +``` +┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ +│ Mobile App │ │ Web Portal │ │ Admin Panel │ +│ (Flutter) │ │ (React.js) │ │ (Dashboard) │ +└─────────┬───────┘ └─────────┬───────┘ └─────────┬───────┘ + │ │ │ + └──────────────────────┼──────────────────────┘ + │ + ┌─────────────┴─────────────┐ + │ Backend API │ + │ (Node.js/Express) │ + └─────────────┬─────────────┘ + │ + ┌─────────────┴─────────────┐ + │ AI/ML Services │ + │ (TensorFlow, YOLO) │ + └─────────────┬─────────────┘ + │ + ┌─────────────┴─────────────┐ + │ Database Layer │ + │ (PostgreSQL + Redis) │ + └───────────────────────────┘ +``` + +## 🚀 Getting Started + +### Prerequisites +- Node.js 18+ +- Flutter 3.0+ +- PostgreSQL 14+ +- Redis 6+ +- Python 3.9+ (for AI/ML services) + +### Installation + +1. Clone the repository +```bash +git clone https://github.com/your-org/vighnview.git +cd vighnview +``` + +2. Install dependencies +```bash +# Backend +cd backend && npm install + +# Frontend +cd ../frontend && npm install + +# Mobile +cd ../mobile && flutter pub get + +# AI Services +cd ../ai-services && pip install -r requirements.txt +``` + +3. Set up environment variables +```bash +cp .env.example .env +# Edit .env with your configuration +``` + +4. Start the development servers +```bash +# Backend +cd backend && npm run dev + +# Frontend +cd frontend && npm run dev + +# Mobile (in separate terminal) +cd mobile && flutter run +``` + +## 📱 Features + +### Current (Phase 1) +- 📸 Photo/video issue reporting with GPS tagging +- 🤖 AI-powered issue type detection +- 🎮 Gamification with points and leaderboards +- 📊 Progress tracking for reported issues +- 🔒 Anonymous reporting option +- 📱 Cross-platform mobile app +- 🌐 Web portal for citizens and officials + +### Upcoming +- 📹 Automated camera network monitoring +- 🚁 Drone surveillance integration +- 🛰 Satellite imagery analysis +- 🤖 Predictive analytics and automation +- 📊 Advanced analytics and reporting + +## 🛠️ Tech Stack + +### Backend +- **Runtime**: Node.js with Express.js +- **Database**: PostgreSQL with Redis for caching +- **Authentication**: JWT with refresh tokens +- **File Storage**: AWS S3 / Google Cloud Storage +- **Real-time**: Socket.io for live updates + +### Frontend +- **Web**: React.js with TypeScript, Tailwind CSS +- **Mobile**: Flutter with Dart +- **State Management**: Redux Toolkit / Provider +- **Maps**: Google Maps API / OpenStreetMap + +### AI/ML +- **Computer Vision**: TensorFlow Lite, YOLOv8 +- **Image Processing**: OpenCV +- **Model Training**: TensorFlow, PyTorch +- **Edge Computing**: Raspberry Pi, NVIDIA Jetson + +### Infrastructure +- **Cloud**: AWS / Google Cloud Platform +- **Containerization**: Docker, Kubernetes +- **CI/CD**: GitHub Actions +- **Monitoring**: Grafana, Prometheus + +## 📊 API Documentation + +The API documentation is available at `/api/docs` when running the development server. + +## 🤝 Contributing + +1. Fork the repository +2. Create a feature branch (`git checkout -b feature/amazing-feature`) +3. Commit your changes (`git commit -m 'Add amazing feature'`) +4. Push to the branch (`git push origin feature/amazing-feature`) +5. Open a Pull Request + +## 📄 License + +This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. + +## 🙏 Acknowledgments + +- ISRO for satellite imagery partnerships +- Open source computer vision community +- Civic technology initiatives worldwide + +--- + +**VighnView** - Making cities smarter, one report at a time! 🏙️✨ \ No newline at end of file diff --git a/ai-services/Dockerfile b/ai-services/Dockerfile new file mode 100644 index 0000000..5efd9bc --- /dev/null +++ b/ai-services/Dockerfile @@ -0,0 +1,57 @@ +# Use Python 3.9 slim image +FROM python:3.9-slim + +# Set working directory +WORKDIR /app + +# Install system dependencies +RUN apt-get update && apt-get install -y \ + libglib2.0-0 \ + libsm6 \ + libxext6 \ + libxrender-dev \ + libgomp1 \ + libglib2.0-0 \ + libgtk-3-0 \ + libavcodec-dev \ + libavformat-dev \ + libswscale-dev \ + libv4l-dev \ + libxvidcore-dev \ + libx264-dev \ + libjpeg-dev \ + libpng-dev \ + libtiff-dev \ + libatlas-base-dev \ + python3-dev \ + gfortran \ + wget \ + curl \ + && rm -rf /var/lib/apt/lists/* + +# Copy requirements first for better caching +COPY requirements.txt . + +# Install Python dependencies +RUN pip install --no-cache-dir -r requirements.txt + +# Copy source code +COPY . . + +# Create models directory +RUN mkdir -p models + +# Create non-root user +RUN useradd --create-home --shell /bin/bash app +RUN chown -R app:app /app +USER app + +# Expose port +EXPOSE 5000 + +# Health check +HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ + CMD curl -f http://localhost:5000/health || exit 1 + +# Start the application +CMD ["python", "app.py"] \ No newline at end of file diff --git a/ai-services/app.py b/ai-services/app.py new file mode 100644 index 0000000..1b27f7a --- /dev/null +++ b/ai-services/app.py @@ -0,0 +1,454 @@ +from flask import Flask, request, jsonify +from flask_cors import CORS +import base64 +import io +import cv2 +import numpy as np +from PIL import Image +import tensorflow as tf +from ultralytics import YOLO +import logging +import os +from datetime import datetime +import json + +# Configure logging +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +app = Flask(__name__) +CORS(app) + +# Load AI models +models = {} +model_status = { + 'issue-detection': 'loading', + 'pothole-detection': 'loading', + 'garbage-detection': 'loading' +} + +# Issue categories and their corresponding models +ISSUE_CATEGORIES = { + 'pothole': 'pothole-detection', + 'garbage': 'garbage-detection', + 'sewage': 'issue-detection', + 'street_light': 'issue-detection', + 'traffic_signal': 'issue-detection', + 'road_damage': 'issue-detection', + 'water_leak': 'issue-detection', + 'illegal_dumping': 'garbage-detection', + 'other': 'issue-detection' +} + +def load_models(): + """Load AI models for issue detection""" + try: + # Load YOLOv8 model for general issue detection + models['issue-detection'] = YOLO('yolov8n.pt') # Using nano model for faster inference + model_status['issue-detection'] = 'loaded' + logger.info("Issue detection model loaded successfully") + + # Load specialized models if available + model_paths = { + 'pothole-detection': './models/pothole_detection.pt', + 'garbage-detection': './models/garbage_detection.pt' + } + + for model_name, model_path in model_paths.items(): + if os.path.exists(model_path): + try: + models[model_name] = YOLO(model_path) + model_status[model_name] = 'loaded' + logger.info(f"{model_name} model loaded successfully") + except Exception as e: + logger.warning(f"Failed to load {model_name}: {e}") + model_status[model_name] = 'unavailable' + else: + logger.info(f"{model_name} model not found, using general model") + model_status[model_name] = 'unavailable' + + except Exception as e: + logger.error(f"Error loading models: {e}") + model_status['issue-detection'] = 'error' + +def preprocess_image(image_data): + """Preprocess image for AI analysis""" + try: + # Decode base64 image + image_bytes = base64.b64decode(image_data) + image = Image.open(io.BytesIO(image_bytes)) + + # Convert to RGB if necessary + if image.mode != 'RGB': + image = image.convert('RGB') + + # Convert to numpy array + image_array = np.array(image) + + return image_array + except Exception as e: + logger.error(f"Error preprocessing image: {e}") + raise + +def detect_issues_yolo(image_array, model_name='issue-detection'): + """Detect issues using YOLO model""" + try: + if model_name not in models or model_status[model_name] != 'loaded': + model_name = 'issue-detection' # Fallback to general model + + model = models[model_name] + results = model(image_array) + + detected_issues = [] + + for result in results: + boxes = result.boxes + if boxes is not None: + for box in boxes: + # Get bounding box coordinates + x1, y1, x2, y2 = box.xyxy[0].cpu().numpy() + confidence = box.conf[0].cpu().numpy() + class_id = int(box.cls[0].cpu().numpy()) + + # Map class ID to issue type + issue_type = map_class_to_issue_type(class_id, model_name) + + if confidence > 0.5: # Confidence threshold + detected_issues.append({ + 'type': issue_type, + 'confidence': float(confidence), + 'bounding_box': { + 'x1': float(x1), + 'y1': float(y1), + 'x2': float(x2), + 'y2': float(y2) + } + }) + + return detected_issues + except Exception as e: + logger.error(f"Error in YOLO detection: {e}") + return [] + +def map_class_to_issue_type(class_id, model_name): + """Map YOLO class ID to issue type""" + # This is a simplified mapping - in a real implementation, + # you would train custom models with specific civic issue classes + + if model_name == 'pothole-detection': + return 'pothole' + elif model_name == 'garbage-detection': + return 'garbage' + else: + # General model mapping + general_mapping = { + 0: 'other', # person + 1: 'other', # bicycle + 2: 'other', # car + 3: 'other', # motorcycle + 4: 'other', # airplane + 5: 'other', # bus + 6: 'other', # train + 7: 'other', # truck + 8: 'other', # boat + 9: 'other', # traffic light + 10: 'other', # fire hydrant + 11: 'other', # stop sign + 12: 'other', # parking meter + 13: 'other', # bench + 14: 'other', # bird + 15: 'other', # cat + 16: 'other', # dog + 17: 'other', # horse + 18: 'other', # sheep + 19: 'other', # cow + 20: 'other', # elephant + 21: 'other', # bear + 22: 'other', # zebra + 23: 'other', # giraffe + 24: 'other', # backpack + 25: 'other', # umbrella + 26: 'other', # handbag + 27: 'other', # tie + 28: 'other', # suitcase + 29: 'other', # frisbee + 30: 'other', # skis + 31: 'other', # snowboard + 32: 'other', # sports ball + 33: 'other', # kite + 34: 'other', # baseball bat + 35: 'other', # baseball glove + 36: 'other', # skateboard + 37: 'other', # surfboard + 38: 'other', # tennis racket + 39: 'other', # bottle + 40: 'garbage', # wine glass + 41: 'other', # cup + 42: 'other', # fork + 43: 'other', # knife + 44: 'other', # spoon + 45: 'other', # bowl + 46: 'other', # banana + 47: 'other', # apple + 48: 'other', # sandwich + 49: 'other', # orange + 50: 'other', # broccoli + 51: 'other', # carrot + 52: 'other', # hot dog + 53: 'other', # pizza + 54: 'other', # donut + 55: 'other', # cake + 56: 'other', # chair + 57: 'other', # couch + 58: 'other', # potted plant + 59: 'other', # bed + 60: 'other', # dining table + 61: 'other', # toilet + 62: 'other', # tv + 63: 'other', # laptop + 64: 'other', # mouse + 65: 'other', # remote + 66: 'other', # keyboard + 67: 'other', # cell phone + 68: 'other', # microwave + 69: 'other', # oven + 70: 'other', # toaster + 71: 'other', # sink + 72: 'other', # refrigerator + 73: 'other', # book + 74: 'other', # clock + 75: 'other', # vase + 76: 'other', # scissors + 77: 'other', # teddy bear + 78: 'other', # hair drier + 79: 'other', # toothbrush + } + return general_mapping.get(class_id, 'other') + +def analyze_image_quality(image_array): + """Analyze image quality for better detection""" + try: + # Convert to grayscale for analysis + gray = cv2.cvtColor(image_array, cv2.COLOR_RGB2GRAY) + + # Calculate image quality metrics + blur_score = cv2.Laplacian(gray, cv2.CV_64F).var() + brightness = np.mean(gray) + contrast = np.std(gray) + + quality_score = min(1.0, (blur_score / 1000) * (brightness / 128) * (contrast / 64)) + + return { + 'blur_score': float(blur_score), + 'brightness': float(brightness), + 'contrast': float(contrast), + 'quality_score': float(quality_score) + } + except Exception as e: + logger.error(f"Error analyzing image quality: {e}") + return { + 'blur_score': 0, + 'brightness': 0, + 'contrast': 0, + 'quality_score': 0 + } + +@app.route('/health', methods=['GET']) +def health_check(): + """Health check endpoint""" + return jsonify({ + 'status': 'healthy', + 'timestamp': datetime.now().isoformat(), + 'models': model_status + }) + +@app.route('/status', methods=['GET']) +def get_status(): + """Get AI service status""" + return jsonify({ + 'status': 'online', + 'models': model_status, + 'available_models': list(models.keys()), + 'issue_categories': list(ISSUE_CATEGORIES.keys()) + }) + +@app.route('/analyze', methods=['POST']) +def analyze_image(): + """Analyze image for civic issues""" + try: + start_time = datetime.now() + + data = request.get_json() + if not data or 'image' not in data: + return jsonify({ + 'error': 'Image data required', + 'detected_issues': [], + 'confidence': 0, + 'processing_time': 0 + }), 400 + + # Preprocess image + image_array = preprocess_image(data['image']) + + # Analyze image quality + quality_metrics = analyze_image_quality(image_array) + + # Detect issues + detected_issues = detect_issues_yolo(image_array, data.get('model', 'issue-detection')) + + # Calculate overall confidence + overall_confidence = 0 + if detected_issues: + overall_confidence = sum(issue['confidence'] for issue in detected_issues) / len(detected_issues) + + processing_time = (datetime.now() - start_time).total_seconds() + + result = { + 'detected_issues': detected_issues, + 'confidence': float(overall_confidence), + 'processing_time': float(processing_time), + 'image_quality': quality_metrics, + 'timestamp': start_time.isoformat() + } + + logger.info(f"Analysis completed: {len(detected_issues)} issues detected in {processing_time:.2f}s") + + return jsonify(result) + + except Exception as e: + logger.error(f"Error in image analysis: {e}") + return jsonify({ + 'error': str(e), + 'detected_issues': [], + 'confidence': 0, + 'processing_time': 0 + }), 500 + +@app.route('/detect', methods=['POST']) +def detect_specific_issue(): + """Detect specific issue type in image""" + try: + data = request.get_json() + if not data or 'image' not in data or 'issue_type' not in data: + return jsonify({ + 'error': 'Image data and issue type required', + 'detected': False, + 'confidence': 0, + 'bounding_boxes': [] + }), 400 + + issue_type = data['issue_type'] + model_name = ISSUE_CATEGORIES.get(issue_type, 'issue-detection') + + # Preprocess image + image_array = preprocess_image(data['image']) + + # Detect specific issue + detected_issues = detect_issues_yolo(image_array, model_name) + + # Filter for specific issue type + filtered_issues = [issue for issue in detected_issues if issue['type'] == issue_type] + + result = { + 'detected': len(filtered_issues) > 0, + 'confidence': max([issue['confidence'] for issue in filtered_issues], default=0), + 'bounding_boxes': [issue['bounding_box'] for issue in filtered_issues], + 'count': len(filtered_issues), + 'issue_type': issue_type + } + + return jsonify(result) + + except Exception as e: + logger.error(f"Error in specific issue detection: {e}") + return jsonify({ + 'error': str(e), + 'detected': False, + 'confidence': 0, + 'bounding_boxes': [] + }), 500 + +@app.route('/batch-analyze', methods=['POST']) +def batch_analyze(): + """Analyze multiple images in batch""" + try: + data = request.get_json() + if not data or 'images' not in data: + return jsonify({'error': 'Images data required'}), 400 + + images = data['images'] + results = [] + + for i, image_data in enumerate(images): + try: + # Preprocess image + image_array = preprocess_image(image_data) + + # Detect issues + detected_issues = detect_issues_yolo(image_array, data.get('model', 'issue-detection')) + + # Calculate confidence + confidence = 0 + if detected_issues: + confidence = sum(issue['confidence'] for issue in detected_issues) / len(detected_issues) + + results.append({ + 'image_index': i, + 'detected_issues': detected_issues, + 'confidence': float(confidence), + 'status': 'success' + }) + + except Exception as e: + logger.error(f"Error processing image {i}: {e}") + results.append({ + 'image_index': i, + 'detected_issues': [], + 'confidence': 0, + 'status': 'error', + 'error': str(e) + }) + + return jsonify({ + 'results': results, + 'total_processed': len(images), + 'successful': len([r for r in results if r['status'] == 'success']) + }) + + except Exception as e: + logger.error(f"Error in batch analysis: {e}") + return jsonify({'error': str(e)}), 500 + +@app.route('/retrain', methods=['POST']) +def retrain_model(): + """Retrain AI model with new data""" + try: + data = request.get_json() + if not data or 'training_data' not in data: + return jsonify({'error': 'Training data required'}), 400 + + # This is a placeholder for model retraining + # In a real implementation, you would: + # 1. Validate training data + # 2. Preprocess data + # 3. Train model + # 4. Validate model + # 5. Deploy new model + + return jsonify({ + 'status': 'retraining_started', + 'message': 'Model retraining initiated', + 'training_data_size': len(data['training_data']) + }) + + except Exception as e: + logger.error(f"Error in model retraining: {e}") + return jsonify({'error': str(e)}), 500 + +if __name__ == '__main__': + # Load models on startup + load_models() + + # Start Flask app + port = int(os.environ.get('PORT', 5000)) + app.run(host='0.0.0.0', port=port, debug=False) \ No newline at end of file diff --git a/ai-services/requirements.txt b/ai-services/requirements.txt new file mode 100644 index 0000000..a9c4470 --- /dev/null +++ b/ai-services/requirements.txt @@ -0,0 +1,15 @@ +flask==2.3.3 +flask-cors==4.0.0 +tensorflow==2.13.0 +opencv-python==4.8.1.78 +pillow==10.0.1 +numpy==1.24.3 +requests==2.31.0 +python-dotenv==1.0.0 +ultralytics==8.0.196 +torch==2.0.1 +torchvision==0.15.2 +scikit-learn==1.3.0 +matplotlib==3.7.2 +seaborn==0.12.2 +pandas==2.0.3 \ No newline at end of file diff --git a/backend/Dockerfile b/backend/Dockerfile new file mode 100644 index 0000000..d2243f2 --- /dev/null +++ b/backend/Dockerfile @@ -0,0 +1,42 @@ +# Use Node.js 18 LTS +FROM node:18-alpine + +# Set working directory +WORKDIR /app + +# Install system dependencies +RUN apk add --no-cache \ + python3 \ + make \ + g++ \ + curl + +# Copy package files +COPY package*.json ./ + +# Install dependencies +RUN npm ci --only=production + +# Copy source code +COPY . . + +# Create uploads directory +RUN mkdir -p uploads logs + +# Create non-root user +RUN addgroup -g 1001 -S nodejs +RUN adduser -S nodejs -u 1001 + +# Change ownership of the app directory +RUN chown -R nodejs:nodejs /app +USER nodejs + +# Expose port +EXPOSE 3000 + +# Health check +HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ + CMD curl -f http://localhost:3000/health || exit 1 + +# Start the application +CMD ["npm", "start"] \ No newline at end of file diff --git a/backend/migrations/001_create_users_table.js b/backend/migrations/001_create_users_table.js new file mode 100644 index 0000000..1bbbd15 --- /dev/null +++ b/backend/migrations/001_create_users_table.js @@ -0,0 +1,29 @@ +exports.up = function(knex) { + return knex.schema.createTable('users', function(table) { + table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid()')); + table.string('email').unique().notNullable(); + table.string('password_hash').notNullable(); + table.string('first_name').notNullable(); + table.string('last_name').notNullable(); + table.string('phone').nullable(); + table.string('avatar_url').nullable(); + table.boolean('is_verified').defaultTo(false); + table.boolean('is_active').defaultTo(true); + table.boolean('is_anonymous').defaultTo(false); + table.string('device_id').nullable(); // For anonymous users + table.integer('total_points').defaultTo(0); + table.integer('level').defaultTo(1); + table.json('preferences').nullable(); + table.timestamp('last_login').nullable(); + table.timestamps(true, true); + + // Indexes + table.index(['email']); + table.index(['device_id']); + table.index(['total_points']); + }); +}; + +exports.down = function(knex) { + return knex.schema.dropTable('users'); +}; \ No newline at end of file diff --git a/backend/migrations/002_create_issues_table.js b/backend/migrations/002_create_issues_table.js new file mode 100644 index 0000000..b0fa5ee --- /dev/null +++ b/backend/migrations/002_create_issues_table.js @@ -0,0 +1,59 @@ +exports.up = function(knex) { + return knex.schema.createTable('issues', function(table) { + table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid()')); + table.uuid('reporter_id').references('id').inTable('users').onDelete('SET NULL'); + table.string('title').notNullable(); + table.text('description').nullable(); + table.enum('category', [ + 'pothole', + 'garbage', + 'sewage', + 'street_light', + 'traffic_signal', + 'road_damage', + 'water_leak', + 'illegal_dumping', + 'other' + ]).notNullable(); + table.enum('priority', ['low', 'medium', 'high', 'critical']).defaultTo('medium'); + table.enum('status', [ + 'reported', + 'verified', + 'assigned', + 'in_progress', + 'resolved', + 'closed', + 'rejected' + ]).defaultTo('reported'); + table.decimal('latitude', 10, 8).notNullable(); + table.decimal('longitude', 11, 8).notNullable(); + table.string('address').nullable(); + table.string('city').nullable(); + table.string('state').nullable(); + table.string('pincode').nullable(); + table.json('media_urls').nullable(); // Array of image/video URLs + table.json('ai_detection_results').nullable(); // AI analysis results + table.integer('upvotes').defaultTo(0); + table.integer('reports_count').defaultTo(0); // For duplicate reports + table.boolean('is_anonymous').defaultTo(false); + table.string('device_id').nullable(); // For anonymous reports + table.uuid('assigned_to').nullable(); // Municipal worker ID + table.timestamp('resolved_at').nullable(); + table.text('resolution_notes').nullable(); + table.json('resolution_media').nullable(); // Before/after photos + table.timestamps(true, true); + + // Indexes + table.index(['reporter_id']); + table.index(['category']); + table.index(['status']); + table.index(['priority']); + table.index(['latitude', 'longitude']); + table.index(['created_at']); + table.index(['assigned_to']); + }); +}; + +exports.down = function(knex) { + return knex.schema.dropTable('issues'); +}; \ No newline at end of file diff --git a/backend/migrations/003_create_gamification_tables.js b/backend/migrations/003_create_gamification_tables.js new file mode 100644 index 0000000..3fbfeac --- /dev/null +++ b/backend/migrations/003_create_gamification_tables.js @@ -0,0 +1,57 @@ +exports.up = function(knex) { + return knex.schema.createTable('points_transactions', function(table) { + table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid()')); + table.uuid('user_id').references('id').inTable('users').onDelete('CASCADE'); + table.uuid('issue_id').references('id').inTable('issues').onDelete('SET NULL'); + table.integer('points').notNullable(); + table.enum('type', [ + 'issue_report', + 'issue_resolution', + 'upvote_received', + 'streak_bonus', + 'level_up', + 'achievement', + 'admin_adjustment' + ]).notNullable(); + table.string('description').nullable(); + table.timestamps(true, true); + + // Indexes + table.index(['user_id']); + table.index(['issue_id']); + table.index(['type']); + table.index(['created_at']); + }); + + return knex.schema.createTable('achievements', function(table) { + table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid()')); + table.string('name').notNullable(); + table.text('description').nullable(); + table.string('icon_url').nullable(); + table.integer('points_reward').defaultTo(0); + table.json('criteria').notNullable(); // JSON object defining achievement criteria + table.boolean('is_active').defaultTo(true); + table.timestamps(true, true); + }); + + return knex.schema.createTable('user_achievements', function(table) { + table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid()')); + table.uuid('user_id').references('id').inTable('users').onDelete('CASCADE'); + table.uuid('achievement_id').references('id').inTable('achievements').onDelete('CASCADE'); + table.timestamp('earned_at').defaultTo(knex.fn.now()); + table.timestamps(true, true); + + // Unique constraint to prevent duplicate achievements + table.unique(['user_id', 'achievement_id']); + + // Indexes + table.index(['user_id']); + table.index(['achievement_id']); + }); +}; + +exports.down = function(knex) { + return knex.schema.dropTable('user_achievements') + .then(() => knex.schema.dropTable('achievements')) + .then(() => knex.schema.dropTable('points_transactions')); +}; \ No newline at end of file diff --git a/backend/migrations/004_create_admin_tables.js b/backend/migrations/004_create_admin_tables.js new file mode 100644 index 0000000..5f21c88 --- /dev/null +++ b/backend/migrations/004_create_admin_tables.js @@ -0,0 +1,67 @@ +exports.up = function(knex) { + return knex.schema.createTable('municipal_workers', function(table) { + table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid()')); + table.string('employee_id').unique().notNullable(); + table.string('email').unique().notNullable(); + table.string('password_hash').notNullable(); + table.string('first_name').notNullable(); + table.string('last_name').notNullable(); + table.string('phone').notNullable(); + table.string('department').notNullable(); + table.enum('role', ['worker', 'supervisor', 'manager', 'admin']).defaultTo('worker'); + table.json('assigned_areas').nullable(); // GeoJSON or area definitions + table.boolean('is_active').defaultTo(true); + table.timestamps(true, true); + + // Indexes + table.index(['employee_id']); + table.index(['email']); + table.index(['department']); + table.index(['role']); + }); + + return knex.schema.createTable('issue_status_history', function(table) { + table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid()')); + table.uuid('issue_id').references('id').inTable('issues').onDelete('CASCADE'); + table.uuid('updated_by').references('id').inTable('municipal_workers').onDelete('SET NULL'); + table.enum('old_status', [ + 'reported', + 'verified', + 'assigned', + 'in_progress', + 'resolved', + 'closed', + 'rejected' + ]).nullable(); + table.enum('new_status', [ + 'reported', + 'verified', + 'assigned', + 'in_progress', + 'resolved', + 'closed', + 'rejected' + ]).notNullable(); + table.text('notes').nullable(); + table.timestamps(true, true); + + // Indexes + table.index(['issue_id']); + table.index(['updated_by']); + table.index(['created_at']); + }); + + return knex.schema.createTable('system_settings', function(table) { + table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid()')); + table.string('key').unique().notNullable(); + table.json('value').notNullable(); + table.text('description').nullable(); + table.timestamps(true, true); + }); +}; + +exports.down = function(knex) { + return knex.schema.dropTable('system_settings') + .then(() => knex.schema.dropTable('issue_status_history')) + .then(() => knex.schema.dropTable('municipal_workers')); +}; \ No newline at end of file diff --git a/backend/package.json b/backend/package.json new file mode 100644 index 0000000..2a7f8ae --- /dev/null +++ b/backend/package.json @@ -0,0 +1,55 @@ +{ + "name": "vighnview-backend", + "version": "1.0.0", + "description": "VighnView Backend API - Phase 1", + "main": "src/app.js", + "scripts": { + "start": "node src/app.js", + "dev": "nodemon src/app.js", + "build": "echo 'No build step required for Node.js'", + "test": "jest", + "test:watch": "jest --watch", + "migrate": "knex migrate:latest", + "migrate:rollback": "knex migrate:rollback", + "seed": "knex seed:run" + }, + "dependencies": { + "express": "^4.18.2", + "cors": "^2.8.5", + "helmet": "^7.1.0", + "morgan": "^1.10.0", + "dotenv": "^16.3.1", + "bcryptjs": "^2.4.3", + "jsonwebtoken": "^9.0.2", + "joi": "^17.11.0", + "multer": "^1.4.5-lts.1", + "sharp": "^0.32.6", + "knex": "^3.0.1", + "pg": "^8.11.3", + "redis": "^4.6.10", + "socket.io": "^4.7.4", + "express-rate-limit": "^7.1.5", + "express-validator": "^7.0.1", + "nodemailer": "^6.9.7", + "firebase-admin": "^11.11.1", + "axios": "^1.6.2", + "uuid": "^9.0.1", + "moment": "^2.29.4", + "winston": "^3.11.0" + }, + "devDependencies": { + "nodemon": "^3.0.2", + "jest": "^29.7.0", + "supertest": "^6.3.3", + "@types/jest": "^29.5.8" + }, + "keywords": [ + "api", + "civic-reporting", + "smart-city", + "nodejs", + "express" + ], + "author": "VighnView Team", + "license": "MIT" +} \ No newline at end of file diff --git a/backend/src/app.js b/backend/src/app.js new file mode 100644 index 0000000..4cff4ac --- /dev/null +++ b/backend/src/app.js @@ -0,0 +1,147 @@ +const express = require('express'); +const cors = require('cors'); +const helmet = require('helmet'); +const morgan = require('morgan'); +const rateLimit = require('express-rate-limit'); +require('dotenv').config(); + +const { errorHandler, notFound } = require('./middleware/errorMiddleware'); +const { connectDB } = require('./config/database'); +const { connectRedis } = require('./config/redis'); +const logger = require('./utils/logger'); + +// Import routes +const authRoutes = require('./routes/authRoutes'); +const issueRoutes = require('./routes/issueRoutes'); +const userRoutes = require('./routes/userRoutes'); +const gamificationRoutes = require('./routes/gamificationRoutes'); +const adminRoutes = require('./routes/adminRoutes'); + +const app = express(); +const PORT = process.env.PORT || 3000; + +// Security middleware +app.use(helmet()); + +// Rate limiting +const limiter = rateLimit({ + windowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS) || 15 * 60 * 1000, // 15 minutes + max: parseInt(process.env.RATE_LIMIT_MAX_REQUESTS) || 100, // limit each IP to 100 requests per windowMs + message: 'Too many requests from this IP, please try again later.', + standardHeaders: true, + legacyHeaders: false, +}); +app.use(limiter); + +// CORS configuration +const corsOptions = { + origin: process.env.CORS_ORIGIN?.split(',') || ['http://localhost:3001', 'http://localhost:3000'], + credentials: true, + optionsSuccessStatus: 200 +}; +app.use(cors(corsOptions)); + +// Body parsing middleware +app.use(express.json({ limit: '10mb' })); +app.use(express.urlencoded({ extended: true, limit: '10mb' })); + +// Logging middleware +app.use(morgan('combined', { stream: { write: message => logger.info(message.trim()) } })); + +// Health check endpoint +app.get('/health', (req, res) => { + res.status(200).json({ + status: 'OK', + timestamp: new Date().toISOString(), + uptime: process.uptime(), + environment: process.env.NODE_ENV || 'development' + }); +}); + +// API routes +app.use('/api/auth', authRoutes); +app.use('/api/issues', issueRoutes); +app.use('/api/users', userRoutes); +app.use('/api/gamification', gamificationRoutes); +app.use('/api/admin', adminRoutes); + +// API documentation endpoint +app.get('/api/docs', (req, res) => { + res.json({ + title: 'VighnView API Documentation', + version: '1.0.0', + description: 'Smart Civic Monitoring Platform API', + endpoints: { + auth: { + 'POST /api/auth/register': 'Register a new user', + 'POST /api/auth/login': 'Login user', + 'POST /api/auth/refresh': 'Refresh access token', + 'POST /api/auth/logout': 'Logout user', + 'POST /api/auth/forgot-password': 'Request password reset', + 'POST /api/auth/reset-password': 'Reset password' + }, + issues: { + 'GET /api/issues': 'Get all issues (with filters)', + 'POST /api/issues': 'Create a new issue report', + 'GET /api/issues/:id': 'Get issue by ID', + 'PUT /api/issues/:id': 'Update issue', + 'DELETE /api/issues/:id': 'Delete issue', + 'POST /api/issues/:id/upvote': 'Upvote an issue', + 'POST /api/issues/:id/resolve': 'Mark issue as resolved' + }, + users: { + 'GET /api/users/profile': 'Get user profile', + 'PUT /api/users/profile': 'Update user profile', + 'GET /api/users/issues': 'Get user\'s reported issues', + 'POST /api/users/avatar': 'Upload user avatar' + }, + gamification: { + 'GET /api/gamification/leaderboard': 'Get leaderboard', + 'GET /api/gamification/points': 'Get user points', + 'GET /api/gamification/achievements': 'Get user achievements' + }, + admin: { + 'GET /api/admin/dashboard': 'Get admin dashboard data', + 'GET /api/admin/issues': 'Get all issues for admin', + 'PUT /api/admin/issues/:id/status': 'Update issue status', + 'GET /api/admin/analytics': 'Get analytics data' + } + } + }); +}); + +// Error handling middleware +app.use(notFound); +app.use(errorHandler); + +// Initialize database and Redis connections +const startServer = async () => { + try { + await connectDB(); + await connectRedis(); + + app.listen(PORT, () => { + logger.info(`🚀 VighnView Backend Server running on port ${PORT}`); + logger.info(`📚 API Documentation available at http://localhost:${PORT}/api/docs`); + logger.info(`🏥 Health check available at http://localhost:${PORT}/health`); + }); + } catch (error) { + logger.error('Failed to start server:', error); + process.exit(1); + } +}; + +// Graceful shutdown +process.on('SIGTERM', () => { + logger.info('SIGTERM received, shutting down gracefully'); + process.exit(0); +}); + +process.on('SIGINT', () => { + logger.info('SIGINT received, shutting down gracefully'); + process.exit(0); +}); + +startServer(); + +module.exports = app; \ No newline at end of file diff --git a/backend/src/config/database.js b/backend/src/config/database.js new file mode 100644 index 0000000..7aaec6b --- /dev/null +++ b/backend/src/config/database.js @@ -0,0 +1,42 @@ +const knex = require('knex'); +const logger = require('../utils/logger'); + +const config = { + client: 'pg', + connection: { + connectionString: process.env.DATABASE_URL, + ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false + }, + migrations: { + directory: './migrations', + tableName: 'knex_migrations' + }, + seeds: { + directory: './seeds' + }, + pool: { + min: 2, + max: 10 + } +}; + +const db = knex(config); + +// Test database connection +const connectDB = async () => { + try { + await db.raw('SELECT 1'); + logger.info('✅ Database connected successfully'); + + // Run migrations in development + if (process.env.NODE_ENV === 'development') { + await db.migrate.latest(); + logger.info('✅ Database migrations completed'); + } + } catch (error) { + logger.error('❌ Database connection failed:', error); + throw error; + } +}; + +module.exports = { db, connectDB }; \ No newline at end of file diff --git a/backend/src/config/redis.js b/backend/src/config/redis.js new file mode 100644 index 0000000..e7f14b2 --- /dev/null +++ b/backend/src/config/redis.js @@ -0,0 +1,76 @@ +const redis = require('redis'); +const logger = require('../utils/logger'); + +let redisClient; + +const connectRedis = async () => { + try { + redisClient = redis.createClient({ + url: process.env.REDIS_URL || 'redis://localhost:6379' + }); + + redisClient.on('error', (err) => { + logger.error('Redis Client Error:', err); + }); + + redisClient.on('connect', () => { + logger.info('✅ Redis connected successfully'); + }); + + await redisClient.connect(); + } catch (error) { + logger.error('❌ Redis connection failed:', error); + throw error; + } +}; + +const getRedisClient = () => { + if (!redisClient) { + throw new Error('Redis client not initialized'); + } + return redisClient; +}; + +// Cache helper functions +const cache = { + async get(key) { + try { + const client = getRedisClient(); + const value = await client.get(key); + return value ? JSON.parse(value) : null; + } catch (error) { + logger.error('Redis GET error:', error); + return null; + } + }, + + async set(key, value, ttl = 3600) { + try { + const client = getRedisClient(); + await client.setEx(key, ttl, JSON.stringify(value)); + } catch (error) { + logger.error('Redis SET error:', error); + } + }, + + async del(key) { + try { + const client = getRedisClient(); + await client.del(key); + } catch (error) { + logger.error('Redis DEL error:', error); + } + }, + + async exists(key) { + try { + const client = getRedisClient(); + return await client.exists(key); + } catch (error) { + logger.error('Redis EXISTS error:', error); + return false; + } + } +}; + +module.exports = { connectRedis, getRedisClient, cache }; \ No newline at end of file diff --git a/backend/src/middleware/authMiddleware.js b/backend/src/middleware/authMiddleware.js new file mode 100644 index 0000000..447fa98 --- /dev/null +++ b/backend/src/middleware/authMiddleware.js @@ -0,0 +1,132 @@ +const jwt = require('jsonwebtoken'); +const User = require('../models/User'); +const { cache } = require('../config/redis'); +const logger = require('../utils/logger'); + +const authenticateToken = async (req, res, next) => { + try { + const authHeader = req.headers['authorization']; + const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN + + if (!token) { + return res.status(401).json({ + success: false, + message: 'Access token required' + }); + } + + // Check cache first + const cachedUser = await cache.get(`user:${token}`); + if (cachedUser) { + req.user = cachedUser; + return next(); + } + + // Verify token + const decoded = jwt.verify(token, process.env.JWT_SECRET); + + // Get user from database + const user = await User.findById(decoded.userId); + if (!user || !user.isActive) { + return res.status(401).json({ + success: false, + message: 'Invalid or inactive user' + }); + } + + // Cache user data for 15 minutes + await cache.set(`user:${token}`, user.toJSON(), 900); + + req.user = user.toJSON(); + next(); + } catch (error) { + logger.error('Authentication error:', error); + + if (error.name === 'JsonWebTokenError') { + return res.status(401).json({ + success: false, + message: 'Invalid token' + }); + } + + if (error.name === 'TokenExpiredError') { + return res.status(401).json({ + success: false, + message: 'Token expired' + }); + } + + return res.status(500).json({ + success: false, + message: 'Authentication failed' + }); + } +}; + +const authenticateOptional = async (req, res, next) => { + try { + const authHeader = req.headers['authorization']; + const token = authHeader && authHeader.split(' ')[1]; + + if (!token) { + req.user = null; + return next(); + } + + const decoded = jwt.verify(token, process.env.JWT_SECRET); + const user = await User.findById(decoded.userId); + + if (user && user.isActive) { + req.user = user.toJSON(); + } else { + req.user = null; + } + + next(); + } catch (error) { + // For optional auth, we don't fail on token errors + req.user = null; + next(); + } +}; + +const requireRole = (roles) => { + return (req, res, next) => { + if (!req.user) { + return res.status(401).json({ + success: false, + message: 'Authentication required' + }); + } + + if (!roles.includes(req.user.role)) { + return res.status(403).json({ + success: false, + message: 'Insufficient permissions' + }); + } + + next(); + }; +}; + +const requireAnonymous = (req, res, next) => { + const deviceId = req.headers['x-device-id']; + + if (!deviceId) { + return res.status(400).json({ + success: false, + message: 'Device ID required for anonymous access' + }); + } + + req.deviceId = deviceId; + next(); +}; + +module.exports = { + authenticateToken, + authenticateOptional, + requireRole, + requireAnonymous +}; \ No newline at end of file diff --git a/backend/src/middleware/errorMiddleware.js b/backend/src/middleware/errorMiddleware.js new file mode 100644 index 0000000..f664405 --- /dev/null +++ b/backend/src/middleware/errorMiddleware.js @@ -0,0 +1,73 @@ +const logger = require('../utils/logger'); + +const notFound = (req, res, next) => { + const error = new Error(`Not Found - ${req.originalUrl}`); + res.status(404); + next(error); +}; + +const errorHandler = (err, req, res, next) => { + let statusCode = res.statusCode === 200 ? 500 : res.statusCode; + let message = err.message; + + // Log error + logger.error('Error:', { + message: err.message, + stack: err.stack, + url: req.originalUrl, + method: req.method, + ip: req.ip, + userAgent: req.get('User-Agent') + }); + + // Mongoose bad ObjectId + if (err.name === 'CastError' && err.kind === 'ObjectId') { + statusCode = 404; + message = 'Resource not found'; + } + + // Mongoose duplicate key + if (err.code === 11000) { + statusCode = 400; + message = 'Duplicate field value entered'; + } + + // Mongoose validation error + if (err.name === 'ValidationError') { + statusCode = 400; + message = Object.values(err.errors).map(val => val.message).join(', '); + } + + // JWT errors + if (err.name === 'JsonWebTokenError') { + statusCode = 401; + message = 'Invalid token'; + } + + if (err.name === 'TokenExpiredError') { + statusCode = 401; + message = 'Token expired'; + } + + // File upload errors + if (err.code === 'LIMIT_FILE_SIZE') { + statusCode = 400; + message = 'File too large'; + } + + if (err.code === 'LIMIT_UNEXPECTED_FILE') { + statusCode = 400; + message = 'Unexpected file field'; + } + + res.status(statusCode).json({ + success: false, + message, + ...(process.env.NODE_ENV === 'development' && { stack: err.stack }) + }); +}; + +module.exports = { + notFound, + errorHandler +}; \ No newline at end of file diff --git a/backend/src/models/Issue.js b/backend/src/models/Issue.js new file mode 100644 index 0000000..3a33106 --- /dev/null +++ b/backend/src/models/Issue.js @@ -0,0 +1,313 @@ +const { db } = require('../config/database'); +const { v4: uuidv4 } = require('uuid'); + +class Issue { + constructor(data) { + this.id = data.id; + this.reporterId = data.reporter_id; + this.title = data.title; + this.description = data.description; + this.category = data.category; + this.priority = data.priority; + this.status = data.status; + this.latitude = parseFloat(data.latitude); + this.longitude = parseFloat(data.longitude); + this.address = data.address; + this.city = data.city; + this.state = data.state; + this.pincode = data.pincode; + this.mediaUrls = data.media_urls; + this.aiDetectionResults = data.ai_detection_results; + this.upvotes = data.upvotes; + this.reportsCount = data.reports_count; + this.isAnonymous = data.is_anonymous; + this.deviceId = data.device_id; + this.assignedTo = data.assigned_to; + this.resolvedAt = data.resolved_at; + this.resolutionNotes = data.resolution_notes; + this.resolutionMedia = data.resolution_media; + this.createdAt = data.created_at; + this.updatedAt = data.updated_at; + } + + static async create(issueData) { + const { + reporterId, + title, + description, + category, + priority = 'medium', + latitude, + longitude, + address, + city, + state, + pincode, + mediaUrls = [], + aiDetectionResults = null, + isAnonymous = false, + deviceId = null + } = issueData; + + const [issue] = await db('issues') + .insert({ + id: uuidv4(), + reporter_id: reporterId, + title, + description, + category, + priority, + latitude, + longitude, + address, + city, + state, + pincode, + media_urls: JSON.stringify(mediaUrls), + ai_detection_results: aiDetectionResults ? JSON.stringify(aiDetectionResults) : null, + is_anonymous: isAnonymous, + device_id: deviceId, + upvotes: 0, + reports_count: 0 + }) + .returning('*'); + + return new Issue(issue); + } + + static async findById(id) { + const issue = await db('issues').where({ id }).first(); + return issue ? new Issue(issue) : null; + } + + static async findAll(filters = {}) { + let query = db('issues') + .leftJoin('users', 'issues.reporter_id', 'users.id') + .select( + 'issues.*', + 'users.first_name as reporter_first_name', + 'users.last_name as reporter_last_name', + 'users.avatar_url as reporter_avatar_url' + ); + + // Apply filters + if (filters.category) { + query = query.where('issues.category', filters.category); + } + if (filters.status) { + query = query.where('issues.status', filters.status); + } + if (filters.priority) { + query = query.where('issues.priority', filters.priority); + } + if (filters.city) { + query = query.where('issues.city', filters.city); + } + if (filters.reporterId) { + query = query.where('issues.reporter_id', filters.reporterId); + } + if (filters.assignedTo) { + query = query.where('issues.assigned_to', filters.assignedTo); + } + if (filters.dateFrom) { + query = query.where('issues.created_at', '>=', filters.dateFrom); + } + if (filters.dateTo) { + query = query.where('issues.created_at', '<=', filters.dateTo); + } + if (filters.bounds) { + const { north, south, east, west } = filters.bounds; + query = query.whereBetween('issues.latitude', [south, north]) + .whereBetween('issues.longitude', [west, east]); + } + + // Sorting + const sortBy = filters.sortBy || 'created_at'; + const sortOrder = filters.sortOrder || 'desc'; + query = query.orderBy(`issues.${sortBy}`, sortOrder); + + // Pagination + if (filters.limit) { + query = query.limit(filters.limit); + } + if (filters.offset) { + query = query.offset(filters.offset); + } + + const issues = await query; + return issues.map(issue => new Issue(issue)); + } + + static async updateStatus(issueId, newStatus, updatedBy = null, notes = null) { + const trx = await db.transaction(); + + try { + // Get current issue + const currentIssue = await trx('issues').where({ id: issueId }).first(); + if (!currentIssue) { + throw new Error('Issue not found'); + } + + // Update issue status + const updateData = { + status: newStatus, + updated_at: new Date() + }; + + if (newStatus === 'resolved' || newStatus === 'closed') { + updateData.resolved_at = new Date(); + } + + if (updatedBy) { + updateData.assigned_to = updatedBy; + } + + const [issue] = await trx('issues') + .where({ id: issueId }) + .update(updateData) + .returning('*'); + + // Record status change in history + await trx('issue_status_history').insert({ + id: uuidv4(), + issue_id: issueId, + updated_by: updatedBy, + old_status: currentIssue.status, + new_status: newStatus, + notes + }); + + await trx.commit(); + return new Issue(issue); + } catch (error) { + await trx.rollback(); + throw error; + } + } + + static async upvote(issueId, userId) { + const trx = await db.transaction(); + + try { + // Check if user already upvoted (prevent duplicate upvotes) + const existingUpvote = await trx('issue_upvotes') + .where({ issue_id: issueId, user_id: userId }) + .first(); + + if (existingUpvote) { + throw new Error('User has already upvoted this issue'); + } + + // Add upvote record + await trx('issue_upvotes').insert({ + id: uuidv4(), + issue_id: issueId, + user_id: userId + }); + + // Increment upvote count + await trx('issues') + .where({ id: issueId }) + .increment('upvotes', 1); + + await trx.commit(); + return true; + } catch (error) { + await trx.rollback(); + throw error; + } + } + + static async getStats(filters = {}) { + let query = db('issues'); + + if (filters.dateFrom) { + query = query.where('created_at', '>=', filters.dateFrom); + } + if (filters.dateTo) { + query = query.where('created_at', '<=', filters.dateTo); + } + if (filters.city) { + query = query.where('city', filters.city); + } + + const stats = await query + .select( + db.raw('COUNT(*) as total_issues'), + db.raw('COUNT(CASE WHEN status = ? THEN 1 END) as reported', ['reported']), + db.raw('COUNT(CASE WHEN status = ? THEN 1 END) as in_progress', ['in_progress']), + db.raw('COUNT(CASE WHEN status = ? THEN 1 END) as resolved', ['resolved']), + db.raw('COUNT(CASE WHEN category = ? THEN 1 END) as potholes', ['pothole']), + db.raw('COUNT(CASE WHEN category = ? THEN 1 END) as garbage', ['garbage']), + db.raw('COUNT(CASE WHEN category = ? THEN 1 END) as sewage', ['sewage']), + db.raw('AVG(EXTRACT(EPOCH FROM (resolved_at - created_at))/3600) as avg_resolution_hours') + ) + .first(); + + return stats; + } + + static async getNearbyIssues(latitude, longitude, radiusKm = 1) { + // Using Haversine formula for distance calculation + const issues = await db('issues') + .select('*') + .whereRaw(` + 6371 * acos( + cos(radians(?)) * cos(radians(latitude)) * + cos(radians(longitude) - radians(?)) + + sin(radians(?)) * sin(radians(latitude)) + ) <= ? + `, [latitude, longitude, latitude, radiusKm]) + .orderBy('created_at', 'desc'); + + return issues.map(issue => new Issue(issue)); + } + + async update(updateData) { + const [issue] = await db('issues') + .where({ id: this.id }) + .update({ + ...updateData, + updated_at: new Date() + }) + .returning('*'); + + if (issue) { + Object.assign(this, new Issue(issue)); + } + return issue; + } + + toJSON() { + return { + id: this.id, + reporterId: this.reporterId, + title: this.title, + description: this.description, + category: this.category, + priority: this.priority, + status: this.status, + location: { + latitude: this.latitude, + longitude: this.longitude, + address: this.address, + city: this.city, + state: this.state, + pincode: this.pincode + }, + mediaUrls: this.mediaUrls, + aiDetectionResults: this.aiDetectionResults, + upvotes: this.upvotes, + reportsCount: this.reportsCount, + isAnonymous: this.isAnonymous, + assignedTo: this.assignedTo, + resolvedAt: this.resolvedAt, + resolutionNotes: this.resolutionNotes, + resolutionMedia: this.resolutionMedia, + createdAt: this.createdAt, + updatedAt: this.updatedAt + }; + } +} + +module.exports = Issue; \ No newline at end of file diff --git a/backend/src/models/User.js b/backend/src/models/User.js new file mode 100644 index 0000000..ba38fed --- /dev/null +++ b/backend/src/models/User.js @@ -0,0 +1,189 @@ +const { db } = require('../config/database'); +const bcrypt = require('bcryptjs'); +const { v4: uuidv4 } = require('uuid'); + +class User { + constructor(data) { + this.id = data.id; + this.email = data.email; + this.firstName = data.first_name; + this.lastName = data.last_name; + this.phone = data.phone; + this.avatarUrl = data.avatar_url; + this.isVerified = data.is_verified; + this.isActive = data.is_active; + this.isAnonymous = data.is_anonymous; + this.deviceId = data.device_id; + this.totalPoints = data.total_points; + this.level = data.level; + this.preferences = data.preferences; + this.lastLogin = data.last_login; + this.createdAt = data.created_at; + this.updatedAt = data.updated_at; + } + + static async create(userData) { + const { + email, + password, + firstName, + lastName, + phone, + isAnonymous = false, + deviceId = null + } = userData; + + const hashedPassword = await bcrypt.hash(password, parseInt(process.env.BCRYPT_ROUNDS) || 12); + + const [user] = await db('users') + .insert({ + id: uuidv4(), + email, + password_hash: hashedPassword, + first_name: firstName, + last_name: lastName, + phone, + is_anonymous: isAnonymous, + device_id: deviceId, + total_points: 0, + level: 1 + }) + .returning('*'); + + return new User(user); + } + + static async findByEmail(email) { + const user = await db('users').where({ email }).first(); + return user ? new User(user) : null; + } + + static async findById(id) { + const user = await db('users').where({ id }).first(); + return user ? new User(user) : null; + } + + static async findByDeviceId(deviceId) { + const user = await db('users').where({ device_id: deviceId }).first(); + return user ? new User(user) : null; + } + + static async update(id, updateData) { + const [user] = await db('users') + .where({ id }) + .update({ + ...updateData, + updated_at: new Date() + }) + .returning('*'); + + return user ? new User(user) : null; + } + + static async updateLastLogin(id) { + await db('users') + .where({ id }) + .update({ last_login: new Date() }); + } + + static async addPoints(userId, points, type, description = null, issueId = null) { + const trx = await db.transaction(); + + try { + // Add points transaction record + await trx('points_transactions').insert({ + id: uuidv4(), + user_id: userId, + issue_id: issueId, + points, + type, + description + }); + + // Update user's total points + await trx('users') + .where({ id: userId }) + .increment('total_points', points); + + // Get updated user data + const [user] = await trx('users') + .where({ id: userId }) + .returning('*'); + + await trx.commit(); + return new User(user); + } catch (error) { + await trx.rollback(); + throw error; + } + } + + static async getLeaderboard(limit = 50) { + const users = await db('users') + .select('id', 'first_name', 'last_name', 'avatar_url', 'total_points', 'level') + .where({ is_active: true }) + .orderBy('total_points', 'desc') + .limit(limit); + + return users.map(user => ({ + id: user.id, + name: `${user.first_name} ${user.last_name}`, + avatarUrl: user.avatar_url, + totalPoints: user.total_points, + level: user.level + })); + } + + static async getUserStats(userId) { + const stats = await db('users') + .leftJoin('issues', 'users.id', 'issues.reporter_id') + .leftJoin('points_transactions', 'users.id', 'points_transactions.user_id') + .where('users.id', userId) + .select( + 'users.total_points', + 'users.level', + db.raw('COUNT(DISTINCT issues.id) as issues_reported'), + db.raw('COUNT(DISTINCT CASE WHEN issues.status = ? THEN issues.id END) as issues_resolved', ['resolved']), + db.raw('SUM(CASE WHEN points_transactions.type = ? THEN points_transactions.points ELSE 0 END) as points_from_reports', ['issue_report']), + db.raw('SUM(CASE WHEN points_transactions.type = ? THEN points_transactions.points ELSE 0 END) as points_from_upvotes', ['upvote_received']) + ) + .groupBy('users.id', 'users.total_points', 'users.level') + .first(); + + return stats; + } + + async validatePassword(password) { + const user = await db('users').where({ id: this.id }).select('password_hash').first(); + return bcrypt.compare(password, user.password_hash); + } + + async updatePassword(newPassword) { + const hashedPassword = await bcrypt.hash(newPassword, parseInt(process.env.BCRYPT_ROUNDS) || 12); + await db('users') + .where({ id: this.id }) + .update({ password_hash: hashedPassword }); + } + + toJSON() { + return { + id: this.id, + email: this.email, + firstName: this.firstName, + lastName: this.lastName, + phone: this.phone, + avatarUrl: this.avatarUrl, + isVerified: this.isVerified, + isActive: this.isActive, + isAnonymous: this.isAnonymous, + totalPoints: this.totalPoints, + level: this.level, + preferences: this.preferences, + lastLogin: this.lastLogin, + createdAt: this.createdAt, + updatedAt: this.updatedAt + }; + } +} + +module.exports = User; \ No newline at end of file diff --git a/backend/src/routes/authRoutes.js b/backend/src/routes/authRoutes.js new file mode 100644 index 0000000..ad7f9ab --- /dev/null +++ b/backend/src/routes/authRoutes.js @@ -0,0 +1,379 @@ +const express = require('express'); +const jwt = require('jsonwebtoken'); +const { body, validationResult } = require('express-validator'); +const User = require('../models/User'); +const { authenticateToken } = require('../middleware/authMiddleware'); +const { cache } = require('../config/redis'); +const logger = require('../utils/logger'); + +const router = express.Router(); + +// Validation middleware +const validateRegistration = [ + body('email').isEmail().normalizeEmail(), + body('password').isLength({ min: 6 }).withMessage('Password must be at least 6 characters'), + body('firstName').trim().isLength({ min: 1 }).withMessage('First name is required'), + body('lastName').trim().isLength({ min: 1 }).withMessage('Last name is required'), + body('phone').optional().isMobilePhone() +]; + +const validateLogin = [ + body('email').isEmail().normalizeEmail(), + body('password').notEmpty().withMessage('Password is required') +]; + +// Generate JWT tokens +const generateTokens = (userId) => { + const accessToken = jwt.sign( + { userId }, + process.env.JWT_SECRET, + { expiresIn: process.env.JWT_EXPIRES_IN || '24h' } + ); + + const refreshToken = jwt.sign( + { userId, type: 'refresh' }, + process.env.JWT_REFRESH_SECRET, + { expiresIn: process.env.JWT_REFRESH_EXPIRES_IN || '7d' } + ); + + return { accessToken, refreshToken }; +}; + +// @route POST /api/auth/register +// @desc Register a new user +// @access Public +router.post('/register', validateRegistration, async (req, res) => { + try { + const errors = validationResult(req); + if (!errors.isEmpty()) { + return res.status(400).json({ + success: false, + message: 'Validation failed', + errors: errors.array() + }); + } + + const { email, password, firstName, lastName, phone, isAnonymous, deviceId } = req.body; + + // Check if user already exists + const existingUser = await User.findByEmail(email); + if (existingUser) { + return res.status(400).json({ + success: false, + message: 'User with this email already exists' + }); + } + + // Create new user + const user = await User.create({ + email, + password, + firstName, + lastName, + phone, + isAnonymous: isAnonymous || false, + deviceId + }); + + // Generate tokens + const { accessToken, refreshToken } = generateTokens(user.id); + + // Store refresh token in cache + await cache.set(`refresh:${user.id}`, refreshToken, 7 * 24 * 60 * 60); // 7 days + + logger.info(`New user registered: ${user.email}`); + + res.status(201).json({ + success: true, + message: 'User registered successfully', + data: { + user: user.toJSON(), + tokens: { + accessToken, + refreshToken + } + } + }); + } catch (error) { + logger.error('Registration error:', error); + res.status(500).json({ + success: false, + message: 'Registration failed', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route POST /api/auth/login +// @desc Login user +// @access Public +router.post('/login', validateLogin, async (req, res) => { + try { + const errors = validationResult(req); + if (!errors.isEmpty()) { + return res.status(400).json({ + success: false, + message: 'Validation failed', + errors: errors.array() + }); + } + + const { email, password } = req.body; + + // Find user by email + const user = await User.findByEmail(email); + if (!user) { + return res.status(401).json({ + success: false, + message: 'Invalid credentials' + }); + } + + // Check if user is active + if (!user.isActive) { + return res.status(401).json({ + success: false, + message: 'Account is deactivated' + }); + } + + // Validate password + const isValidPassword = await user.validatePassword(password); + if (!isValidPassword) { + return res.status(401).json({ + success: false, + message: 'Invalid credentials' + }); + } + + // Update last login + await User.updateLastLogin(user.id); + + // Generate tokens + const { accessToken, refreshToken } = generateTokens(user.id); + + // Store refresh token in cache + await cache.set(`refresh:${user.id}`, refreshToken, 7 * 24 * 60 * 60); + + logger.info(`User logged in: ${user.email}`); + + res.json({ + success: true, + message: 'Login successful', + data: { + user: user.toJSON(), + tokens: { + accessToken, + refreshToken + } + } + }); + } catch (error) { + logger.error('Login error:', error); + res.status(500).json({ + success: false, + message: 'Login failed', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route POST /api/auth/refresh +// @desc Refresh access token +// @access Public +router.post('/refresh', async (req, res) => { + try { + const { refreshToken } = req.body; + + if (!refreshToken) { + return res.status(401).json({ + success: false, + message: 'Refresh token required' + }); + } + + // Verify refresh token + const decoded = jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET); + + if (decoded.type !== 'refresh') { + return res.status(401).json({ + success: false, + message: 'Invalid refresh token' + }); + } + + // Check if refresh token exists in cache + const cachedRefreshToken = await cache.get(`refresh:${decoded.userId}`); + if (!cachedRefreshToken || cachedRefreshToken !== refreshToken) { + return res.status(401).json({ + success: false, + message: 'Invalid or expired refresh token' + }); + } + + // Get user + const user = await User.findById(decoded.userId); + if (!user || !user.isActive) { + return res.status(401).json({ + success: false, + message: 'User not found or inactive' + }); + } + + // Generate new tokens + const { accessToken, refreshToken: newRefreshToken } = generateTokens(user.id); + + // Update refresh token in cache + await cache.set(`refresh:${user.id}`, newRefreshToken, 7 * 24 * 60 * 60); + + res.json({ + success: true, + message: 'Token refreshed successfully', + data: { + tokens: { + accessToken, + refreshToken: newRefreshToken + } + } + }); + } catch (error) { + logger.error('Token refresh error:', error); + + if (error.name === 'JsonWebTokenError' || error.name === 'TokenExpiredError') { + return res.status(401).json({ + success: false, + message: 'Invalid or expired refresh token' + }); + } + + res.status(500).json({ + success: false, + message: 'Token refresh failed', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route POST /api/auth/logout +// @desc Logout user +// @access Private +router.post('/logout', authenticateToken, async (req, res) => { + try { + // Remove refresh token from cache + await cache.del(`refresh:${req.user.id}`); + + // Clear any cached user data + const authHeader = req.headers['authorization']; + const token = authHeader && authHeader.split(' ')[1]; + if (token) { + await cache.del(`user:${token}`); + } + + logger.info(`User logged out: ${req.user.email}`); + + res.json({ + success: true, + message: 'Logout successful' + }); + } catch (error) { + logger.error('Logout error:', error); + res.status(500).json({ + success: false, + message: 'Logout failed', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route GET /api/auth/me +// @desc Get current user +// @access Private +router.get('/me', authenticateToken, async (req, res) => { + try { + const user = await User.findById(req.user.id); + if (!user) { + return res.status(404).json({ + success: false, + message: 'User not found' + }); + } + + res.json({ + success: true, + data: { + user: user.toJSON() + } + }); + } catch (error) { + logger.error('Get user error:', error); + res.status(500).json({ + success: false, + message: 'Failed to get user data', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route POST /api/auth/anonymous +// @desc Create anonymous user session +// @access Public +router.post('/anonymous', [ + body('deviceId').notEmpty().withMessage('Device ID is required') +], async (req, res) => { + try { + const errors = validationResult(req); + if (!errors.isEmpty()) { + return res.status(400).json({ + success: false, + message: 'Validation failed', + errors: errors.array() + }); + } + + const { deviceId } = req.body; + + // Check if anonymous user already exists for this device + let user = await User.findByDeviceId(deviceId); + + if (!user) { + // Create anonymous user + user = await User.create({ + email: `anonymous_${deviceId}@vighnview.local`, + password: 'anonymous_password', + firstName: 'Anonymous', + lastName: 'User', + isAnonymous: true, + deviceId + }); + } + + // Generate tokens + const { accessToken, refreshToken } = generateTokens(user.id); + + // Store refresh token in cache + await cache.set(`refresh:${user.id}`, refreshToken, 7 * 24 * 60 * 60); + + logger.info(`Anonymous user session created: ${deviceId}`); + + res.json({ + success: true, + message: 'Anonymous session created', + data: { + user: user.toJSON(), + tokens: { + accessToken, + refreshToken + } + } + }); + } catch (error) { + logger.error('Anonymous auth error:', error); + res.status(500).json({ + success: false, + message: 'Anonymous authentication failed', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/backend/src/routes/gamificationRoutes.js b/backend/src/routes/gamificationRoutes.js new file mode 100644 index 0000000..26990ed --- /dev/null +++ b/backend/src/routes/gamificationRoutes.js @@ -0,0 +1,371 @@ +const express = require('express'); +const User = require('../models/User'); +const { authenticateToken } = require('../middleware/authMiddleware'); +const { db } = require('../config/database'); +const logger = require('../utils/logger'); + +const router = express.Router(); + +// @route GET /api/gamification/leaderboard +// @desc Get leaderboard +// @access Public +router.get('/leaderboard', async (req, res) => { + try { + const limit = parseInt(req.query.limit) || 50; + const timeframe = req.query.timeframe || 'all'; // all, week, month, year + + let leaderboard; + + if (timeframe === 'all') { + leaderboard = await User.getLeaderboard(limit); + } else { + // Get leaderboard for specific timeframe + const dateFilter = getDateFilter(timeframe); + leaderboard = await getLeaderboardForTimeframe(limit, dateFilter); + } + + res.json({ + success: true, + data: { + leaderboard, + timeframe, + limit + } + }); + } catch (error) { + logger.error('Get leaderboard error:', error); + res.status(500).json({ + success: false, + message: 'Failed to fetch leaderboard', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route GET /api/gamification/points +// @desc Get user points and stats +// @access Private +router.get('/points', authenticateToken, async (req, res) => { + try { + const userId = req.user.id; + + // Get user stats + const stats = await User.getUserStats(userId); + + // Get recent points transactions + const recentTransactions = await db('points_transactions') + .where({ user_id: userId }) + .orderBy('created_at', 'desc') + .limit(10) + .select('*'); + + // Get user achievements + const achievements = await db('user_achievements') + .join('achievements', 'user_achievements.achievement_id', 'achievements.id') + .where('user_achievements.user_id', userId) + .select('achievements.*', 'user_achievements.earned_at') + .orderBy('user_achievements.earned_at', 'desc'); + + // Calculate level and points to next level + const levelInfo = calculateLevelInfo(stats.total_points); + + res.json({ + success: true, + data: { + points: stats.total_points, + level: levelInfo.level, + pointsToNextLevel: levelInfo.pointsToNext, + stats: { + issuesReported: stats.issues_reported || 0, + issuesResolved: stats.issues_resolved || 0, + pointsFromReports: stats.points_from_reports || 0, + pointsFromUpvotes: stats.points_from_upvotes || 0 + }, + recentTransactions: recentTransactions.map(transaction => ({ + id: transaction.id, + points: transaction.points, + type: transaction.type, + description: transaction.description, + createdAt: transaction.created_at + })), + achievements: achievements.map(achievement => ({ + id: achievement.id, + name: achievement.name, + description: achievement.description, + iconUrl: achievement.icon_url, + pointsReward: achievement.points_reward, + earnedAt: achievement.earned_at + })) + } + }); + } catch (error) { + logger.error('Get user points error:', error); + res.status(500).json({ + success: false, + message: 'Failed to fetch user points', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route GET /api/gamification/achievements +// @desc Get all available achievements +// @access Public +router.get('/achievements', async (req, res) => { + try { + const achievements = await db('achievements') + .where({ is_active: true }) + .select('*') + .orderBy('points_reward', 'desc'); + + res.json({ + success: true, + data: { + achievements: achievements.map(achievement => ({ + id: achievement.id, + name: achievement.name, + description: achievement.description, + iconUrl: achievement.icon_url, + pointsReward: achievement.points_reward, + criteria: achievement.criteria + })) + } + }); + } catch (error) { + logger.error('Get achievements error:', error); + res.status(500).json({ + success: false, + message: 'Failed to fetch achievements', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route GET /api/gamification/achievements/user +// @desc Get user's achievements +// @access Private +router.get('/achievements/user', authenticateToken, async (req, res) => { + try { + const userId = req.user.id; + + // Get user's earned achievements + const earnedAchievements = await db('user_achievements') + .join('achievements', 'user_achievements.achievement_id', 'achievements.id') + .where('user_achievements.user_id', userId) + .select('achievements.*', 'user_achievements.earned_at') + .orderBy('user_achievements.earned_at', 'desc'); + + // Get all available achievements + const allAchievements = await db('achievements') + .where({ is_active: true }) + .select('*') + .orderBy('points_reward', 'desc'); + + // Mark which achievements are earned + const earnedIds = new Set(earnedAchievements.map(a => a.id)); + const achievementsWithStatus = allAchievements.map(achievement => { + const isEarned = earnedIds.has(achievement.id); + const earnedAchievement = earnedAchievements.find(a => a.id === achievement.id); + + return { + id: achievement.id, + name: achievement.name, + description: achievement.description, + iconUrl: achievement.icon_url, + pointsReward: achievement.points_reward, + criteria: achievement.criteria, + isEarned, + earnedAt: earnedAchievement ? earnedAchievement.earned_at : null, + progress: isEarned ? 100 : calculateAchievementProgress(userId, achievement.criteria) + }; + }); + + res.json({ + success: true, + data: { + achievements: achievementsWithStatus, + earnedCount: earnedAchievements.length, + totalCount: allAchievements.length + } + }); + } catch (error) { + logger.error('Get user achievements error:', error); + res.status(500).json({ + success: false, + message: 'Failed to fetch user achievements', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route POST /api/gamification/check-achievements +// @desc Check and award new achievements +// @access Private +router.post('/check-achievements', authenticateToken, async (req, res) => { + try { + const userId = req.user.id; + const newAchievements = await checkAndAwardAchievements(userId); + + res.json({ + success: true, + message: newAchievements.length > 0 ? 'New achievements earned!' : 'No new achievements', + data: { + newAchievements + } + }); + } catch (error) { + logger.error('Check achievements error:', error); + res.status(500).json({ + success: false, + message: 'Failed to check achievements', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// Helper functions +function getDateFilter(timeframe) { + const now = new Date(); + const filters = { + week: new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000), + month: new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000), + year: new Date(now.getTime() - 365 * 24 * 60 * 60 * 1000) + }; + + return filters[timeframe] || null; +} + +async function getLeaderboardForTimeframe(limit, dateFilter) { + const users = await db('users') + .join('points_transactions', 'users.id', 'points_transactions.user_id') + .where('users.is_active', true) + .where('points_transactions.created_at', '>=', dateFilter) + .select( + 'users.id', + 'users.first_name', + 'users.last_name', + 'users.avatar_url', + 'users.level', + db.raw('SUM(points_transactions.points) as total_points') + ) + .groupBy('users.id', 'users.first_name', 'users.last_name', 'users.avatar_url', 'users.level') + .orderBy('total_points', 'desc') + .limit(limit); + + return users.map(user => ({ + id: user.id, + name: `${user.first_name} ${user.last_name}`, + avatarUrl: user.avatar_url, + totalPoints: parseInt(user.total_points) || 0, + level: user.level + })); +} + +function calculateLevelInfo(totalPoints) { + // Level calculation: Level 1 = 0-99 points, Level 2 = 100-299 points, etc. + const level = Math.floor(totalPoints / 100) + 1; + const pointsInCurrentLevel = totalPoints % 100; + const pointsToNext = 100 - pointsInCurrentLevel; + + return { + level, + pointsToNext, + pointsInCurrentLevel + }; +} + +async function calculateAchievementProgress(userId, criteria) { + // This is a simplified version - in a real app, you'd implement + // specific logic for each achievement type + try { + const stats = await User.getUserStats(userId); + + if (criteria.type === 'issues_reported') { + return Math.min(100, (stats.issues_reported / criteria.target) * 100); + } + + if (criteria.type === 'points_earned') { + return Math.min(100, (stats.total_points / criteria.target) * 100); + } + + return 0; + } catch (error) { + return 0; + } +} + +async function checkAndAwardAchievements(userId) { + const newAchievements = []; + + try { + // Get user stats + const stats = await User.getUserStats(userId); + + // Get all active achievements + const achievements = await db('achievements') + .where({ is_active: true }) + .select('*'); + + // Get user's existing achievements + const existingAchievements = await db('user_achievements') + .where({ user_id: userId }) + .select('achievement_id'); + + const existingIds = new Set(existingAchievements.map(a => a.achievement_id)); + + // Check each achievement + for (const achievement of achievements) { + if (existingIds.has(achievement.id)) continue; + + const criteria = achievement.criteria; + let shouldAward = false; + + // Check achievement criteria + switch (criteria.type) { + case 'issues_reported': + shouldAward = stats.issues_reported >= criteria.target; + break; + case 'points_earned': + shouldAward = stats.total_points >= criteria.target; + break; + case 'issues_resolved': + shouldAward = stats.issues_resolved >= criteria.target; + break; + // Add more criteria types as needed + } + + if (shouldAward) { + // Award achievement + await db('user_achievements').insert({ + id: require('uuid').v4(), + user_id: userId, + achievement_id: achievement.id + }); + + // Award points + if (achievement.points_reward > 0) { + await User.addPoints( + userId, + achievement.points_reward, + 'achievement', + `Achievement unlocked: ${achievement.name}` + ); + } + + newAchievements.push({ + id: achievement.id, + name: achievement.name, + description: achievement.description, + iconUrl: achievement.icon_url, + pointsReward: achievement.points_reward + }); + } + } + } catch (error) { + logger.error('Error checking achievements:', error); + } + + return newAchievements; +} + +module.exports = router; \ No newline at end of file diff --git a/backend/src/routes/issueRoutes.js b/backend/src/routes/issueRoutes.js new file mode 100644 index 0000000..d8ec196 --- /dev/null +++ b/backend/src/routes/issueRoutes.js @@ -0,0 +1,390 @@ +const express = require('express'); +const multer = require('multer'); +const { body, validationResult, query } = require('express-validator'); +const Issue = require('../models/Issue'); +const User = require('../models/User'); +const { authenticateToken, authenticateOptional, requireAnonymous } = require('../middleware/authMiddleware'); +const { uploadToCloudStorage } = require('../utils/fileUpload'); +const { analyzeImageWithAI } = require('../utils/aiDetection'); +const logger = require('../utils/logger'); + +const router = express.Router(); + +// Configure multer for file uploads +const upload = multer({ + storage: multer.memoryStorage(), + limits: { + fileSize: 10 * 1024 * 1024, // 10MB limit + }, + fileFilter: (req, file, cb) => { + if (file.mimetype.startsWith('image/') || file.mimetype.startsWith('video/')) { + cb(null, true); + } else { + cb(new Error('Only image and video files are allowed'), false); + } + } +}); + +// Validation middleware +const validateIssueCreation = [ + body('title').trim().isLength({ min: 5, max: 200 }).withMessage('Title must be between 5 and 200 characters'), + body('description').optional().trim().isLength({ max: 1000 }).withMessage('Description must be less than 1000 characters'), + body('category').isIn(['pothole', 'garbage', 'sewage', 'street_light', 'traffic_signal', 'road_damage', 'water_leak', 'illegal_dumping', 'other']).withMessage('Invalid category'), + body('priority').optional().isIn(['low', 'medium', 'high', 'critical']).withMessage('Invalid priority'), + body('latitude').isFloat({ min: -90, max: 90 }).withMessage('Invalid latitude'), + body('longitude').isFloat({ min: -180, max: 180 }).withMessage('Invalid longitude'), + body('address').optional().trim().isLength({ max: 500 }).withMessage('Address too long'), + body('city').optional().trim().isLength({ max: 100 }).withMessage('City name too long'), + body('state').optional().trim().isLength({ max: 100 }).withMessage('State name too long'), + body('pincode').optional().isPostalCode('IN').withMessage('Invalid pincode') +]; + +// @route GET /api/issues +// @desc Get all issues with filters +// @access Public +router.get('/', [ + query('category').optional().isIn(['pothole', 'garbage', 'sewage', 'street_light', 'traffic_signal', 'road_damage', 'water_leak', 'illegal_dumping', 'other']), + query('status').optional().isIn(['reported', 'verified', 'assigned', 'in_progress', 'resolved', 'closed', 'rejected']), + query('priority').optional().isIn(['low', 'medium', 'high', 'critical']), + query('city').optional().trim(), + query('limit').optional().isInt({ min: 1, max: 100 }), + query('offset').optional().isInt({ min: 0 }), + query('sortBy').optional().isIn(['created_at', 'upvotes', 'priority', 'status']), + query('sortOrder').optional().isIn(['asc', 'desc']) +], authenticateOptional, async (req, res) => { + try { + const errors = validationResult(req); + if (!errors.isEmpty()) { + return res.status(400).json({ + success: false, + message: 'Validation failed', + errors: errors.array() + }); + } + + const filters = { + category: req.query.category, + status: req.query.status, + priority: req.query.priority, + city: req.query.city, + limit: parseInt(req.query.limit) || 20, + offset: parseInt(req.query.offset) || 0, + sortBy: req.query.sortBy || 'created_at', + sortOrder: req.query.sortOrder || 'desc' + }; + + // Add bounds filter if provided + if (req.query.bounds) { + try { + filters.bounds = JSON.parse(req.query.bounds); + } catch (error) { + return res.status(400).json({ + success: false, + message: 'Invalid bounds format' + }); + } + } + + const issues = await Issue.findAll(filters); + + res.json({ + success: true, + data: { + issues: issues.map(issue => issue.toJSON()), + pagination: { + limit: filters.limit, + offset: filters.offset, + total: issues.length + } + } + }); + } catch (error) { + logger.error('Get issues error:', error); + res.status(500).json({ + success: false, + message: 'Failed to fetch issues', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route GET /api/issues/nearby +// @desc Get nearby issues +// @access Public +router.get('/nearby', [ + query('latitude').isFloat({ min: -90, max: 90 }), + query('longitude').isFloat({ min: -180, max: 180 }), + query('radius').optional().isFloat({ min: 0.1, max: 50 }) +], async (req, res) => { + try { + const errors = validationResult(req); + if (!errors.isEmpty()) { + return res.status(400).json({ + success: false, + message: 'Validation failed', + errors: errors.array() + }); + } + + const { latitude, longitude, radius = 1 } = req.query; + const issues = await Issue.getNearbyIssues( + parseFloat(latitude), + parseFloat(longitude), + parseFloat(radius) + ); + + res.json({ + success: true, + data: { + issues: issues.map(issue => issue.toJSON()), + location: { latitude: parseFloat(latitude), longitude: parseFloat(longitude) }, + radius: parseFloat(radius) + } + }); + } catch (error) { + logger.error('Get nearby issues error:', error); + res.status(500).json({ + success: false, + message: 'Failed to fetch nearby issues', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route GET /api/issues/:id +// @desc Get issue by ID +// @access Public +router.get('/:id', authenticateOptional, async (req, res) => { + try { + const issue = await Issue.findById(req.params.id); + + if (!issue) { + return res.status(404).json({ + success: false, + message: 'Issue not found' + }); + } + + res.json({ + success: true, + data: { + issue: issue.toJSON() + } + }); + } catch (error) { + logger.error('Get issue error:', error); + res.status(500).json({ + success: false, + message: 'Failed to fetch issue', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route POST /api/issues +// @desc Create a new issue report +// @access Private/Anonymous +router.post('/', validateIssueCreation, upload.array('media', 5), async (req, res) => { + try { + const errors = validationResult(req); + if (!errors.isEmpty()) { + return res.status(400).json({ + success: false, + message: 'Validation failed', + errors: errors.array() + }); + } + + let reporterId = null; + let isAnonymous = false; + let deviceId = null; + + // Handle authentication + if (req.user) { + reporterId = req.user.id; + } else { + // Anonymous reporting + isAnonymous = true; + deviceId = req.headers['x-device-id']; + + if (!deviceId) { + return res.status(400).json({ + success: false, + message: 'Device ID required for anonymous reporting' + }); + } + } + + // Upload media files + let mediaUrls = []; + if (req.files && req.files.length > 0) { + for (const file of req.files) { + const url = await uploadToCloudStorage(file, 'issues'); + mediaUrls.push(url); + } + } + + // AI Detection on first image (if available) + let aiDetectionResults = null; + if (req.files && req.files.length > 0) { + const firstImage = req.files.find(file => file.mimetype.startsWith('image/')); + if (firstImage) { + try { + aiDetectionResults = await analyzeImageWithAI(firstImage.buffer); + } catch (aiError) { + logger.warn('AI detection failed:', aiError); + // Continue without AI results + } + } + } + + // Create issue + const issueData = { + reporterId, + title: req.body.title, + description: req.body.description, + category: req.body.category, + priority: req.body.priority || 'medium', + latitude: parseFloat(req.body.latitude), + longitude: parseFloat(req.body.longitude), + address: req.body.address, + city: req.body.city, + state: req.body.state, + pincode: req.body.pincode, + mediaUrls, + aiDetectionResults, + isAnonymous, + deviceId + }; + + const issue = await Issue.create(issueData); + + // Award points to user (if not anonymous) + if (reporterId) { + await User.addPoints( + reporterId, + 10, // Base points for reporting + 'issue_report', + `Reported ${req.body.category} issue`, + issue.id + ); + } + + logger.info(`New issue reported: ${issue.id} by ${reporterId || 'anonymous'}`); + + res.status(201).json({ + success: true, + message: 'Issue reported successfully', + data: { + issue: issue.toJSON() + } + }); + } catch (error) { + logger.error('Create issue error:', error); + res.status(500).json({ + success: false, + message: 'Failed to create issue', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route POST /api/issues/:id/upvote +// @desc Upvote an issue +// @access Private +router.post('/:id/upvote', authenticateToken, async (req, res) => { + try { + const issueId = req.params.id; + const userId = req.user.id; + + // Check if issue exists + const issue = await Issue.findById(issueId); + if (!issue) { + return res.status(404).json({ + success: false, + message: 'Issue not found' + }); + } + + // Check if user is trying to upvote their own issue + if (issue.reporterId === userId) { + return res.status(400).json({ + success: false, + message: 'Cannot upvote your own issue' + }); + } + + // Add upvote + await Issue.upvote(issueId, userId); + + // Award points to issue reporter (if not anonymous) + if (issue.reporterId) { + await User.addPoints( + issue.reporterId, + 2, // Points for receiving upvote + 'upvote_received', + `Issue upvoted by another user`, + issueId + ); + } + + logger.info(`Issue ${issueId} upvoted by user ${userId}`); + + res.json({ + success: true, + message: 'Issue upvoted successfully' + }); + } catch (error) { + logger.error('Upvote issue error:', error); + + if (error.message === 'User has already upvoted this issue') { + return res.status(400).json({ + success: false, + message: error.message + }); + } + + res.status(500).json({ + success: false, + message: 'Failed to upvote issue', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +// @route GET /api/issues/stats/overview +// @desc Get issue statistics +// @access Public +router.get('/stats/overview', async (req, res) => { + try { + const filters = {}; + + if (req.query.city) { + filters.city = req.query.city; + } + if (req.query.dateFrom) { + filters.dateFrom = req.query.dateFrom; + } + if (req.query.dateTo) { + filters.dateTo = req.query.dateTo; + } + + const stats = await Issue.getStats(filters); + + res.json({ + success: true, + data: { + stats + } + }); + } catch (error) { + logger.error('Get issue stats error:', error); + res.status(500).json({ + success: false, + message: 'Failed to fetch issue statistics', + error: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error' + }); + } +}); + +module.exports = router; \ No newline at end of file diff --git a/backend/src/utils/aiDetection.js b/backend/src/utils/aiDetection.js new file mode 100644 index 0000000..025230e --- /dev/null +++ b/backend/src/utils/aiDetection.js @@ -0,0 +1,250 @@ +const axios = require('axios'); +const logger = require('./logger'); + +// AI Service Configuration +const AI_SERVICE_URL = process.env.AI_SERVICE_URL || 'http://localhost:5000'; + +/** + * Analyze image with AI to detect civic issues + * @param {Buffer} imageBuffer - Image buffer + * @returns {Promise} - AI detection results + */ +const analyzeImageWithAI = async (imageBuffer) => { + try { + // Convert buffer to base64 + const base64Image = imageBuffer.toString('base64'); + + // Call AI service + const response = await axios.post(`${AI_SERVICE_URL}/analyze`, { + image: base64Image, + model: 'issue-detection' + }, { + timeout: 30000 // 30 second timeout + }); + + return response.data; + } catch (error) { + logger.error('AI detection error:', error); + + // Return fallback detection results + return { + detected_issues: [], + confidence: 0, + processing_time: 0, + error: 'AI service unavailable' + }; + } +}; + +/** + * Detect specific issue types in image + * @param {Buffer} imageBuffer - Image buffer + * @param {string} issueType - Type of issue to detect + * @returns {Promise} - Detection results for specific issue type + */ +const detectSpecificIssue = async (imageBuffer, issueType) => { + try { + const base64Image = imageBuffer.toString('base64'); + + const response = await axios.post(`${AI_SERVICE_URL}/detect`, { + image: base64Image, + issue_type: issueType + }, { + timeout: 30000 + }); + + return response.data; + } catch (error) { + logger.error(`AI detection error for ${issueType}:`, error); + return { + detected: false, + confidence: 0, + bounding_boxes: [], + error: 'AI service unavailable' + }; + } +}; + +/** + * Batch analyze multiple images + * @param {Array} imageBuffers - Array of image buffers + * @returns {Promise} - Array of detection results + */ +const batchAnalyzeImages = async (imageBuffers) => { + try { + const base64Images = imageBuffers.map(buffer => buffer.toString('base64')); + + const response = await axios.post(`${AI_SERVICE_URL}/batch-analyze`, { + images: base64Images, + model: 'issue-detection' + }, { + timeout: 60000 // 60 second timeout for batch processing + }); + + return response.data; + } catch (error) { + logger.error('Batch AI detection error:', error); + return imageBuffers.map(() => ({ + detected_issues: [], + confidence: 0, + processing_time: 0, + error: 'AI service unavailable' + })); + } +}; + +/** + * Get AI model status and health + * @returns {Promise} - Model status information + */ +const getAIModelStatus = async () => { + try { + const response = await axios.get(`${AI_SERVICE_URL}/status`, { + timeout: 5000 + }); + + return response.data; + } catch (error) { + logger.error('AI model status check error:', error); + return { + status: 'offline', + models: [], + error: 'AI service unavailable' + }; + } +}; + +/** + * Retrain AI model with new data + * @param {Array} trainingData - Training data + * @returns {Promise} - Training results + */ +const retrainModel = async (trainingData) => { + try { + const response = await axios.post(`${AI_SERVICE_URL}/retrain`, { + training_data: trainingData, + model_name: 'issue-detection' + }, { + timeout: 300000 // 5 minute timeout for training + }); + + return response.data; + } catch (error) { + logger.error('Model retraining error:', error); + throw error; + } +}; + +/** + * Validate AI detection results + * @param {Object} results - AI detection results + * @returns {Object} - Validated and cleaned results + */ +const validateDetectionResults = (results) => { + const validatedResults = { + detected_issues: [], + confidence: 0, + processing_time: 0, + timestamp: new Date().toISOString() + }; + + if (results && typeof results === 'object') { + // Validate detected issues + if (Array.isArray(results.detected_issues)) { + validatedResults.detected_issues = results.detected_issues.filter(issue => { + return issue && + typeof issue.type === 'string' && + typeof issue.confidence === 'number' && + issue.confidence >= 0 && + issue.confidence <= 1; + }); + } + + // Validate confidence score + if (typeof results.confidence === 'number') { + validatedResults.confidence = Math.max(0, Math.min(1, results.confidence)); + } + + // Validate processing time + if (typeof results.processing_time === 'number') { + validatedResults.processing_time = Math.max(0, results.processing_time); + } + } + + return validatedResults; +}; + +/** + * Categorize detected issues by type + * @param {Array} detectedIssues - Array of detected issues + * @returns {Object} - Categorized issues + */ +const categorizeDetectedIssues = (detectedIssues) => { + const categories = { + pothole: [], + garbage: [], + sewage: [], + street_light: [], + traffic_signal: [], + road_damage: [], + water_leak: [], + illegal_dumping: [], + other: [] + }; + + detectedIssues.forEach(issue => { + const category = issue.type.toLowerCase().replace(/\s+/g, '_'); + if (categories[category]) { + categories[category].push(issue); + } else { + categories.other.push(issue); + } + }); + + return categories; +}; + +/** + * Calculate overall issue severity score + * @param {Array} detectedIssues - Array of detected issues + * @returns {number} - Severity score (0-1) + */ +const calculateSeverityScore = (detectedIssues) => { + if (!Array.isArray(detectedIssues) || detectedIssues.length === 0) { + return 0; + } + + const severityWeights = { + pothole: 0.8, + sewage: 0.9, + water_leak: 0.7, + traffic_signal: 0.6, + street_light: 0.4, + garbage: 0.5, + illegal_dumping: 0.6, + road_damage: 0.7, + other: 0.3 + }; + + let totalScore = 0; + let totalWeight = 0; + + detectedIssues.forEach(issue => { + const weight = severityWeights[issue.type] || severityWeights.other; + totalScore += issue.confidence * weight; + totalWeight += weight; + }); + + return totalWeight > 0 ? totalScore / totalWeight : 0; +}; + +module.exports = { + analyzeImageWithAI, + detectSpecificIssue, + batchAnalyzeImages, + getAIModelStatus, + retrainModel, + validateDetectionResults, + categorizeDetectedIssues, + calculateSeverityScore +}; \ No newline at end of file diff --git a/backend/src/utils/fileUpload.js b/backend/src/utils/fileUpload.js new file mode 100644 index 0000000..ccf1d24 --- /dev/null +++ b/backend/src/utils/fileUpload.js @@ -0,0 +1,188 @@ +const AWS = require('aws-sdk'); +const { Storage } = require('@google-cloud/storage'); +const sharp = require('sharp'); +const { v4: uuidv4 } = require('uuid'); +const logger = require('./logger'); + +// Configure AWS S3 +const s3 = new AWS.S3({ + accessKeyId: process.env.AWS_ACCESS_KEY_ID, + secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY, + region: process.env.AWS_REGION +}); + +// Configure Google Cloud Storage +let gcs; +if (process.env.GOOGLE_CLOUD_PROJECT_ID) { + gcs = new Storage({ + projectId: process.env.GOOGLE_CLOUD_PROJECT_ID + }); +} + +/** + * Upload file to cloud storage (AWS S3 or Google Cloud Storage) + * @param {Object} file - Multer file object + * @param {string} folder - Folder name in storage + * @returns {Promise} - Public URL of uploaded file + */ +const uploadToCloudStorage = async (file, folder = 'uploads') => { + try { + const fileExtension = getFileExtension(file.originalname); + const fileName = `${folder}/${uuidv4()}${fileExtension}`; + + let buffer = file.buffer; + + // Process image files + if (file.mimetype.startsWith('image/')) { + buffer = await processImage(file.buffer); + } + + // Choose storage provider + if (process.env.AWS_S3_BUCKET) { + return await uploadToS3(buffer, fileName, file.mimetype); + } else if (process.env.GOOGLE_CLOUD_STORAGE_BUCKET) { + return await uploadToGCS(buffer, fileName, file.mimetype); + } else { + throw new Error('No cloud storage configured'); + } + } catch (error) { + logger.error('File upload error:', error); + throw error; + } +}; + +/** + * Upload file to AWS S3 + */ +const uploadToS3 = async (buffer, fileName, mimeType) => { + const params = { + Bucket: process.env.AWS_S3_BUCKET, + Key: fileName, + Body: buffer, + ContentType: mimeType, + ACL: 'public-read' + }; + + const result = await s3.upload(params).promise(); + return result.Location; +}; + +/** + * Upload file to Google Cloud Storage + */ +const uploadToGCS = async (buffer, fileName, mimeType) => { + const bucket = gcs.bucket(process.env.GOOGLE_CLOUD_STORAGE_BUCKET); + const file = bucket.file(fileName); + + await file.save(buffer, { + metadata: { + contentType: mimeType + }, + public: true + }); + + return `https://storage.googleapis.com/${process.env.GOOGLE_CLOUD_STORAGE_BUCKET}/${fileName}`; +}; + +/** + * Process image file (resize, optimize) + */ +const processImage = async (buffer) => { + try { + return await sharp(buffer) + .resize(1920, 1080, { + fit: 'inside', + withoutEnlargement: true + }) + .jpeg({ quality: 85 }) + .toBuffer(); + } catch (error) { + logger.warn('Image processing failed, using original:', error); + return buffer; + } +}; + +/** + * Get file extension from filename + */ +const getFileExtension = (filename) => { + const ext = filename.split('.').pop(); + return ext ? `.${ext}` : ''; +}; + +/** + * Delete file from cloud storage + */ +const deleteFromCloudStorage = async (url) => { + try { + if (url.includes('amazonaws.com')) { + return await deleteFromS3(url); + } else if (url.includes('storage.googleapis.com')) { + return await deleteFromGCS(url); + } + } catch (error) { + logger.error('File deletion error:', error); + throw error; + } +}; + +/** + * Delete file from AWS S3 + */ +const deleteFromS3 = async (url) => { + const key = url.split('/').pop(); + const params = { + Bucket: process.env.AWS_S3_BUCKET, + Key: key + }; + + await s3.deleteObject(params).promise(); +}; + +/** + * Delete file from Google Cloud Storage + */ +const deleteFromGCS = async (url) => { + const fileName = url.split('/').pop(); + const bucket = gcs.bucket(process.env.GOOGLE_CLOUD_STORAGE_BUCKET); + const file = bucket.file(fileName); + + await file.delete(); +}; + +/** + * Generate signed URL for private file access + */ +const generateSignedUrl = async (fileName, expiresIn = 3600) => { + try { + if (process.env.AWS_S3_BUCKET) { + const params = { + Bucket: process.env.AWS_S3_BUCKET, + Key: fileName, + Expires: expiresIn + }; + + return await s3.getSignedUrlPromise('getObject', params); + } else if (process.env.GOOGLE_CLOUD_STORAGE_BUCKET) { + const bucket = gcs.bucket(process.env.GOOGLE_CLOUD_STORAGE_BUCKET); + const file = bucket.file(fileName); + + const [signedUrl] = await file.getSignedUrl({ + action: 'read', + expires: Date.now() + expiresIn * 1000 + }); + + return signedUrl; + } + } catch (error) { + logger.error('Signed URL generation error:', error); + throw error; + } +}; + +module.exports = { + uploadToCloudStorage, + deleteFromCloudStorage, + generateSignedUrl, + processImage +}; \ No newline at end of file diff --git a/backend/src/utils/logger.js b/backend/src/utils/logger.js new file mode 100644 index 0000000..2695b1b --- /dev/null +++ b/backend/src/utils/logger.js @@ -0,0 +1,29 @@ +const winston = require('winston'); + +const logger = winston.createLogger({ + level: process.env.LOG_LEVEL || 'info', + format: winston.format.combine( + winston.format.timestamp({ + format: 'YYYY-MM-DD HH:mm:ss' + }), + winston.format.errors({ stack: true }), + winston.format.json() + ), + defaultMeta: { service: 'vighnview-backend' }, + transports: [ + new winston.transports.File({ filename: 'logs/error.log', level: 'error' }), + new winston.transports.File({ filename: 'logs/combined.log' }), + ], +}); + +// If we're not in production, log to the console as well +if (process.env.NODE_ENV !== 'production') { + logger.add(new winston.transports.Console({ + format: winston.format.combine( + winston.format.colorize(), + winston.format.simple() + ) + })); +} + +module.exports = logger; \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml index 11da81e..ff0d9db 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -1,39 +1,137 @@ -version: "3.8" +version: '3.8' + services: - db: + # PostgreSQL Database + postgres: image: postgres:15-alpine - env_file: .env + container_name: vighnview_postgres environment: - - POSTGRES_USER=${POSTGRES_USER} - - POSTGRES_PASSWORD=${POSTGRES_PASSWORD} - - POSTGRES_DB=${POSTGRES_DB} + POSTGRES_DB: vighnview + POSTGRES_USER: vighnview_user + POSTGRES_PASSWORD: vighnview_password volumes: - - pgdata:/var/lib/postgresql/data + - postgres_data:/var/lib/postgresql/data + - ./backend/migrations:/docker-entrypoint-initdb.d ports: - - "${POSTGRES_PORT}:5432" + - "5432:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U vighnview_user -d vighnview"] + interval: 10s + timeout: 5s + retries: 5 - backend: - build: ./backend - env_file: .env - depends_on: - - db + # Redis Cache + redis: + image: redis:7-alpine + container_name: vighnview_redis + command: redis-server --appendonly yes --requirepass redis_password + volumes: + - redis_data:/data ports: - - "${BACKEND_PORT}:5000" + - "6379:6379" + healthcheck: + test: ["CMD", "redis-cli", "--raw", "incr", "ping"] + interval: 10s + timeout: 3s + retries: 5 + + # Backend API + backend: + build: + context: ./backend + dockerfile: Dockerfile + container_name: vighnview_backend + environment: + NODE_ENV: development + DATABASE_URL: postgresql://vighnview_user:vighnview_password@postgres:5432/vighnview + REDIS_URL: redis://:redis_password@redis:6379 + JWT_SECRET: your-super-secret-jwt-key-here + JWT_REFRESH_SECRET: your-super-secret-refresh-key-here + PORT: 3000 volumes: - - ./backend:/usr/src/app - command: ["node", "index.js"] + - ./backend:/app + - /app/node_modules + - backend_uploads:/app/uploads + ports: + - "3000:3000" + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:3000/health"] + interval: 30s + timeout: 10s + retries: 3 + # Frontend Web App frontend: - build: ./frontend + build: + context: ./frontend + dockerfile: Dockerfile + container_name: vighnview_frontend + environment: + REACT_APP_API_URL: http://localhost:3000/api + volumes: + - ./frontend:/app + - /app/node_modules + ports: + - "3001:3000" depends_on: - backend + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:3000"] + interval: 30s + timeout: 10s + retries: 3 + + # AI Service + ai-service: + build: + context: ./ai-services + dockerfile: Dockerfile + container_name: vighnview_ai + environment: + FLASK_ENV: development + PORT: 5000 + volumes: + - ./ai-services:/app + - ai_models:/app/models ports: - - "3000:3000" + - "5000:5000" + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:5000/health"] + interval: 30s + timeout: 10s + retries: 3 + + # Nginx Reverse Proxy + nginx: + image: nginx:alpine + container_name: vighnview_nginx volumes: - - ./frontend:/usr/src/app - environment: - - NEXT_PUBLIC_BACKEND_URL=${NEXT_PUBLIC_BACKEND_URL} - command: ["npm", "run", "dev"] + - ./nginx/nginx.conf:/etc/nginx/nginx.conf + - ./nginx/ssl:/etc/nginx/ssl + ports: + - "80:80" + - "443:443" + depends_on: + - frontend + - backend + - ai-service + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost/health"] + interval: 30s + timeout: 10s + retries: 3 volumes: - pgdata: + postgres_data: + redis_data: + backend_uploads: + ai_models: + +networks: + default: + name: vighnview_network \ No newline at end of file diff --git a/frontend/Dockerfile b/frontend/Dockerfile new file mode 100644 index 0000000..c44b01a --- /dev/null +++ b/frontend/Dockerfile @@ -0,0 +1,37 @@ +# Multi-stage build for React app + +# Build stage +FROM node:18-alpine as build + +WORKDIR /app + +# Copy package files +COPY package*.json ./ + +# Install dependencies +RUN npm ci + +# Copy source code +COPY . . + +# Build the app +RUN npm run build + +# Production stage +FROM nginx:alpine + +# Copy built app from build stage +COPY --from=build /app/build /usr/share/nginx/html + +# Copy nginx configuration +COPY nginx.conf /etc/nginx/conf.d/default.conf + +# Expose port +EXPOSE 3000 + +# Health check +HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ + CMD curl -f http://localhost:3000 || exit 1 + +# Start nginx +CMD ["nginx", "-g", "daemon off;"] \ No newline at end of file diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 0000000..4385fb0 --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,62 @@ +{ + "name": "vighnview-frontend", + "version": "1.0.0", + "description": "VighnView Frontend - Smart Civic Monitoring Platform", + "private": true, + "dependencies": { + "@testing-library/jest-dom": "^5.17.0", + "@testing-library/react": "^13.4.0", + "@testing-library/user-event": "^14.5.1", + "react": "^18.2.0", + "react-dom": "^18.2.0", + "react-scripts": "5.0.1", + "react-router-dom": "^6.8.1", + "axios": "^1.6.2", + "react-query": "^3.39.3", + "react-hook-form": "^7.48.2", + "react-hot-toast": "^2.4.1", + "react-dropzone": "^14.2.3", + "react-map-gl": "^7.1.6", + "mapbox-gl": "^2.15.0", + "react-icons": "^4.12.0", + "framer-motion": "^10.16.16", + "recharts": "^2.8.0", + "date-fns": "^2.30.0", + "clsx": "^2.0.0", + "tailwind-merge": "^2.0.0", + "web-vitals": "^2.1.4" + }, + "devDependencies": { + "tailwindcss": "^3.3.6", + "autoprefixer": "^10.4.16", + "postcss": "^8.4.32", + "@types/react": "^18.2.45", + "@types/react-dom": "^18.2.18", + "typescript": "^4.9.5" + }, + "scripts": { + "start": "react-scripts start", + "build": "react-scripts build", + "test": "react-scripts test", + "eject": "react-scripts eject" + }, + "eslintConfig": { + "extends": [ + "react-app", + "react-app/jest" + ] + }, + "browserslist": { + "production": [ + ">0.2%", + "not dead", + "not op_mini all" + ], + "development": [ + "last 1 chrome version", + "last 1 firefox version", + "last 1 safari version" + ] + }, + "proxy": "http://localhost:3000" +} \ No newline at end of file diff --git a/frontend/src/App.js b/frontend/src/App.js new file mode 100644 index 0000000..cf954db --- /dev/null +++ b/frontend/src/App.js @@ -0,0 +1,110 @@ +import React from 'react'; +import { BrowserRouter as Router, Routes, Route } from 'react-router-dom'; +import { QueryClient, QueryClientProvider } from 'react-query'; +import { Toaster } from 'react-hot-toast'; +import { AuthProvider } from './contexts/AuthContext'; +import { ThemeProvider } from './contexts/ThemeContext'; + +// Components +import Navbar from './components/layout/Navbar'; +import Footer from './components/layout/Footer'; +import ProtectedRoute from './components/auth/ProtectedRoute'; + +// Pages +import Home from './pages/Home'; +import ReportIssue from './pages/ReportIssue'; +import IssuesList from './pages/IssuesList'; +import IssueDetail from './pages/IssueDetail'; +import Leaderboard from './pages/Leaderboard'; +import Profile from './pages/Profile'; +import Login from './pages/Login'; +import Register from './pages/Register'; +import Dashboard from './pages/Dashboard'; +import NotFound from './pages/NotFound'; + +// Create a client +const queryClient = new QueryClient({ + defaultOptions: { + queries: { + retry: 1, + refetchOnWindowFocus: false, + staleTime: 5 * 60 * 1000, // 5 minutes + }, + }, +}); + +function App() { + return ( + + + + +
+ + +
+ + {/* Public Routes */} + } /> + } /> + } /> + } /> + } /> + } /> + + {/* Protected Routes */} + + + + } /> + + + + } /> + + + + } /> + + {/* 404 Route */} + } /> + +
+ +
+ +
+ + + + + ); +} + +export default App; \ No newline at end of file diff --git a/frontend/src/contexts/AuthContext.js b/frontend/src/contexts/AuthContext.js new file mode 100644 index 0000000..7281c74 --- /dev/null +++ b/frontend/src/contexts/AuthContext.js @@ -0,0 +1,296 @@ +import React, { createContext, useContext, useReducer, useEffect } from 'react'; +import { authAPI } from '../services/api'; +import toast from 'react-hot-toast'; + +const AuthContext = createContext(); + +const initialState = { + user: null, + token: null, + refreshToken: null, + isAuthenticated: false, + isLoading: true, + isAnonymous: false +}; + +const authReducer = (state, action) => { + switch (action.type) { + case 'LOGIN_START': + return { + ...state, + isLoading: true + }; + case 'LOGIN_SUCCESS': + return { + ...state, + user: action.payload.user, + token: action.payload.tokens.accessToken, + refreshToken: action.payload.tokens.refreshToken, + isAuthenticated: true, + isLoading: false, + isAnonymous: action.payload.user.isAnonymous || false + }; + case 'LOGIN_ANONYMOUS': + return { + ...state, + user: action.payload.user, + token: action.payload.tokens.accessToken, + refreshToken: action.payload.tokens.refreshToken, + isAuthenticated: true, + isLoading: false, + isAnonymous: true + }; + case 'LOGOUT': + return { + ...initialState, + isLoading: false + }; + case 'UPDATE_USER': + return { + ...state, + user: { ...state.user, ...action.payload } + }; + case 'SET_LOADING': + return { + ...state, + isLoading: action.payload + }; + default: + return state; + } +}; + +export const AuthProvider = ({ children }) => { + const [state, dispatch] = useReducer(authReducer, initialState); + + // Check for existing session on app load + useEffect(() => { + const initAuth = async () => { + try { + const token = localStorage.getItem('accessToken'); + const refreshToken = localStorage.getItem('refreshToken'); + + if (token && refreshToken) { + // Set token in API headers + authAPI.defaults.headers.common['Authorization'] = `Bearer ${token}`; + + // Verify token and get user data + const response = await authAPI.get('/auth/me'); + + if (response.data.success) { + dispatch({ + type: 'LOGIN_SUCCESS', + payload: { + user: response.data.data.user, + tokens: { accessToken: token, refreshToken } + } + }); + } else { + // Token invalid, try refresh + await refreshAccessToken(); + } + } else { + dispatch({ type: 'SET_LOADING', payload: false }); + } + } catch (error) { + console.error('Auth initialization error:', error); + // Try to refresh token if available + const refreshToken = localStorage.getItem('refreshToken'); + if (refreshToken) { + try { + await refreshAccessToken(); + } catch (refreshError) { + // Refresh failed, clear storage + localStorage.removeItem('accessToken'); + localStorage.removeItem('refreshToken'); + dispatch({ type: 'SET_LOADING', payload: false }); + } + } else { + dispatch({ type: 'SET_LOADING', payload: false }); + } + } + }; + + initAuth(); + }, []); + + const refreshAccessToken = async () => { + try { + const refreshToken = localStorage.getItem('refreshToken'); + if (!refreshToken) throw new Error('No refresh token'); + + const response = await authAPI.post('/auth/refresh', { + refreshToken + }); + + if (response.data.success) { + const { accessToken, refreshToken: newRefreshToken } = response.data.data.tokens; + + // Update localStorage + localStorage.setItem('accessToken', accessToken); + localStorage.setItem('refreshToken', newRefreshToken); + + // Update API headers + authAPI.defaults.headers.common['Authorization'] = `Bearer ${accessToken}`; + + // Get user data + const userResponse = await authAPI.get('/auth/me'); + + if (userResponse.data.success) { + dispatch({ + type: 'LOGIN_SUCCESS', + payload: { + user: userResponse.data.data.user, + tokens: { accessToken, refreshToken: newRefreshToken } + } + }); + } + } + } catch (error) { + throw error; + } + }; + + const login = async (credentials) => { + try { + dispatch({ type: 'LOGIN_START' }); + + const response = await authAPI.post('/auth/login', credentials); + + if (response.data.success) { + const { user, tokens } = response.data.data; + + // Store tokens + localStorage.setItem('accessToken', tokens.accessToken); + localStorage.setItem('refreshToken', tokens.refreshToken); + + // Set token in API headers + authAPI.defaults.headers.common['Authorization'] = `Bearer ${tokens.accessToken}`; + + dispatch({ + type: 'LOGIN_SUCCESS', + payload: { user, tokens } + }); + + toast.success('Login successful!'); + return { success: true }; + } + } catch (error) { + const message = error.response?.data?.message || 'Login failed'; + toast.error(message); + dispatch({ type: 'SET_LOADING', payload: false }); + return { success: false, error: message }; + } + }; + + const register = async (userData) => { + try { + dispatch({ type: 'LOGIN_START' }); + + const response = await authAPI.post('/auth/register', userData); + + if (response.data.success) { + const { user, tokens } = response.data.data; + + // Store tokens + localStorage.setItem('accessToken', tokens.accessToken); + localStorage.setItem('refreshToken', tokens.refreshToken); + + // Set token in API headers + authAPI.defaults.headers.common['Authorization'] = `Bearer ${tokens.accessToken}`; + + dispatch({ + type: 'LOGIN_SUCCESS', + payload: { user, tokens } + }); + + toast.success('Registration successful!'); + return { success: true }; + } + } catch (error) { + const message = error.response?.data?.message || 'Registration failed'; + toast.error(message); + dispatch({ type: 'SET_LOADING', payload: false }); + return { success: false, error: message }; + } + }; + + const loginAnonymous = async (deviceId) => { + try { + dispatch({ type: 'LOGIN_START' }); + + const response = await authAPI.post('/auth/anonymous', { deviceId }); + + if (response.data.success) { + const { user, tokens } = response.data.data; + + // Store tokens + localStorage.setItem('accessToken', tokens.accessToken); + localStorage.setItem('refreshToken', tokens.refreshToken); + + // Set token in API headers + authAPI.defaults.headers.common['Authorization'] = `Bearer ${tokens.accessToken}`; + + dispatch({ + type: 'LOGIN_ANONYMOUS', + payload: { user, tokens } + }); + + return { success: true }; + } + } catch (error) { + const message = error.response?.data?.message || 'Anonymous login failed'; + toast.error(message); + dispatch({ type: 'SET_LOADING', payload: false }); + return { success: false, error: message }; + } + }; + + const logout = async () => { + try { + if (state.token) { + await authAPI.post('/auth/logout'); + } + } catch (error) { + console.error('Logout error:', error); + } finally { + // Clear storage + localStorage.removeItem('accessToken'); + localStorage.removeItem('refreshToken'); + + // Clear API headers + delete authAPI.defaults.headers.common['Authorization']; + + dispatch({ type: 'LOGOUT' }); + toast.success('Logged out successfully'); + } + }; + + const updateUser = (userData) => { + dispatch({ type: 'UPDATE_USER', payload: userData }); + }; + + const value = { + ...state, + login, + register, + loginAnonymous, + logout, + updateUser, + refreshAccessToken + }; + + return ( + + {children} + + ); +}; + +export const useAuth = () => { + const context = useContext(AuthContext); + if (!context) { + throw new Error('useAuth must be used within an AuthProvider'); + } + return context; +}; \ No newline at end of file diff --git a/frontend/src/pages/Home.js b/frontend/src/pages/Home.js new file mode 100644 index 0000000..72151e6 --- /dev/null +++ b/frontend/src/pages/Home.js @@ -0,0 +1,451 @@ +import React, { useState, useEffect } from 'react'; +import { Link } from 'react-router-dom'; +import { motion } from 'framer-motion'; +import { + FaMapMarkerAlt, + FaCamera, + FaTrophy, + FaUsers, + FaChartLine, + FaMobileAlt, + FaRobot, + FaSatelliteDish, + FaDrone +} from 'react-icons/fa'; +import { issuesAPI } from '../services/api'; +import { useAuth } from '../contexts/AuthContext'; + +const Home = () => { + const { isAuthenticated, user } = useAuth(); + const [stats, setStats] = useState(null); + const [recentIssues, setRecentIssues] = useState([]); + const [isLoading, setIsLoading] = useState(true); + + useEffect(() => { + const fetchData = async () => { + try { + const [statsResponse, issuesResponse] = await Promise.all([ + issuesAPI.getStats(), + issuesAPI.getIssues({ limit: 6, sortBy: 'created_at', sortOrder: 'desc' }) + ]); + + if (statsResponse.data.success) { + setStats(statsResponse.data.data.stats); + } + + if (issuesResponse.data.success) { + setRecentIssues(issuesResponse.data.data.issues); + } + } catch (error) { + console.error('Error fetching home data:', error); + } finally { + setIsLoading(false); + } + }; + + fetchData(); + }, []); + + const features = [ + { + icon: , + title: "Report Issues", + description: "Easily report civic issues with photos, location, and AI-powered detection", + color: "bg-blue-500" + }, + { + icon: , + title: "Gamification", + description: "Earn points, unlock achievements, and compete on leaderboards", + color: "bg-yellow-500" + }, + { + icon: , + title: "Track Progress", + description: "Monitor the status of your reported issues in real-time", + color: "bg-green-500" + }, + { + icon: , + title: "Community", + description: "Join thousands of citizens making their cities better", + color: "bg-purple-500" + } + ]; + + const phases = [ + { + phase: "Phase 1", + title: "Civic Reporting App", + description: "Mobile app and website for issue reporting with AI detection", + icon: , + status: "completed", + features: ["Issue Reporting", "AI Detection", "Gamification", "Progress Tracking"] + }, + { + phase: "Phase 2", + title: "Camera Network", + description: "Integration with traffic cameras and police van feeds", + icon: , + status: "upcoming", + features: ["CCTV Integration", "Police Van Cameras", "Dashcam Integration", "Local CCTV"] + }, + { + phase: "Phase 3", + title: "Drone Surveillance", + description: "Automated drone network for comprehensive monitoring", + icon: , + status: "upcoming", + features: ["Self-Manufactured Drones", "Market Drones", "On-Demand Scanning"] + }, + { + phase: "Phase 4", + title: "Satellite Imagery", + description: "High-definition satellite data for large-scale analysis", + icon: , + status: "upcoming", + features: ["ISRO Integration", "Change Detection", "GIS Mapping"] + }, + { + phase: "Phase 5", + title: "Data Integration", + description: "Centralized platform with real-time dashboards", + icon: , + status: "upcoming", + features: ["Centralized Data", "Real-time Dashboards", "Public Portal"] + }, + { + phase: "Phase 6", + title: "Smart Governance", + description: "Full automation with predictive analytics", + icon: , + status: "upcoming", + features: ["AI Predictions", "IoT Sensors", "Automated Workflows"] + } + ]; + + const getStatusColor = (status) => { + switch (status) { + case 'completed': return 'bg-green-100 text-green-800 border-green-200'; + case 'current': return 'bg-blue-100 text-blue-800 border-blue-200'; + case 'upcoming': return 'bg-gray-100 text-gray-600 border-gray-200'; + default: return 'bg-gray-100 text-gray-600 border-gray-200'; + } + }; + + return ( +
+ {/* Hero Section */} +
+
+ +

+ VighnView +

+

+ Smart Civic Monitoring Platform +

+

+ Transform civic issue reporting from reactive to proactive through AI-powered detection, + gamification, and multi-source data integration. Making cities smarter, one report at a time! +

+ +
+ {isAuthenticated ? ( + <> + + Report an Issue + + + View Dashboard + + + ) : ( + <> + + Get Started + + + Sign In + + + )} +
+ +
+
+ + {/* Stats Section */} + {stats && ( +
+
+ +
+
+ {stats.total_issues || 0} +
+
Issues Reported
+
+
+
+ {stats.resolved || 0} +
+
Issues Resolved
+
+
+
+ {stats.potholes || 0} +
+
Potholes Fixed
+
+
+
+ {stats.garbage || 0} +
+
Garbage Cleaned
+
+ +
+
+ )} + + {/* Features Section */} +
+
+ +

+ Why Choose VighnView? +

+

+ Our platform combines cutting-edge technology with community engagement + to create a comprehensive civic monitoring solution. +

+ + +
+ {features.map((feature, index) => ( + +
+ {feature.icon} +
+

+ {feature.title} +

+

+ {feature.description} +

+ + ))} +
+
+
+ + {/* Recent Issues Section */} + {recentIssues.length > 0 && ( +
+
+ +

+ Recent Issues +

+

+ See what your community is reporting +

+ + +
+ {recentIssues.map((issue, index) => ( + +
+ + {issue.status.replace('_', ' ')} + + + {new Date(issue.createdAt).toLocaleDateString()} + +
+ +

+ {issue.title} +

+ +

+ {issue.description || 'No description provided'} +

+ +
+ + {issue.category.replace('_', ' ')} + + + View Details → + +
+ + ))} +
+ +
+ + View All Issues + +
+
+
+ )} + + {/* Roadmap Section */} +
+
+ +

+ Development Roadmap +

+

+ Our journey from basic reporting to full smart governance automation +

+ + +
+ {phases.map((phase, index) => ( + +
+
+ {phase.icon} +
+
+
{phase.phase}
+

{phase.title}

+
+
+ +

{phase.description}

+ +
+
+ {phase.status} +
+
+ +
+ {phase.features.map((feature, featureIndex) => ( +
+
+ {feature} +
+ ))} +
+ + ))} +
+
+
+ + {/* CTA Section */} +
+
+ +

+ Ready to Make a Difference? +

+

+ Join thousands of citizens who are already using VighnView to improve their communities. +

+ + {!isAuthenticated && ( +
+ + Start Reporting Issues + + + View Leaderboard + +
+ )} + +
+
+
+ ); +}; + +export default Home; \ No newline at end of file diff --git a/frontend/src/pages/ReportIssue.js b/frontend/src/pages/ReportIssue.js new file mode 100644 index 0000000..fdb2b9e --- /dev/null +++ b/frontend/src/pages/ReportIssue.js @@ -0,0 +1,528 @@ +import React, { useState, useRef } from 'react'; +import { useNavigate } from 'react-router-dom'; +import { useForm } from 'react-hook-form'; +import { useDropzone } from 'react-dropzone'; +import { motion } from 'framer-motion'; +import { + FaCamera, + FaMapMarkerAlt, + FaUpload, + FaTrash, + FaSpinner, + FaCheck, + FaExclamationTriangle +} from 'react-icons/fa'; +import toast from 'react-hot-toast'; +import { issuesAPI, getCurrentLocation, reverseGeocode } from '../services/api'; +import { useAuth } from '../contexts/AuthContext'; + +const ReportIssue = () => { + const navigate = useNavigate(); + const { user, isAuthenticated } = useAuth(); + const [isSubmitting, setIsSubmitting] = useState(false); + const [location, setLocation] = useState(null); + const [isGettingLocation, setIsGettingLocation] = useState(false); + const [uploadedFiles, setUploadedFiles] = useState([]); + const [aiAnalysis, setAiAnalysis] = useState(null); + const [isAnalyzing, setIsAnalyzing] = useState(false); + + const fileInputRef = useRef(null); + + const { + register, + handleSubmit, + formState: { errors }, + setValue, + watch, + reset + } = useForm({ + defaultValues: { + title: '', + description: '', + category: '', + priority: 'medium', + latitude: '', + longitude: '', + address: '', + city: '', + state: '', + pincode: '' + } + }); + + const categories = [ + { value: 'pothole', label: 'Pothole', icon: '🕳️' }, + { value: 'garbage', label: 'Garbage', icon: '🗑️' }, + { value: 'sewage', label: 'Sewage', icon: '💧' }, + { value: 'street_light', label: 'Street Light', icon: '💡' }, + { value: 'traffic_signal', label: 'Traffic Signal', icon: '🚦' }, + { value: 'road_damage', label: 'Road Damage', icon: '🛣️' }, + { value: 'water_leak', label: 'Water Leak', icon: '💧' }, + { value: 'illegal_dumping', label: 'Illegal Dumping', icon: '🚛' }, + { value: 'other', label: 'Other', icon: '📋' } + ]; + + const priorities = [ + { value: 'low', label: 'Low', color: 'text-green-600' }, + { value: 'medium', label: 'Medium', color: 'text-yellow-600' }, + { value: 'high', label: 'High', color: 'text-orange-600' }, + { value: 'critical', label: 'Critical', color: 'text-red-600' } + ]; + + const getCurrentLocationHandler = async () => { + setIsGettingLocation(true); + try { + const position = await getCurrentLocation(); + setLocation(position); + + setValue('latitude', position.latitude); + setValue('longitude', position.longitude); + + // Get address from coordinates + const addressData = await reverseGeocode(position.latitude, position.longitude); + setValue('address', addressData.address); + setValue('city', addressData.city); + setValue('state', addressData.state); + setValue('pincode', addressData.pincode); + + toast.success('Location detected successfully!'); + } catch (error) { + console.error('Location error:', error); + toast.error('Failed to get location. Please enter manually.'); + } finally { + setIsGettingLocation(false); + } + }; + + const onDrop = (acceptedFiles) => { + const newFiles = acceptedFiles.map(file => ({ + file, + id: Math.random().toString(36).substr(2, 9), + preview: URL.createObjectURL(file), + uploading: false, + uploaded: false + })); + + setUploadedFiles(prev => [...prev, ...newFiles]); + + // Analyze first image with AI + if (acceptedFiles.length > 0 && acceptedFiles[0].type.startsWith('image/')) { + analyzeImageWithAI(acceptedFiles[0]); + } + }; + + const { getRootProps, getInputProps, isDragActive } = useDropzone({ + onDrop, + accept: { + 'image/*': ['.jpeg', '.jpg', '.png', '.gif'], + 'video/*': ['.mp4', '.mov', '.avi'] + }, + maxFiles: 5, + maxSize: 10 * 1024 * 1024 // 10MB + }); + + const removeFile = (fileId) => { + setUploadedFiles(prev => { + const file = prev.find(f => f.id === fileId); + if (file) { + URL.revokeObjectURL(file.preview); + } + return prev.filter(f => f.id !== fileId); + }); + }; + + const analyzeImageWithAI = async (file) => { + setIsAnalyzing(true); + try { + const formData = new FormData(); + formData.append('image', file); + + // This would call your AI service + // const response = await fetch('/api/ai/analyze', { + // method: 'POST', + // body: formData + // }); + // const result = await response.json(); + + // Simulate AI analysis for demo + setTimeout(() => { + const mockAnalysis = { + detected_issues: [ + { type: 'pothole', confidence: 0.85 }, + { type: 'garbage', confidence: 0.72 } + ], + confidence: 0.78, + processing_time: 1.2 + }; + setAiAnalysis(mockAnalysis); + setIsAnalyzing(false); + toast.success('AI analysis completed!'); + }, 2000); + + } catch (error) { + console.error('AI analysis error:', error); + setIsAnalyzing(false); + toast.error('AI analysis failed'); + } + }; + + const onSubmit = async (data) => { + if (!isAuthenticated && !user?.isAnonymous) { + toast.error('Please login or use anonymous mode to report issues'); + return; + } + + if (uploadedFiles.length === 0) { + toast.error('Please upload at least one photo or video'); + return; + } + + setIsSubmitting(true); + try { + const issueData = { + ...data, + media: uploadedFiles.map(f => f.file) + }; + + const response = await issuesAPI.createIssue(issueData); + + if (response.data.success) { + toast.success('Issue reported successfully!'); + reset(); + setUploadedFiles([]); + setAiAnalysis(null); + navigate(`/issues/${response.data.data.issue.id}`); + } + } catch (error) { + console.error('Report issue error:', error); + const message = error.response?.data?.message || 'Failed to report issue'; + toast.error(message); + } finally { + setIsSubmitting(false); + } + }; + + return ( +
+ +
+

+ Report a Civic Issue +

+

+ Help improve your community by reporting issues that need attention. +

+
+ +
+ {/* Basic Information */} +
+

+ + Basic Information +

+ +
+ + + {errors.title && ( +

{errors.title.message}

+ )} +
+ +
+ +