Initial Commit

.gitignore

@@ -0,0 +1,53 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environment variables
+.env
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Model files
+#*.pkl
+#*.h5
+#*.model
+
+# Logs
+*.log
+logs/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Database
+*.db
+*.sqlite3
+
+demo_ai_model.py

README.md

@@ -1,10 +1,434 @@
----
-title: Code Strom
-emoji: 📉
-colorFrom: red
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Smart Parking System - AI & Payment Module
+
+An intelligent parking management system with AI-powered slot recommendations and integrated payment processing in sandbox mode.
+
+## 🚀 Features
+
+### 1. AI-Powered Slot Recommendation
+- **Basic Classification Model** using Random Forest
+- Considers multiple factors:
+  - **Proximity** to user location (Haversine distance calculation)
+  - **User feedback** scores (historical ratings)
+  - **Slot popularity** (booking frequency and usage patterns)
+  - **Real-time availability**
+  - **Price factors**
+- Smart ranking algorithm with weighted scoring
+- Continuous learning from user feedback
+
+### 2. Payment Integration (Sandbox Mode)
+- **Razorpay** integration in test/sandbox mode
+- Payment order creation
+- Payment link generation
+- Payment verification with signature validation
+- Refund support
+- Payment simulation for development/testing
+- Complete transaction tracking
+
+### 3. Database Integration
+- **PHP API Backend** at `https://aadarshsenapati.in/api/api.php`
+- Real-time parking slot data
+- User registration and management
+- Booking system with unique UIDs
+- Payment status tracking
+- Feedback storage and retrieval
+- Complete CRUD operations
+
+### 4. Feedback System
+- Collect user ratings (1-5 stars)
+- Track user satisfaction metrics
+- Store feedback in database
+- Use feedback for AI model improvement
+- Automated model retraining with new data
+- Feedback analytics and reporting
+
+## 📁 Project Structure
+
+```
+CodeStrom/
+├── ai_model/
+│   └── parking_slot_classifier.py    # ML model for slot recommendation
+├── backend/
+│   ├── main.py                       # FastAPI backend API
+│   ├── payment_service.py            # Razorpay payment integration
+│   └── database_api.py               # Database API client
+├── requirements.txt                   # Project dependencies
+├── test_system.py                    # Comprehensive test suite
+├── test_database.py                  # Database integration tests
+├── .env.example                      # Environment variables template
+├── .gitignore
+├── render.yaml                       # Render deployment config
+├── railway.json                      # Railway deployment config
+└── vercel.json                       # Vercel deployment config
+```
+
+## 🛠️ Installation & Setup
+
+### Prerequisites
+- Python 3.11+
+- pip (Python package manager)
+- Razorpay account with test credentials
+
+### Step 1: Install Dependencies
+```bash
+# Navigate to project directory
+cd CodeStrom
+
+# Install required packages
+pip install -r requirements.txt
+```
+
+### Step 2: Configure Environment
+```bash
+# Create .env file from template
+copy .env.example .env
+
+# Edit .env and add your Razorpay test credentials
+# RAZORPAY_KEY_ID=rzp_test_RYlqJbc24Sl6jz
+# RAZORPAY_KEY_SECRET=bghQe0L7iort9vmqb6Jlf8Ec
+```
+
+### Step 3: Test Database Connection
+```bash
+# Test database API integration
+python test_database.py
+```
+
+### Step 4: Test the Complete System
+```bash
+# Run comprehensive test suite
+python test_system.py
+```
+
+### Step 5: Start Development Server
+```bash
+# Start FastAPI backend
+uvicorn backend.main:app --reload --host 0.0.0.0 --port 8000
+
+# API will be available at: http://localhost:8000
+# Interactive docs at: http://localhost:8000/docs
+# Database test: http://localhost:8000/api/test-database
+```
+
+## 🔑 Configuration
+
+### Database API
+- **Endpoint:** `https://aadarshsenapati.in/api/api.php`
+- Managed by team member - handles all database operations
+- Supports: Users, Parking Lots, Bookings, Payments, Feedback
+
+### Razorpay Test Credentials
+```env
+RAZORPAY_KEY_ID=rzp_test_RYlqJbc24Sl6jz
+RAZORPAY_KEY_SECRET=bghQe0L7iort9vmqb6Jlf8Ec
+```
+
+These are **sandbox/test mode** credentials. Use Razorpay test cards for testing:
+- **Card Number:** 4111 1111 1111 1111
+- **CVV:** Any 3 digits
+- **Expiry:** Any future date
+- **OTP:** 123456 (for test mode)
+
+## 🚀 Deployment
+
+### Option 1: Render
+```yaml
+# render.yaml is already configured
+# Steps:
+1. Create account on render.com
+2. Connect GitHub repository
+3. Create new Web Service
+4. Render will auto-detect render.yaml
+5. Add environment variables (RAZORPAY keys)
+6. Deploy!
+```
+
+### Option 2: Railway
+```bash
+# Install Railway CLI
+npm i -g @railway/cli
+
+# Login and deploy
+railway login
+railway init
+railway up
+```
+
+### Option 3: Vercel (Serverless)
+```bash
+# Install Vercel CLI
+npm i -g vercel
+
+# Deploy
+vercel --prod
+```
+
+### Post-Deployment
+- Test all API endpoints
+- Verify payment integration
+- Monitor error logs
+- Set up health checks
+
+## 📡 API Endpoints
+
+### Database & Health
+```bash
+GET  /                      # Health check
+GET  /api/test-database     # Test database connection
+```
+
+### AI Recommendations
+```bash
+POST /api/recommend-slots
+{
+  "user_location": {"latitude": 28.6139, "longitude": 77.2090},
+  "slots": [],  # Optional - if empty, fetches from database
+  "top_k": 3
+}
+```
+
+### Booking Management
+```bash
+POST /api/payment/create-order
+{
+  "booking_id": "custom_id",  # Optional
+  "slot_id": "1",             # Database slot ID or name
+  "amount": 100.0,
+  "duration_hours": 2,
+  "vehicle_number": "DL01AB1234",
+  "customer_name": "John Doe",
+  "customer_contact": "+919876543210",
+  "customer_email": "john@example.com"
+}
+
+GET /api/booking/{booking_uid}  # Get booking details
+```
+
+### Payment Operations
+```bash
+POST /api/payment/create-link     # Create payment link
+POST /api/payment/verify          # Verify payment signature
+POST /api/payment/simulate        # Simulate payment (testing)
+  ?booking_uid=ABC12345&amount=100
+```
+
+### Feedback System
+```bash
+POST /api/feedback
+{
+  "booking_id": "ABC12345",  # Booking UID from database
+  "slot_id": "A1",
+  "rating": 4.5,
+  "comment": "Great spot!",
+  "user_satisfaction": true
+}
+
+GET /api/feedback/stats  # Get feedback statistics
+```
+
+### AI Model Management
+```bash
+POST /api/retrain-model  # Retrain model with feedback data
+```
+
+## 🤖 AI Model Details
+
+### Features Used
+1. **Proximity Score** (0-1): Distance from user to parking slot
+2. **Average Feedback** (0-1): Normalized user ratings
+3. **Popularity Score** (0-1): Historical booking frequency
+4. **Availability** (0-1): Current availability status
+5. **Price Factor** (0-1): Normalized pricing
+
+### Algorithm
+- **Random Forest Classifier** (100 estimators)
+- Trained on user satisfaction data
+- Predicts probability of user satisfaction
+- Falls back to weighted scoring if not trained
+
+### Continuous Improvement
+- Collects feedback after each booking
+- Retrains model periodically
+- Updates slot rankings based on new data
+
+## 💳 Payment Flow
+
+1. User books a slot via WhatsApp
+2. Backend creates Razorpay order
+3. Payment link sent to user
+4. User completes payment
+5. Webhook verifies payment
+6. Booking confirmed
+7. Feedback collected after use
+
+## 🧪 Testing
+
+### Pre-Production Testing
+
+#### 1. Run Test Suite
+```bash
+python test_system.py
+```
+This will test:
+- ✅ AI model training and predictions
+- ✅ Payment service (simulated and real)
+- ✅ Full integration flow
+- ✅ Feedback collection
+- ✅ Model retraining
+
+#### 2. API Testing with Interactive Docs
+```bash
+# Start server
+uvicorn backend.main:app --reload --port 8000
+
+# Open browser to:
+http://localhost:8000/docs
+```
+
+Test each endpoint:
+- `/api/recommend-slots` - AI recommendations
+- `/api/payment/create-order` - Create payment
+- `/api/payment/simulate` - Simulate payment
+- `/api/feedback` - Submit feedback
+- `/api/retrain-model` - Retrain AI model
+
+#### 3. Manual Testing Scenarios
+
+**Scenario 1: Find Best Parking Spot**
+```bash
+curl -X POST "http://localhost:8000/api/recommend-slots" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_location": {"latitude": 28.6139, "longitude": 77.2090},
+    "slots": [
+      {
+        "slot_id": "A1",
+        "latitude": 28.6145,
+        "longitude": 77.2095,
+        "avg_feedback": 4.5,
+        "popularity_score": 0.8,
+        "is_available": true,
+        "price_factor": 0.7,
+        "price_per_hour": 50.0
+      }
+    ],
+    "top_k": 3
+  }'
+```
+
+**Scenario 2: Create Payment Order**
+```bash
+curl -X POST "http://localhost:8000/api/payment/create-order" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "booking_id": "BKG001",
+    "slot_id": "A1",
+    "amount": 100.0,
+    "duration_hours": 2,
+    "vehicle_number": "DL01AB1234",
+    "customer_name": "Test User",
+    "customer_contact": "+919876543210",
+    "customer_email": "test@example.com"
+  }'
+```
+
+**Scenario 3: Simulate Payment**
+```bash
+curl -X POST "http://localhost:8000/api/payment/simulate?booking_id=BKG001&amount=100"
+```
+
+**Scenario 4: Submit Feedback**
+```bash
+curl -X POST "http://localhost:8000/api/feedback" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "booking_id": "BKG001",
+    "slot_id": "A1",
+    "rating": 5.0,
+    "comment": "Great spot!",
+    "user_satisfaction": true
+  }'
+```
+
+### Post-Production Testing
+
+#### 1. Health Check
+```bash
+curl http://your-deployed-url.com/
+```
+
+#### 2. Load Testing
+```bash
+# Install hey (load testing tool)
+# Run load test
+hey -n 1000 -c 10 http://your-deployed-url.com/api/recommend-slots
+```
+
+#### 3. Monitor Performance
+- Response times < 500ms
+- Error rate < 1%
+- Model accuracy > 80%
+- Payment success rate > 98%
+
+#### 4. Test Payment Integration
+- Test with Razorpay test cards
+- Verify payment webhooks
+- Check payment verification
+- Test refund functionality
+
+## 📊 Next Steps
+
+### Phase 1: Core Implementation ✅
+- [x] AI classification model with feedback learning
+- [x] Razorpay payment integration (sandbox)
+- [x] FastAPI backend with all endpoints
+- [x] Comprehensive testing suite
+- [x] Deployment configurations
+
+### Phase 2: Testing & Validation (Current)
+- [ ] Run local test suite (`python test_system.py`)
+- [ ] Test all API endpoints with Postman/curl
+- [ ] Verify payment flows with test credentials
+- [ ] Load testing and performance optimization
+- [ ] Security testing and validation
+
+### Phase 3: Production Deployment
+- [ ] Deploy backend to Render/Railway
+- [ ] Configure production environment variables
+- [ ] Set up monitoring and logging
+- [ ] Configure auto-scaling
+- [ ] Set up backup and disaster recovery
+
+### Phase 4: Integration & Enhancement
+- [ ] Connect to real parking database
+- [ ] Integrate with external systems (to be handled by other teams)
+- [ ] Add real-time slot updates
+- [ ] Implement caching for performance
+- [ ] Add analytics dashboard
+
+### Phase 5: Continuous Improvement
+- [ ] Collect production feedback data
+- [ ] Retrain AI model with real data
+- [ ] A/B test different recommendation algorithms
+- [ ] Optimize model performance
+- [ ] Add advanced features based on usage patterns
+
+## 🤝 Integration Points
+
+This module provides REST APIs that can be integrated with:
+- **Frontend applications** (Web/Mobile)
+- **WhatsApp/Telegram bots** (handled by other teams)
+- **Admin dashboards**
+- **IoT parking sensors**
+- **Third-party booking systems**
+
+## 📄 License
+
+MIT License
+
+## 📧 Support
+
+For issues and questions, please create an issue in the repository.
+
+---
+
+**AI + Payment Module** | Smart Parking System v1.0

check_slots.py

@@ -0,0 +1,59 @@
+"""
+Quick script to check what's in the database
+"""
+from backend.database_api import DatabaseAPI
+import json
+
+api = DatabaseAPI()
+
+print("=" * 60)
+print("CHECKING DATABASE CONTENT")
+print("=" * 60)
+
+# Check parking lots
+print("\n1️⃣  PARKING LOTS:")
+lots_result = api.get_parking_lots()
+print(f"Status: {lots_result['status']}")
+if lots_result.get('data'):
+    for lot in lots_result['data']:
+        print(f"\n📍 Lot {lot.get('lot_id')}: {lot.get('lot_name')}")
+        print(f"   Location: {lot.get('address')}")
+        print(f"   Coordinates: ({lot.get('latitude')}, {lot.get('longitude')})")
+        print(f"   Total Slots: {lot.get('total_slots')}")
+        print(f"   Raw data: {json.dumps(lot, indent=2)}")
+else:
+    print("No parking lots found")
+
+# Check available slots for lot 1
+print("\n" + "=" * 60)
+print("2️⃣  AVAILABLE SLOTS FOR LOT 1:")
+slots_result = api.get_available_slots(1)
+print(f"Status: {slots_result['status']}")
+print(f"Message: {slots_result.get('message', 'N/A')}")
+if slots_result.get('data'):
+    print(f"Found {len(slots_result['data'])} slots:")
+    for slot in slots_result['data']:
+        print(f"\n🅿️  Slot {slot.get('id')}: {slot.get('slot_number')}")
+        print(f"   Parking Lot ID: {slot.get('parking_lot_id')}")
+        print(f"   Vehicle Type: {slot.get('vehicle_type')}")
+        print(f"   Available: {slot.get('is_available')}")
+        print(f"   Active: {slot.get('is_active')}")
+        print(f"   Hourly Rate: ₹{slot.get('hourly_rate')}")
+        print(f"   Raw data: {json.dumps(slot, indent=2)}")
+else:
+    print("No available slots found")
+    print(f"Full response: {json.dumps(slots_result, indent=2)}")
+
+# Check all available slots
+print("\n" + "=" * 60)
+print("3️⃣  ALL AVAILABLE SLOTS:")
+all_slots = api.get_all_available_slots()
+print(f"Status: {all_slots['status']}")
+print(f"Total Lots: {all_slots.get('total_lots', 0)}")
+print(f"Total Slots: {all_slots.get('total_slots', 0)}")
+if all_slots.get('data'):
+    for slot in all_slots['data'][:3]:  # Show first 3
+        print(f"\n🅿️  Slot: {slot.get('slot_number')} ({slot.get('lot_name')})")
+        print(f"   Vehicle: {slot.get('vehicle_type')}, Rate: ₹{slot.get('hourly_rate')}/hr")
+
+print("\n" + "=" * 60)

demo_ai_model.py

@@ -0,0 +1,194 @@
+"""
+Interactive AI Model Demo - Test the Recommendation System
+"""
+from backend.database_api import DatabaseAPI, transform_parking_lots_for_ai
+from ai_model.parking_slot_classifier import ParkingSlotClassifier
+import json
+
+print("=" * 70)
+print("🤖 SMART PARKING AI MODEL - INTERACTIVE DEMO")
+print("=" * 70)
+
+# Initialize
+api = DatabaseAPI()
+classifier = ParkingSlotClassifier()
+
+# Load or train model
+try:
+    classifier.load_model('parking_model.pkl')
+    print("\n✅ AI Model loaded successfully")
+except:
+    print("\n🔄 Training new AI model...")
+    from ai_model.parking_slot_classifier import generate_training_data
+    training_data, labels = generate_training_data(500)
+    classifier.train(training_data, labels)
+    classifier.save_model('parking_model.pkl')
+    print("✅ Model trained and saved")
+
+print("\n" + "=" * 70)
+print("📍 STEP 1: GET USER LOCATION")
+print("=" * 70)
+
+# Example user location (SRM University AP)
+user_lat = 16.4645
+user_lon = 80.5076
+
+print(f"User Location: ({user_lat}, {user_lon})")
+print(f"Location: Near SRM University AP, Guntur")
+
+print("\n" + "=" * 70)
+print("🅿️  STEP 2: FETCH AVAILABLE PARKING SLOTS FROM DATABASE")
+print("=" * 70)
+
+# Get slots from database
+slots_result = api.get_all_available_slots()
+
+if slots_result['status'] == 'success':
+    raw_slots = slots_result.get('data', [])
+    print(f"✅ Found {len(raw_slots)} available slot(s) in database")
+    
+    # Show raw data
+    print(f"\n📊 Raw Database Data:")
+    for slot in raw_slots:
+        print(f"  - Slot {slot.get('slot_number')} at {slot.get('lot_name')}")
+        print(f"    Type: {slot.get('vehicle_type')}, Rate: ₹{slot.get('hourly_rate')}/hr")
+    
+    print("\n" + "=" * 70)
+    print("🔄 STEP 3: TRANSFORM DATA FOR AI MODEL")
+    print("=" * 70)
+    
+    # Transform to AI format
+    ai_slots = transform_parking_lots_for_ai(raw_slots)
+    
+    print(f"✅ Transformed {len(ai_slots)} slots for AI processing")
+    print(f"\n📊 AI Model Input Features:")
+    
+    if ai_slots:
+        sample = ai_slots[0]
+        print(f"  Slot ID: {sample['slot_id']}")
+        print(f"  Location: ({sample['latitude']}, {sample['longitude']})")
+        print(f"  Features:")
+        print(f"    - avg_feedback: {sample['avg_feedback']} (0-5 scale)")
+        print(f"    - popularity_score: {sample['popularity_score']} (0-1)")
+        print(f"    - is_available: {sample['is_available']}")
+        print(f"    - price_factor: {sample['price_factor']} (0-1)")
+        print(f"    - price_per_hour: ₹{sample['price_per_hour']}")
+        print(f"    - proximity_score: Will be calculated based on user location")
+    
+    print("\n" + "=" * 70)
+    print("🧠 STEP 4: AI MODEL PREDICTION")
+    print("=" * 70)
+    
+    # Get AI recommendations
+    user_coords = (user_lat, user_lon)
+    recommendations = classifier.predict_best_slots(
+        ai_slots, 
+        user_coords, 
+        top_k=3
+    )
+    
+    print(f"✅ AI Model processed {len(ai_slots)} slot(s)")
+    print(f"📍 Calculated proximity from user location")
+    print(f"🎯 Generated {len(recommendations)} recommendation(s)")
+    
+    print("\n" + "=" * 70)
+    print("🏆 STEP 5: TOP RECOMMENDATIONS")
+    print("=" * 70)
+    
+    for i, slot in enumerate(recommendations, 1):
+        print(f"\n#{i} Recommended Slot: {slot['slot_id']}")
+        print(f"  📍 Location: {slot.get('location', 'N/A')}")
+        print(f"  🚗 Vehicle Type: {slot.get('vehicle_type', 'N/A')}")
+        print(f"  💰 Price: ₹{slot['price_per_hour']}/hour")
+        print(f"  📊 AI Scores:")
+        print(f"     - Recommendation Score: {slot['recommendation_score']:.3f} (FINAL)")
+        print(f"     - Proximity Score: {slot['proximity_score']:.3f}")
+        print(f"     - Feedback Score: {slot['avg_feedback']:.1f}/5.0")
+        print(f"     - Popularity: {slot['popularity_score']:.2f}")
+        print(f"     - Available: {'✅ Yes' if slot['is_available'] else '❌ No'}")
+        
+        # Calculate distance
+        from ai_model.parking_slot_classifier import ParkingSlotClassifier
+        temp_classifier = ParkingSlotClassifier()
+        slot_coords = (slot['latitude'], slot['longitude'])
+        proximity = temp_classifier.calculate_proximity_score(slot_coords, user_coords)
+        
+        # Estimate distance
+        distance_km = (1 - proximity) * 5
+        if distance_km < 0.1:
+            distance_str = f"{distance_km * 1000:.0f} meters"
+        else:
+            distance_str = f"{distance_km:.2f} km"
+        
+        print(f"     - Estimated Distance: {distance_str}")
+    
+    print("\n" + "=" * 70)
+    print("📊 HOW THE AI DECIDED")
+    print("=" * 70)
+    
+    print(f"""
+The AI considered these factors for each slot:
+
+1. PROXIMITY (40% weight)
+   - Calculated distance from your location using GPS
+   - Closer slots get higher scores
+
+2. USER FEEDBACK (30% weight)
+   - Average ratings from previous users
+   - Based on actual user experiences
+
+3. POPULARITY (20% weight)
+   - How often this slot is booked
+   - Popular slots are often better maintained
+
+4. AVAILABILITY (10% weight)
+   - Currently available = higher priority
+   - Unavailable slots get lower scores
+
+5. PRICE (indirect factor)
+   - Considered in the overall calculation
+   - Balanced with other factors
+    """)
+    
+    print("\n" + "=" * 70)
+    print("🔄 MODEL LEARNING")
+    print("=" * 70)
+    
+    print(f"""
+The AI model improves over time:
+
+1. User receives recommendations ✅
+2. User books a slot ✅
+3. User provides feedback (rating + satisfaction) 📝
+4. System stores the feedback
+5. After 10+ feedbacks → Model retrains 🔄
+6. Model learns patterns of good recommendations 🧠
+
+Current training: {500} synthetic samples
+Real feedback needed: 10+ samples for retraining
+    """)
+    
+else:
+    print(f"❌ Failed to fetch slots: {slots_result.get('message')}")
+
+print("\n" + "=" * 70)
+print("✅ DEMO COMPLETE")
+print("=" * 70)
+print(f"""
+To use the AI model in your application:
+
+1. GET user's GPS location
+2. POST to /api/recommend-slots with:
+   {{
+     "user_location": {{"latitude": {user_lat}, "longitude": {user_lon}}},
+     "slots": [],
+     "top_k": 3
+   }}
+
+3. Receive top 3 recommended slots
+4. Display to user
+5. Collect feedback after booking
+6. Use feedback to improve model
+
+For more details, see: AI_MODEL_GUIDE.md
+""")

diagnose_api.py

@@ -0,0 +1,66 @@
+"""
+Diagnose the API issue by making direct requests
+"""
+import requests
+import json
+
+base_url = "https://aadarshsenapati.in/api/api.php"
+
+print("=" * 60)
+print("DIAGNOSING API ENDPOINT")
+print("=" * 60)
+
+# Test get_available_slots endpoint
+print("\n📡 Testing get_available_slots endpoint:")
+print(f"URL: {base_url}?action=get_available_slots")
+
+try:
+    # Try POST request with parking_lot_id
+    response = requests.post(
+        f"{base_url}?action=get_available_slots",
+        json={"parking_lot_id": 1},
+        headers={'Content-Type': 'application/json'},
+        timeout=10
+    )
+    
+    print(f"\nStatus Code: {response.status_code}")
+    print(f"Response Headers: {dict(response.headers)}")
+    print(f"\nResponse Body:")
+    print(response.text[:1000])  # First 1000 chars
+    
+    if response.status_code == 200:
+        try:
+            data = response.json()
+            print(f"\nParsed JSON:")
+            print(json.dumps(data, indent=2))
+        except:
+            print("\nCouldn't parse as JSON")
+    
+except Exception as e:
+    print(f"❌ Error: {e}")
+
+# Also try with different parking_lot_id formats
+print("\n" + "=" * 60)
+print("Testing with different parameter formats:")
+
+formats = [
+    {"parking_lot_id": 1},
+    {"parking_lot_id": "1"},
+    {"lot_id": 1},
+]
+
+for fmt in formats:
+    print(f"\n📤 Trying: {fmt}")
+    try:
+        response = requests.post(
+            f"{base_url}?action=get_available_slots",
+            json=fmt,
+            timeout=5
+        )
+        print(f"   Status: {response.status_code}")
+        if response.status_code == 200:
+            print(f"   Result: {response.json().get('status')}")
+    except Exception as e:
+        print(f"   Error: {e}")
+
+print("\n" + "=" * 60)

diagnose_booking.py

@@ -0,0 +1,138 @@
+"""
+Diagnose booking endpoint issue
+"""
+import requests
+import json
+from datetime import datetime, timedelta
+
+base_url = "https://aadarshsenapati.in/api/api.php"
+
+print("=" * 70)
+print("DIAGNOSING book_slot ENDPOINT")
+print("=" * 70)
+
+# Prepare booking data
+start_time = datetime.now()
+end_time = start_time + timedelta(hours=2)
+
+booking_data = {
+    "user_id": 1,
+    "slot_id": 1,
+    "start_time": start_time.strftime("%Y-%m-%d %H:%M:%S"),
+    "end_time": end_time.strftime("%Y-%m-%d %H:%M:%S"),
+    "total_amount": 100.0
+}
+
+print("\n📤 Sending booking request...")
+print(f"URL: {base_url}?action=book_slot")
+print(f"\nPayload:")
+print(json.dumps(booking_data, indent=2))
+
+try:
+    response = requests.post(
+        f"{base_url}?action=book_slot",
+        json=booking_data,
+        headers={'Content-Type': 'application/json'},
+        timeout=10
+    )
+    
+    print(f"\n📥 Response Status Code: {response.status_code}")
+    print(f"\nResponse Headers:")
+    for key, value in response.headers.items():
+        print(f"  {key}: {value}")
+    
+    print(f"\n📄 Response Body:")
+    print(response.text[:2000])  # First 2000 chars
+    
+    if response.status_code == 200:
+        try:
+            data = response.json()
+            print(f"\n✅ Parsed JSON:")
+            print(json.dumps(data, indent=2))
+        except:
+            print("\n⚠️  Response is not valid JSON")
+    else:
+        print(f"\n❌ HTTP Error: {response.status_code}")
+        
+        # Try to see if there's any HTML error
+        if "html" in response.text.lower():
+            print("\n⚠️  Response appears to be HTML (likely a PHP error page)")
+            # Extract title if present
+            if "<title>" in response.text:
+                start = response.text.find("<title>") + 7
+                end = response.text.find("</title>")
+                print(f"Error Title: {response.text[start:end]}")
+        
+except Exception as e:
+    print(f"\n❌ Request failed: {e}")
+
+# Try with different data formats
+print("\n" + "=" * 70)
+print("TRYING DIFFERENT DATA FORMATS")
+print("=" * 70)
+
+# Try 1: String slot_id
+test_data_1 = {**booking_data, "slot_id": "1"}
+print("\n1️⃣  Trying with string slot_id...")
+try:
+    response = requests.post(
+        f"{base_url}?action=book_slot",
+        json=test_data_1,
+        timeout=5
+    )
+    print(f"   Status: {response.status_code}")
+    if response.status_code == 200:
+        print(f"   Result: {response.json().get('status')}")
+except Exception as e:
+    print(f"   Error: {e}")
+
+# Try 2: Without total_amount
+test_data_2 = {k: v for k, v in booking_data.items() if k != 'total_amount'}
+print("\n2️⃣  Trying without total_amount...")
+try:
+    response = requests.post(
+        f"{base_url}?action=book_slot",
+        json=test_data_2,
+        timeout=5
+    )
+    print(f"   Status: {response.status_code}")
+    if response.status_code == 200:
+        print(f"   Result: {response.json().get('status')}")
+except Exception as e:
+    print(f"   Error: {e}")
+
+# Try 3: Minimal data
+test_data_3 = {
+    "user_id": 1,
+    "slot_id": 1
+}
+print("\n3️⃣  Trying with minimal data (user_id, slot_id only)...")
+try:
+    response = requests.post(
+        f"{base_url}?action=book_slot",
+        json=test_data_3,
+        timeout=5
+    )
+    print(f"   Status: {response.status_code}")
+    if response.status_code == 200:
+        print(f"   Result: {response.json().get('status')}")
+    else:
+        print(f"   Response: {response.text[:200]}")
+except Exception as e:
+    print(f"   Error: {e}")
+
+print("\n" + "=" * 70)
+print("💡 COMMON CAUSES OF 500 ERROR:")
+print("=" * 70)
+print("""
+1. Table name mismatch (e.g., 'bookings' vs 'booking')
+2. Column name mismatch (e.g., 'slot_id' vs 'parking_slot_id')
+3. Missing table or columns in database
+4. SQL syntax error in PHP code
+5. Missing required fields
+6. Data type mismatch (e.g., expecting INT but getting STRING)
+7. Foreign key constraint violation
+8. PHP syntax error or uncaught exception
+
+📋 Check your PHP error logs for the actual error message!
+""")

diagnose_payment_update.py

@@ -0,0 +1,119 @@
+"""
+Diagnose Payment Update Issue
+"""
+import requests
+import json
+from datetime import datetime, timedelta
+from backend.database_api import DatabaseAPI
+
+api = DatabaseAPI()
+base_url = "https://aadarshsenapati.in/api/api.php"
+
+print("=" * 70)
+print("DIAGNOSING PAYMENT UPDATE ISSUE")
+print("=" * 70)
+
+# Step 1: Create a test booking first
+print("\n1️⃣  Creating a test booking...")
+start_time = datetime.now()
+end_time = start_time + timedelta(hours=2)
+
+booking_result = api.book_slot(
+    user_id=9,
+    slot_id=1,
+    start_time=start_time.strftime("%Y-%m-%d %H:%M:%S"),
+    end_time=end_time.strftime("%Y-%m-%d %H:%M:%S"),
+    total_amount=120.0
+)
+
+if booking_result['status'] == 'success':
+    booking_uid = booking_result['booking_uid']
+    print(f"✅ Booking created: {booking_uid}")
+    
+    # Step 2: Check initial status
+    print(f"\n2️⃣  Checking initial booking status...")
+    status_result = api.get_booking_status(booking_uid)
+    if status_result['status'] == 'success':
+        booking_data = status_result['data']
+        print(f"Initial payment_status: '{booking_data.get('payment_status')}'")
+        print(f"Full booking data:")
+        print(json.dumps(booking_data, indent=2))
+    
+    # Step 3: Update payment status
+    print(f"\n3️⃣  Updating payment status to 'Paid'...")
+    
+    # Direct API call to see exact request/response
+    payment_data = {
+        "booking_uid": booking_uid,
+        "payment_status": "Paid",
+        "transaction_id": f"txn_test_{booking_uid}",
+        "amount": 120.0
+    }
+    
+    print(f"\nPayload being sent:")
+    print(json.dumps(payment_data, indent=2))
+    
+    response = requests.post(
+        f"{base_url}?action=update_payment_status",
+        json=payment_data,
+        headers={'Content-Type': 'application/json'},
+        timeout=10
+    )
+    
+    print(f"\nResponse Status: {response.status_code}")
+    print(f"Response Body:")
+    print(response.text)
+    
+    if response.status_code == 200:
+        try:
+            result = response.json()
+            print(f"\nParsed Response:")
+            print(json.dumps(result, indent=2))
+        except:
+            print("Could not parse JSON")
+    
+    # Step 4: Check updated status
+    print(f"\n4️⃣  Checking booking status after update...")
+    status_result = api.get_booking_status(booking_uid)
+    if status_result['status'] == 'success':
+        booking_data = status_result['data']
+        payment_status = booking_data.get('payment_status')
+        print(f"After update payment_status: '{payment_status}'")
+        print(f"Full booking data:")
+        print(json.dumps(booking_data, indent=2))
+        
+        # Analysis
+        print(f"\n5️⃣  ANALYSIS:")
+        if payment_status == 'Paid':
+            print("✅ Payment status updated correctly!")
+        elif payment_status == 'Completed':
+            print("⚠️  Payment status is 'Completed' (should be 'Paid')")
+            print("   Valid statuses: Pending, Paid, Failed, Refunded")
+        elif payment_status == '':
+            print("❌ Payment status is EMPTY (removed)")
+            print("   This suggests the UPDATE query is setting it to empty string")
+        elif payment_status is None:
+            print("❌ Payment status is NULL")
+            print("   This suggests the UPDATE query is setting it to NULL")
+        elif payment_status == 'Pending':
+            print("❌ Payment status is still 'Pending'")
+            print("   This suggests the UPDATE query didn't execute")
+        else:
+            print(f"⚠️  Payment status is: '{payment_status}'")
+            print("   Unexpected value")
+    
+else:
+    print(f"❌ Failed to create booking: {booking_result.get('message')}")
+
+print("\n" + "=" * 70)
+print("💡 COMMON CAUSES:")
+print("=" * 70)
+print("""
+1. UPDATE query is setting payment_status to empty string instead of value
+2. Column name mismatch (e.g., 'paymentStatus' vs 'payment_status')
+3. Missing WHERE clause causing wrong row to update
+4. Database user lacks UPDATE permission
+5. SQL syntax error silently failing
+
+🔍 Check your PHP update_payment code!
+""")

final_system_test.py

@@ -0,0 +1,190 @@
+"""
+Final System Test - Verify Everything Works
+"""
+from backend.database_api import DatabaseAPI, transform_parking_lots_for_ai
+from datetime import datetime, timedelta
+import json
+
+def print_header(title):
+    print("\n" + "="*70)
+    print(f"🧪 {title}")
+    print("="*70)
+
+def main():
+    print("""
+╔══════════════════════════════════════════════════════════════════╗
+║                   SMART PARKING SYSTEM                            ║
+║                   FINAL SYSTEM TEST                               ║
+╚══════════════════════════════════════════════════════════════════╝
+""")
+    
+    api = DatabaseAPI()
+    results = {}
+    
+    # Test 1: Get Available Slots
+    print_header("TEST 1: Get Available Parking Slots")
+    try:
+        result = api.get_all_available_slots()
+        if result['status'] == 'success' and result.get('data'):
+            slots = result['data']
+            print(f"✅ PASSED - Found {len(slots)} available slot(s)")
+            print(f"   Sample: {slots[0].get('lot_name')}-{slots[0].get('slot_number')}")
+            results['Get Slots'] = True
+        else:
+            print(f"❌ FAILED - No slots found")
+            results['Get Slots'] = False
+    except Exception as e:
+        print(f"❌ FAILED - {e}")
+        results['Get Slots'] = False
+    
+    # Test 2: AI Data Transformation
+    print_header("TEST 2: AI Data Transformation")
+    try:
+        slots_result = api.get_all_available_slots()
+        if slots_result['status'] == 'success':
+            transformed = transform_parking_lots_for_ai(slots_result['data'])
+            if transformed:
+                print(f"✅ PASSED - Transformed {len(transformed)} slot(s) for AI")
+                sample = transformed[0]
+                print(f"   Slot ID: {sample['slot_id']}")
+                print(f"   Coordinates: ({sample['latitude']}, {sample['longitude']})")
+                print(f"   Price: ₹{sample['price_per_hour']}/hr")
+                results['AI Transform'] = True
+            else:
+                print(f"❌ FAILED - No transformed data")
+                results['AI Transform'] = False
+    except Exception as e:
+        print(f"❌ FAILED - {e}")
+        results['AI Transform'] = False
+    
+    # Test 3: User Registration
+    print_header("TEST 3: User Registration")
+    try:
+        result = api.register_user(
+            name="System Test User",
+            phone="+919876543210",
+            email="systest@parking.com"
+        )
+        if result['status'] == 'success':
+            print(f"✅ PASSED - {result.get('message')}")
+            results['User Registration'] = True
+        else:
+            print(f"❌ FAILED - {result.get('message')}")
+            results['User Registration'] = False
+    except Exception as e:
+        print(f"❌ FAILED - {e}")
+        results['User Registration'] = False
+    
+    # Test 4: Create Booking
+    print_header("TEST 4: Create Booking")
+    booking_uid = None
+    try:
+        start_time = datetime.now()
+        end_time = start_time + timedelta(hours=2)
+        
+        result = api.book_slot(
+            user_id=9,  # Known existing user
+            slot_id=1,  # Known existing slot
+            start_time=start_time.strftime("%Y-%m-%d %H:%M:%S"),
+            end_time=end_time.strftime("%Y-%m-%d %H:%M:%S"),
+            total_amount=120.0
+        )
+        
+        if result['status'] == 'success':
+            booking_uid = result.get('booking_uid')
+            print(f"✅ PASSED - Booking created")
+            print(f"   Booking UID: {booking_uid}")
+            results['Create Booking'] = True
+        else:
+            print(f"❌ FAILED - {result.get('message')}")
+            results['Create Booking'] = False
+    except Exception as e:
+        print(f"❌ FAILED - {e}")
+        results['Create Booking'] = False
+    
+    # Test 5: Get Booking Status
+    if booking_uid:
+        print_header("TEST 5: Get Booking Status")
+        try:
+            result = api.get_booking_status(booking_uid)
+            if result['status'] == 'success' and result.get('data'):
+                booking = result['data']
+                print(f"✅ PASSED - Booking retrieved")
+                print(f"   Status: {booking.get('status')}")
+                print(f"   Payment: {booking.get('payment_status')}")
+                print(f"   Amount: ₹{booking.get('total_amount')}")
+                results['Get Booking'] = True
+            else:
+                print(f"❌ FAILED - Booking not found")
+                results['Get Booking'] = False
+        except Exception as e:
+            print(f"❌ FAILED - {e}")
+            results['Get Booking'] = False
+    else:
+        print_header("TEST 5: Get Booking Status")
+        print("⏭️  SKIPPED - No booking created")
+        results['Get Booking'] = None
+    
+    # Test 6: Update Payment
+    if booking_uid:
+        print_header("TEST 6: Update Payment Status")
+        try:
+            result = api.update_payment(
+                booking_uid=booking_uid,
+                payment_status='Paid',
+                transaction_id=f'txn_test_{booking_uid}',
+                amount=120.0
+            )
+            if result['status'] == 'success':
+                print(f"✅ PASSED - Payment updated to Paid")
+                results['Update Payment'] = True
+            else:
+                print(f"❌ FAILED - {result.get('message')}")
+                results['Update Payment'] = False
+        except Exception as e:
+            print(f"❌ FAILED - {e}")
+            results['Update Payment'] = False
+    else:
+        print_header("TEST 6: Update Payment Status")
+        print("⏭️  SKIPPED - No booking created")
+        results['Update Payment'] = None
+    
+    # Summary
+    print("\n" + "="*70)
+    print("📊 TEST SUMMARY")
+    print("="*70)
+    
+    passed = sum(1 for v in results.values() if v is True)
+    failed = sum(1 for v in results.values() if v is False)
+    skipped = sum(1 for v in results.values() if v is None)
+    total = passed + failed
+    
+    for test_name, result in results.items():
+        if result is True:
+            print(f"✅ PASSED: {test_name}")
+        elif result is False:
+            print(f"❌ FAILED: {test_name}")
+        else:
+            print(f"⏭️  SKIPPED: {test_name}")
+    
+    print("\n" + "="*70)
+    print(f"Total: {passed}/{total} tests passed")
+    if skipped:
+        print(f"Skipped: {skipped} test(s)")
+    
+    if passed == total and total > 0:
+        print("\n🎉 ALL TESTS PASSED! System is ready!")
+    elif passed >= total * 0.8:
+        print("\n✅ Most tests passed! System is functional!")
+    else:
+        print("\n⚠️  Some tests failed. Check the output above.")
+    
+    print("\n💡 To start the API server:")
+    print("   python backend/main.py")
+    print("\n📖 For more info, see:")
+    print("   - SUCCESS_SUMMARY.md")
+    print("   - TESTING_GUIDE.md")
+    print("="*70)
+
+if __name__ == "__main__":
+    main()

parking_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58a841e4f900172e5662e2f41492ff9aff3d1ef67c7820c20b746186a94ab2ae
+size 753436

requirements.txt

@@ -0,0 +1,27 @@
+numpy>=1.24.0
+scikit-learn>=1.3.0
+pandas>=2.0.0
+
+# Web Framework
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+pydantic>=2.0.0
+
+# HTTP Requests (for database API)
+requests>=2.31.0
+
+# Payment Gateway
+razorpay>=1.4.0
+
+# Database (optional - for production)
+sqlalchemy>=2.0.0
+psycopg2-binary>=2.9.0
+
+# Environment variables
+python-dotenv>=1.0.0
+
+# CORS
+python-multipart>=0.0.6
+
+# For production deployment
+gunicorn>=21.0.0

run_tests.py

@@ -0,0 +1,77 @@
+"""
+Quick Test - Run all basic tests at once
+"""
+import subprocess
+import sys
+
+def run_test(name, command):
+    """Run a test and display results"""
+    print("\n" + "=" * 70)
+    print(f"🧪 TEST: {name}")
+    print("=" * 70)
+    
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        
+        print(result.stdout)
+        if result.stderr:
+            print("STDERR:", result.stderr)
+        
+        return result.returncode == 0
+    except subprocess.TimeoutExpired:
+        print("❌ Test timed out")
+        return False
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+
+def main():
+    print("""
+╔══════════════════════════════════════════════════════════════╗
+║         SMART PARKING SYSTEM - QUICK TEST SUITE             ║
+╚══════════════════════════════════════════════════════════════╝
+""")
+    
+    tests = [
+        ("Database Slot Check", "python check_slots.py"),
+        ("Full Database Integration", "python test_database.py"),
+    ]
+    
+    results = {}
+    
+    for name, command in tests:
+        results[name] = run_test(name, command)
+    
+    # Summary
+    print("\n" + "=" * 70)
+    print("📊 TEST SUMMARY")
+    print("=" * 70)
+    
+    for name, passed in results.items():
+        status = "✅ PASSED" if passed else "❌ FAILED"
+        print(f"{status}: {name}")
+    
+    total = len(results)
+    passed = sum(1 for v in results.values() if v)
+    
+    print(f"\n Total: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("\n🎉 All tests passed!")
+    else:
+        print("\n⚠️  Some tests failed. Check the output above.")
+    
+    print("\n💡 To start the API server, run:")
+    print("   python backend/main.py")
+    print("\n💡 Then visit http://127.0.0.1:8000/docs for interactive API testing")
+
+
+if __name__ == "__main__":
+    main()

test_api_raw.py

@@ -0,0 +1,111 @@
+"""
+Diagnose the actual API response structure
+"""
+import requests
+import json
+
+API_URL = "https://aadarshsenapati.in/api/api.php"
+
+print("=" * 70)
+print("RAW API RESPONSE DIAGNOSTIC")
+print("=" * 70)
+
+# Test 1: Get parking lots
+print("\n1. GET PARKING LOTS")
+print("-" * 70)
+response = requests.get(f"{API_URL}?action=get_parking_lots", timeout=10)
+print(f"Status Code: {response.status_code}")
+print(f"\nRaw Response Text:")
+print(response.text)
+print(f"\nParsed JSON:")
+data = response.json()
+print(json.dumps(data, indent=2))
+
+if data.get('status') == 'success' and data.get('data'):
+    print(f"\n📊 First Record Fields:")
+    first_record = data['data'][0]
+    for key, value in first_record.items():
+        print(f"   {key}: {value} (type: {type(value).__name__})")
+
+# Test 2: Get users (if endpoint exists)
+print("\n\n2. GET USERS")
+print("-" * 70)
+try:
+    response = requests.get(f"{API_URL}?action=get_users", timeout=10)
+    print(f"Status Code: {response.status_code}")
+    if response.status_code == 200:
+        print(json.dumps(response.json(), indent=2))
+except Exception as e:
+    print(f"Error: {e}")
+
+# Test 3: Get slots (if different from lots)
+print("\n\n3. GET SLOTS")
+print("-" * 70)
+try:
+    response = requests.get(f"{API_URL}?action=get_slots", timeout=10)
+    print(f"Status Code: {response.status_code}")
+    if response.status_code == 200:
+        data = response.json()
+        print(json.dumps(data, indent=2))
+        if data.get('status') == 'success' and data.get('data'):
+            print(f"\n📊 First Slot Record Fields:")
+            first_record = data['data'][0]
+            for key, value in first_record.items():
+                print(f"   {key}: {value} (type: {type(value).__name__})")
+except Exception as e:
+    print(f"Error: {e}")
+
+# Test 4: Get slots by lot_id
+print("\n\n4. GET SLOTS BY LOT ID")
+print("-" * 70)
+try:
+    response = requests.get(f"{API_URL}?action=get_slots_by_lot&lot_id=1", timeout=10)
+    print(f"Status Code: {response.status_code}")
+    if response.status_code == 200:
+        data = response.json()
+        print(json.dumps(data, indent=2))
+        if data.get('status') == 'success' and data.get('data'):
+            print(f"\n📊 First Slot Record Fields:")
+            first_record = data['data'][0]
+            for key, value in first_record.items():
+                print(f"   {key}: {value} (type: {type(value).__name__})")
+except Exception as e:
+    print(f"Error: {e}")
+
+# Test 5: Get available slots
+print("\n\n5. GET AVAILABLE SLOTS")
+print("-" * 70)
+try:
+    response = requests.get(f"{API_URL}?action=get_available_slots", timeout=10)
+    print(f"Status Code: {response.status_code}")
+    if response.status_code == 200:
+        data = response.json()
+        print(json.dumps(data, indent=2))
+        if data.get('status') == 'success' and data.get('data'):
+            print(f"\n📊 First Slot Record Fields:")
+            first_record = data['data'][0]
+            for key, value in first_record.items():
+                print(f"   {key}: {value} (type: {type(value).__name__})")
+except Exception as e:
+    print(f"Error: {e}")
+
+# Test 6: Try to get parking_slots table data
+print("\n\n6. GET PARKING SLOTS (alternative endpoint name)")
+print("-" * 70)
+try:
+    response = requests.get(f"{API_URL}?action=get_parking_slots", timeout=10)
+    print(f"Status Code: {response.status_code}")
+    if response.status_code == 200:
+        data = response.json()
+        print(json.dumps(data, indent=2))
+        if data.get('status') == 'success' and data.get('data'):
+            print(f"\n📊 First Slot Record Fields:")
+            first_record = data['data'][0]
+            for key, value in first_record.items():
+                print(f"   {key}: {value} (type: {type(value).__name__})")
+except Exception as e:
+    print(f"Error: {e}")
+
+print("\n" + "=" * 70)
+print("END DIAGNOSTIC")
+print("=" * 70)

test_booking_userid.py

@@ -0,0 +1,73 @@
+"""
+Test booking with valid user_id
+"""
+import requests
+import json
+from datetime import datetime, timedelta
+
+base_url = "https://aadarshsenapati.in/api/api.php"
+
+print("=" * 70)
+print("TESTING BOOKING WITH DIFFERENT USER IDs")
+print("=" * 70)
+
+# Prepare booking data
+start_time = datetime.now()
+end_time = start_time + timedelta(hours=2)
+
+# Try different user IDs
+user_ids_to_try = [1, 9, 10]
+
+for user_id in user_ids_to_try:
+    print(f"\n{'='*70}")
+    print(f"🧪 Testing with user_id: {user_id}")
+    print('='*70)
+    
+    booking_data = {
+        "user_id": user_id,
+        "slot_id": 1,
+        "start_time": start_time.strftime("%Y-%m-%d %H:%M:%S"),
+        "end_time": end_time.strftime("%Y-%m-%d %H:%M:%S"),
+        "total_amount": 120.0
+    }
+    
+    try:
+        response = requests.post(
+            f"{base_url}?action=book_slot",
+            json=booking_data,
+            headers={'Content-Type': 'application/json'},
+            timeout=10
+        )
+        
+        print(f"Status Code: {response.status_code}")
+        
+        if response.status_code == 200:
+            try:
+                result = response.json()
+                print(f"✅ SUCCESS!")
+                print(f"Response: {json.dumps(result, indent=2)}")
+                
+                if result.get('status') == 'success':
+                    print(f"\n🎉 Booking created successfully!")
+                    print(f"   Booking UID: {result.get('booking_uid')}")
+                    print(f"   User ID: {user_id} ✅ WORKS!")
+                    break  # Stop after first success
+            except:
+                print(f"⚠️  Response is not JSON: {response.text[:200]}")
+        else:
+            print(f"❌ FAILED with user_id: {user_id}")
+            
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+print("\n" + "=" * 70)
+print("💡 RECOMMENDATION:")
+print("=" * 70)
+print("""
+The booking endpoint works, but specific user_ids may not exist.
+
+Solutions:
+1. Use user_id that exists (like 9 from your manual test)
+2. Create user_id = 1 in database
+3. Update Python code to use existing user_id
+""")

test_database.py

@@ -0,0 +1,285 @@
+"""
+Test Database API Integration
+Tests the connection to https://aadarshsenapati.in/api/api.php
+"""
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from backend.database_api import DatabaseAPI, transform_parking_lots_for_ai
+from datetime import datetime, timedelta
+import json
+
+
+def test_database_connection():
+    """Test basic database connectivity"""
+    print("\n" + "=" * 70)
+    print("DATABASE API CONNECTION TEST")
+    print("=" * 70)
+    
+    api = DatabaseAPI()
+    
+    # Test 1: Get parking lots and slots
+    print("\n1️⃣  Testing: Get Available Parking Slots")
+    print("-" * 70)
+    result = api.get_all_available_slots()
+    
+    if result['status'] == 'success':
+        slots = result.get('data', [])
+        total_lots = result.get('total_lots', 0)
+        print(f"✅ SUCCESS: Found {len(slots)} available slots from {total_lots} parking lot(s)")
+        
+        if slots:
+            print(f"\n📊 Sample Parking Slot:")
+            sample = slots[0]
+            print(f"   Slot ID: {sample.get('slot_id')}")
+            print(f"   Slot Number: {sample.get('slot_number')}")
+            print(f"   Lot Name: {sample.get('lot_name')}")
+            print(f"   Location: {sample.get('lot_address')}")
+            print(f"   Coordinates: ({sample.get('lot_latitude')}, {sample.get('lot_longitude')})")
+            print(f"   Vehicle Type: {sample.get('vehicle_type')}")
+            print(f"   Price/Hour: ₹{sample.get('hourly_rate')}")
+            
+            # Test data transformation
+            print(f"\n🔄 Transforming data for AI model...")
+            transformed = transform_parking_lots_for_ai(slots)
+            print(f"✅ Transformed {len(transformed)} slots")
+            print(f"\n📊 Transformed Sample:")
+            t_sample = transformed[0]
+            print(f"   Slot ID: {t_sample['slot_id']}")
+            print(f"   DB Slot ID: {t_sample.get('db_slot_id')}")
+            print(f"   Coordinates: ({t_sample['latitude']}, {t_sample['longitude']})")
+            print(f"   Proximity Score: {t_sample['proximity_score']}")
+            print(f"   Popularity Score: {t_sample['popularity_score']}")
+            print(f"   Price Factor: {t_sample['price_factor']}")
+            print(f"   Price/Hour: ₹{t_sample['price_per_hour']}")
+    else:
+        print(f"❌ FAILED: {result.get('message')}")
+    
+    return api
+
+
+def test_user_registration(api):
+    """Test user registration"""
+    print("\n2️⃣  Testing: User Registration")
+    print("-" * 70)
+    
+    test_user = {
+        "name": "Test User AI",
+        "phone": "+919999888877",
+        "email": "aitest@smartparking.com"
+    }
+    
+    result = api.register_user(**test_user)
+    
+    if result['status'] == 'success':
+        print(f"✅ SUCCESS: {result.get('message')}")
+        print(f"   Name: {test_user['name']}")
+        print(f"   Phone: {test_user['phone']}")
+    else:
+        print(f"❌ FAILED: {result.get('message')}")
+    
+    return result['status'] == 'success'
+
+
+def test_booking_flow(api):
+    """Test complete booking flow"""
+    print("\n3️⃣  Testing: Booking Flow")
+    print("-" * 70)
+    
+    # Get available slots first
+    slots_result = api.get_all_available_slots()
+    if slots_result['status'] != 'success' or not slots_result.get('data'):
+        print("❌ Cannot test booking: No available slots")
+        return False
+    
+    # Use first available slot
+    slot = slots_result['data'][0]
+    slot_db_id = slot.get('slot_id') or slot.get('id') or 1
+    slot_number = slot.get('slot_number', 'Unknown')
+    lot_name = slot.get('lot_name', 'Unknown')
+    
+    # Create booking
+    start_time = datetime.now()
+    end_time = start_time + timedelta(hours=2)
+    
+    # Use user_id = 9 (known to exist in database)
+    # In production, this should be the authenticated user's ID
+    booking_data = {
+        "user_id": 9,  # Using existing user ID from database
+        "slot_id": int(slot_db_id),
+        "start_time": start_time.strftime("%Y-%m-%d %H:%M:%S"),
+        "end_time": end_time.strftime("%Y-%m-%d %H:%M:%S"),
+        "total_amount": 120.0
+    }
+    
+    print(f"\n📝 Creating booking...")
+    print(f"   Lot: {lot_name}")
+    print(f"   Slot: {slot_number} (DB ID: {slot_db_id})")
+    print(f"   Duration: 2 hours")
+    print(f"   Amount: ₹120")
+    print(f"   User ID: 9 (existing user)")
+    
+    result = api.book_slot(**booking_data)
+    
+    if result['status'] == 'success':
+        booking_uid = result.get('booking_uid')
+        print(f"✅ SUCCESS: Booking created")
+        print(f"   Booking UID: {booking_uid}")
+        
+        # Test getting booking status
+        print(f"\n📊 Fetching booking status...")
+        status_result = api.get_booking_status(booking_uid)
+        
+        if status_result['status'] == 'success':
+            booking = status_result.get('data', {})
+            print(f"✅ Booking found:")
+            print(f"   Status: {booking.get('status')}")
+            print(f"   Payment Status: {booking.get('payment_status')}")
+            print(f"   Amount: ₹{booking.get('total_amount')}")
+        
+        return booking_uid
+    else:
+        print(f"❌ FAILED: {result.get('message')}")
+        return None
+
+
+def test_payment_update(api, booking_uid):
+    """Test payment status update"""
+    if not booking_uid:
+        print("\n⏭️  Skipping payment test (no booking UID)")
+        return
+    
+    print("\n4️⃣  Testing: Payment Update")
+    print("-" * 70)
+    
+    payment_data = {
+        "booking_uid": booking_uid,
+        "payment_status": "Paid",
+        "transaction_id": f"txn_test_{booking_uid}",
+        "amount": 120.0
+    }
+    
+    print(f"💳 Updating payment status to 'Paid'...")
+    result = api.update_payment(**payment_data)
+    
+    if result['status'] == 'success':
+        print(f"✅ SUCCESS: {result.get('message')}")
+        
+        # Verify update
+        print(f"\n✓ Verifying update...")
+        status_result = api.get_booking_status(booking_uid)
+        if status_result['status'] == 'success':
+            booking = status_result.get('data', {})
+            print(f"   Payment Status: {booking.get('payment_status')}")
+    else:
+        print(f"❌ FAILED: {result.get('message')}")
+
+
+def test_feedback_submission(api, booking_uid):
+    """Test feedback submission"""
+    if not booking_uid:
+        print("\n⏭️  Skipping feedback test (no booking UID)")
+        return
+    
+    print("\n5️⃣  Testing: Feedback Submission")
+    print("-" * 70)
+    
+    # Get booking ID (not UID) first
+    status_result = api.get_booking_status(booking_uid)
+    if status_result['status'] != 'success':
+        print("❌ Cannot get booking details for feedback")
+        return
+    
+    booking = status_result.get('data', {})
+    booking_id = booking.get('id')
+    user_id = booking.get('user_id', 1)
+    
+    feedback_data = {
+        "user_id": user_id,
+        "booking_id": booking_id,
+        "rating": 5.0,
+        "comments": "Excellent parking spot! Very convenient location."
+    }
+    
+    print(f"⭐ Submitting feedback...")
+    print(f"   Rating: {feedback_data['rating']}/5.0")
+    print(f"   Comment: {feedback_data['comments']}")
+    
+    result = api.add_feedback(**feedback_data)
+    
+    if result['status'] == 'success':
+        print(f"✅ SUCCESS: {result.get('message')}")
+    else:
+        print(f"❌ FAILED: {result.get('message')}")
+
+
+def test_booking_cancellation(api, booking_uid):
+    """Test booking cancellation"""
+    if not booking_uid:
+        print("\n⏭️  Skipping cancellation test (no booking UID)")
+        return
+    
+    print("\n6️⃣  Testing: Booking Cancellation")
+    print("-" * 70)
+    
+    print(f"❌ Cancelling booking {booking_uid}...")
+    result = api.cancel_booking(booking_uid)
+    
+    if result['status'] == 'success':
+        print(f"✅ SUCCESS: {result.get('message')}")
+        
+        # Verify cancellation
+        status_result = api.get_booking_status(booking_uid)
+        if status_result['status'] == 'success':
+            booking = status_result.get('data', {})
+            print(f"   Status: {booking.get('status')}")
+    else:
+        print(f"❌ FAILED: {result.get('message')}")
+
+
+def main():
+    """Run all database tests"""
+    print("\n" + "=" * 70)
+    print("🚀 SMART PARKING - DATABASE API INTEGRATION TESTS")
+    print("=" * 70)
+    print(f"Database URL: https://aadarshsenapati.in/api/api.php")
+    print(f"Test Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    try:
+        # Initialize API
+        api = test_database_connection()
+        
+        # Test user registration
+        test_user_registration(api)
+        
+        # Test booking flow
+        booking_uid = test_booking_flow(api)
+        
+        # Test payment update
+        test_payment_update(api, booking_uid)
+        
+        # Test feedback
+        test_feedback_submission(api, booking_uid)
+        
+        # Don't cancel in tests - keep the data
+        # test_booking_cancellation(api, booking_uid)
+        
+        print("\n" + "=" * 70)
+        print("✅ DATABASE API INTEGRATION TESTS COMPLETED")
+        print("=" * 70)
+        print("\n💡 Next Steps:")
+        print("   1. Verify data in database")
+        print("   2. Test AI recommendations with real data")
+        print("   3. Integrate with payment system")
+        print("   4. Deploy to production")
+        
+    except Exception as e:
+        print(f"\n❌ ERROR: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()

test_slot_availability.py

@@ -0,0 +1,117 @@
+"""
+Test Slot Availability Update - Prevent Double Booking
+"""
+from backend.database_api import DatabaseAPI
+from datetime import datetime, timedelta
+import json
+
+api = DatabaseAPI()
+
+print("=" * 70)
+print("TESTING SLOT AVAILABILITY UPDATE (PREVENT DOUBLE BOOKING)")
+print("=" * 70)
+
+# Step 1: Check initial slot availability
+print("\n1️⃣  Checking initial slot availability...")
+slots_result = api.get_all_available_slots()
+
+if slots_result['status'] == 'success' and slots_result.get('data'):
+    slot = slots_result['data'][0]
+    slot_id = slot.get('slot_id') or slot.get('id')
+    print(f"Slot ID: {slot_id}")
+    print(f"Slot Number: {slot.get('slot_number')}")
+    print(f"Initial status: Available ✅")
+    
+    # Step 2: Create a booking
+    print(f"\n2️⃣  Creating booking for slot {slot_id}...")
+    start_time = datetime.now()
+    end_time = start_time + timedelta(hours=2)
+    
+    booking_result = api.book_slot(
+        user_id=9,
+        slot_id=int(slot_id),
+        start_time=start_time.strftime("%Y-%m-%d %H:%M:%S"),
+        end_time=end_time.strftime("%Y-%m-%d %H:%M:%S"),
+        total_amount=120.0
+    )
+    
+    if booking_result['status'] == 'success':
+        booking_uid = booking_result['booking_uid']
+        print(f"✅ Booking created: {booking_uid}")
+        
+        # Step 3: Check if slot is now unavailable
+        print(f"\n3️⃣  Checking slot availability after booking...")
+        
+        # Direct API call to check slot status
+        import requests
+        response = requests.get(
+            f"https://aadarshsenapati.in/api/api.php?action=get_available_slots",
+            json={"parking_lot_id": 1},
+            timeout=10
+        )
+        
+        print(f"Available slots response:")
+        print(json.dumps(response.json(), indent=2))
+        
+        # Also try to get all slots (including unavailable)
+        print(f"\n4️⃣  Attempting to book the same slot again...")
+        duplicate_booking = api.book_slot(
+            user_id=9,
+            slot_id=int(slot_id),
+            start_time=start_time.strftime("%Y-%m-%d %H:%M:%S"),
+            end_time=end_time.strftime("%Y-%m-%d %H:%M:%S"),
+            total_amount=120.0
+        )
+        
+        if duplicate_booking['status'] == 'success':
+            print(f"❌ WARNING: Duplicate booking allowed!")
+            print(f"   Duplicate booking UID: {duplicate_booking['booking_uid']}")
+            print(f"   This means is_available was not updated to 0")
+        else:
+            print(f"✅ GOOD: Duplicate booking prevented!")
+            print(f"   Message: {duplicate_booking.get('message')}")
+        
+        # Step 5: Test cancellation (should release slot)
+        print(f"\n5️⃣  Testing booking cancellation...")
+        cancel_result = api.cancel_booking(booking_uid)
+        
+        if cancel_result['status'] == 'success':
+            print(f"✅ Booking cancelled")
+            
+            # Check if slot is available again
+            print(f"\n6️⃣  Checking if slot is available after cancellation...")
+            slots_after = api.get_all_available_slots()
+            
+            if slots_after['status'] == 'success':
+                available_count = len(slots_after.get('data', []))
+                print(f"Available slots now: {available_count}")
+                
+                if available_count > 0:
+                    print(f"✅ GOOD: Slot released and available again!")
+                else:
+                    print(f"❌ WARNING: Slot not released after cancellation")
+        else:
+            print(f"❌ Cancellation failed: {cancel_result.get('message')}")
+    else:
+        print(f"❌ Booking failed: {booking_result.get('message')}")
+else:
+    print("❌ No slots found to test")
+
+print("\n" + "=" * 70)
+print("SUMMARY")
+print("=" * 70)
+print("""
+✅ EXPECTED BEHAVIOR:
+   1. Initial slot shows as available (is_available = 1)
+   2. After booking, slot becomes unavailable (is_available = 0)
+   3. Duplicate booking should be prevented
+   4. After cancellation, slot becomes available again (is_available = 1)
+
+❌ CURRENT ISSUE (if not working):
+   - update_slot endpoint might not be implemented in PHP
+   - is_available not being updated when booking
+   - Multiple vehicles can book same slot
+
+🔧 FIX NEEDED IN PHP:
+   Implement update_slot endpoint to update is_available field
+""")

test_system.py

@@ -0,0 +1,230 @@
+"""
+Test script for the AI model and payment integration
+"""
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from ai_model.parking_slot_classifier import ParkingSlotClassifier, generate_training_data
+from backend.payment_service import PaymentService, PaymentSimulator
+import json
+
+
+def test_ai_model():
+    """Test the parking slot classifier"""
+    print("=" * 50)
+    print("Testing AI Model")
+    print("=" * 50)
+    
+    # Initialize classifier
+    classifier = ParkingSlotClassifier()
+    
+    # Generate and train with synthetic data
+    print("\n1. Generating training data...")
+    training_data, labels = generate_training_data(100)
+    print(f"   Generated {len(training_data)} training samples")
+    
+    print("\n2. Training model...")
+    classifier.train(training_data, labels)
+    print("   Model trained successfully")
+    
+    # Test prediction
+    print("\n3. Testing predictions...")
+    test_slots = [
+        {
+            'slot_id': 'A1',
+            'latitude': 28.6139,
+            'longitude': 77.2090,
+            'avg_feedback': 4.5,
+            'popularity_score': 0.8,
+            'is_available': True,
+            'price_factor': 0.7,
+            'price_per_hour': 50.0
+        },
+        {
+            'slot_id': 'B2',
+            'latitude': 28.6150,
+            'longitude': 77.2100,
+            'avg_feedback': 3.2,
+            'popularity_score': 0.4,
+            'is_available': True,
+            'price_factor': 0.5,
+            'price_per_hour': 40.0
+        },
+        {
+            'slot_id': 'C3',
+            'latitude': 28.6145,
+            'longitude': 77.2095,
+            'avg_feedback': 4.8,
+            'popularity_score': 0.9,
+            'is_available': True,
+            'price_factor': 0.9,
+            'price_per_hour': 60.0
+        }
+    ]
+    
+    user_location = (28.6139, 77.2090)
+    best_slots = classifier.predict_best_slots(test_slots, user_location, top_k=3)
+    
+    print("\n   Top 3 Recommended Slots:")
+    for i, slot in enumerate(best_slots, 1):
+        print(f"   {i}. {slot['slot_id']} - Score: {slot['recommendation_score']:.3f}")
+        print(f"      Proximity: {slot['proximity_score']:.3f}, Rating: {slot['avg_feedback']}")
+    
+    print("\n✅ AI Model Test Passed!")
+    return classifier
+
+
+def test_payment_service():
+    """Test the payment service"""
+    print("\n" + "=" * 50)
+    print("Testing Payment Service")
+    print("=" * 50)
+    
+    # Use simulator (doesn't require actual Razorpay connection)
+    print("\n1. Testing Payment Simulator...")
+    simulator = PaymentSimulator()
+    
+    # Simulate payment
+    order_id = "order_test_123"
+    amount = 100.0
+    
+    payment_result = simulator.simulate_payment(order_id, amount)
+    print(f"   Payment ID: {payment_result['payment_id']}")
+    print(f"   Amount: ₹{payment_result['amount']}")
+    print(f"   Status: {payment_result['status']}")
+    
+    # Retrieve simulated payment
+    payment_details = simulator.get_simulated_payment(payment_result['payment_id'])
+    print(f"\n   Retrieved Payment: {json.dumps(payment_details, indent=2)}")
+    
+    print("\n✅ Payment Service Test Passed!")
+    
+    # Try real Razorpay (will fail gracefully if credentials are invalid)
+    print("\n2. Testing Real Razorpay Connection...")
+    try:
+        payment_service = PaymentService(
+            "rzp_test_RYlqJbc24Sl6jz",
+            "bghQe0L7iort9vmqb6Jlf8Ec"
+        )
+        print("   ✅ Razorpay client initialized")
+        
+        # Try creating an order
+        order = payment_service.create_payment_order(
+            amount=50.0,
+            booking_id="TEST_123",
+            notes={'test': 'true'}
+        )
+        
+        if order['success']:
+            print(f"   ✅ Order created: {order['order_id']}")
+        else:
+            print(f"   ⚠️  Order creation failed: {order.get('error')}")
+            
+    except Exception as e:
+        print(f"   ⚠️  Razorpay connection failed: {e}")
+        print("   (This is expected if credentials are invalid)")
+
+
+def test_integration():
+    """Test integration between AI model and payment"""
+    print("\n" + "=" * 50)
+    print("Testing Full Integration")
+    print("=" * 50)
+    
+    print("\n1. User searches for parking...")
+    user_location = (28.6139, 77.2090)
+    print(f"   User location: {user_location}")
+    
+    print("\n2. AI recommends best slots...")
+    classifier = ParkingSlotClassifier()
+    
+    # Quick train with small dataset
+    training_data, labels = generate_training_data(50)
+    classifier.train(training_data, labels)
+    
+    # Sample available slots
+    available_slots = [
+        {
+            'slot_id': 'P101',
+            'latitude': 28.6145,
+            'longitude': 77.2095,
+            'avg_feedback': 4.2,
+            'popularity_score': 0.7,
+            'is_available': True,
+            'price_factor': 0.6,
+            'price_per_hour': 45.0
+        },
+        {
+            'slot_id': 'P102',
+            'latitude': 28.6140,
+            'longitude': 77.2088,
+            'avg_feedback': 4.8,
+            'popularity_score': 0.9,
+            'is_available': True,
+            'price_factor': 0.8,
+            'price_per_hour': 55.0
+        }
+    ]
+    
+    recommendations = classifier.predict_best_slots(available_slots, user_location, top_k=2)
+    
+    print("\n   Recommendations:")
+    for i, slot in enumerate(recommendations, 1):
+        print(f"   {i}. Slot {slot['slot_id']} - Score: {slot['recommendation_score']:.3f}")
+    
+    print("\n3. User selects a slot...")
+    selected_slot = recommendations[0]
+    print(f"   Selected: {selected_slot['slot_id']}")
+    
+    print("\n4. Creating payment order...")
+    simulator = PaymentSimulator()
+    booking_id = "BKG_TEST_001"
+    duration = 2
+    amount = selected_slot['price_per_hour'] * duration
+    
+    payment = simulator.simulate_payment(f"order_{booking_id}", amount)
+    print(f"   Payment ID: {payment['payment_id']}")
+    print(f"   Amount: ₹{amount}")
+    
+    print("\n5. User provides feedback...")
+    feedback = {
+        'booking_id': booking_id,
+        'slot_id': selected_slot['slot_id'],
+        'rating': 5.0,
+        'satisfaction': True
+    }
+    print(f"   Rating: {feedback['rating']}/5")
+    print(f"   Satisfied: {feedback['satisfaction']}")
+    
+    print("\n✅ Full Integration Test Passed!")
+
+
+if __name__ == "__main__":
+    print("\n🚀 Starting Smart Parking System Tests\n")
+    
+    try:
+        # Test AI Model
+        classifier = test_ai_model()
+        
+        # Test Payment Service
+        test_payment_service()
+        
+        # Test Integration
+        test_integration()
+        
+        print("\n" + "=" * 50)
+        print("✅ ALL TESTS PASSED!")
+        print("=" * 50)
+        print("\n📝 Next Steps:")
+        print("1. Set up real parking slot database")
+        print("2. Configure Twilio WhatsApp webhook")
+        print("3. Deploy backend to Render")
+        print("4. Deploy WhatsApp bot to production")
+        print("5. Test with real users")
+        
+    except Exception as e:
+        print(f"\n❌ Test Failed: {e}")
+        import traceback
+        traceback.print_exc()