Upload 5 files

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port 7860 (Hugging Face Spaces standard)
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"]

README.md

@@ -1,12 +1,86 @@
----
-title: Get Me A Job Ap
-emoji: 😻
-colorFrom: purple
-colorTo: pink
-sdk: gradio
-sdk_version: 5.42.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Get Me A Job - Backend API
+
+FastAPI backend with Firebase integration for the Get Me A Job application.
+
+## Setup Instructions
+
+### 1. Firebase Setup
+
+1. Go to [Firebase Console](https://console.firebase.google.com/)
+2. Create a new project: **"get-me-a-job-backend"**
+3. Enable **Firestore Database**
+4. Enable **Authentication** (Email/Password)
+5. Go to **Project Settings** → **Service Accounts**
+6. Click **"Generate new private key"**
+7. Download the JSON file
+
+### 2. Hugging Face Spaces Deployment
+
+1. Create new Space at [huggingface.co/spaces](https://huggingface.co/spaces)
+2. Name: **"yashgori20/get-me-a-job-api"**
+3. Framework: **Gradio** (we'll override with FastAPI)
+4. Upload these files to the Space
+
+### 3. Environment Variables
+
+Add these secrets in Hugging Face Spaces settings:
+
+```bash
+# Firebase Service Account (paste entire JSON content)
+FIREBASE_SERVICE_ACCOUNT={"type":"service_account","project_id":"your-project-id",...}
+
+# JWT Secret (generate a random string)
+JWT_SECRET=your-super-secret-jwt-key-here
+```
+
+### 4. Database Collections
+
+Firebase will auto-create these collections:
+
+- **users**: User accounts
+- **subscriptions**: User subscription plans
+- **usage**: Usage tracking for free tier
+
+## API Endpoints
+
+- `POST /getmeajob/api/auth/register` - User registration
+- `POST /getmeajob/api/auth/login` - User login
+- `GET /getmeajob/api/auth/verify` - Token verification
+- `GET /getmeajob/api/subscription/status` - Check subscription
+- `GET /getmeajob/api/check-updates` - App update check
+- `POST /getmeajob/api/usage/track` - Track API usage
+
+## Local Development
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Add firebase-service-account.json file
+
+# Run the server
+python app.py
+```
+
+Server will run on: http://localhost:7860
+
+## Frontend Integration
+
+Your Electron app is already configured to use:
+`https://yashgori20-get-me-a-job-api.hf.space/getmeajob/api/`
+
+Just deploy this backend and it will work immediately!
+
+## Security Features
+
+- JWT token authentication
+- Password hashing with bcrypt
+- CORS protection
+- Input validation with Pydantic
+- Firebase security rules
+
+## Free Tier Limits
+
+- 10 AI requests per user
+- Email/password authentication
+- Persistent data storage

app.py

@@ -0,0 +1,343 @@
+from fastapi import FastAPI, HTTPException, Depends, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, EmailStr
+import firebase_admin
+from firebase_admin import credentials, firestore, auth
+import jwt
+import bcrypt
+import os
+from datetime import datetime, timedelta
+from typing import Optional
+import uvicorn
+import json
+
+# Initialize FastAPI app
+app = FastAPI(title="Get Me A Job API", version="1.0.0")
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, replace with specific domains
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Security
+security = HTTPBearer()
+JWT_SECRET = os.getenv("JWT_SECRET", "your-super-secret-key-change-in-production")
+JWT_ALGORITHM = "HS256"
+
+# Firebase setup
+def init_firebase():
+    """Initialize Firebase Admin SDK"""
+    try:
+        # Try to get service account from environment variable
+        service_account_json = os.getenv("FIREBASE_SERVICE_ACCOUNT")
+        if service_account_json:
+            service_account_info = json.loads(service_account_json)
+            cred = credentials.Certificate(service_account_info)
+        else:
+            # Fallback to service account file (for local development)
+            cred = credentials.Certificate("firebase-service-account.json")
+        
+        firebase_admin.initialize_app(cred)
+        print("Firebase initialized successfully")
+    except Exception as e:
+        print(f"Firebase initialization failed: {e}")
+        # For development, continue without Firebase
+        pass
+
+# Initialize Firebase
+init_firebase()
+
+# Get Firestore client
+try:
+    db = firestore.client()
+except:
+    db = None
+    print("Firestore client not available - running in development mode")
+
+# Pydantic models
+class UserRegister(BaseModel):
+    email: EmailStr
+    password: str
+
+class UserLogin(BaseModel):
+    email: EmailStr
+    password: str
+
+class UserResponse(BaseModel):
+    id: str
+    email: str
+
+class TokenResponse(BaseModel):
+    token: str
+    user: UserResponse
+
+class SubscriptionResponse(BaseModel):
+    isPaid: bool
+    plan: str
+    usageLeft: Optional[int] = None
+    usageLimit: Optional[int] = None
+
+class UpdateResponse(BaseModel):
+    latestVersion: str
+    downloadUrl: str
+
+# Helper functions
+def hash_password(password: str) -> str:
+    return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+def verify_password(password: str, hashed: str) -> bool:
+    return bcrypt.checkpw(password.encode('utf-8'), hashed.encode('utf-8'))
+
+def create_jwt_token(user_id: str, email: str) -> str:
+    payload = {
+        'user_id': user_id,
+        'email': email,
+        'exp': datetime.utcnow() + timedelta(days=7)
+    }
+    return jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALGORITHM)
+
+def verify_jwt_token(token: str) -> dict:
+    try:
+        payload = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM])
+        return payload
+    except jwt.ExpiredSignatureError:
+        raise HTTPException(status_code=401, detail="Token expired")
+    except jwt.InvalidTokenError:
+        raise HTTPException(status_code=401, detail="Invalid token")
+
+def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(security)) -> dict:
+    return verify_jwt_token(credentials.credentials)
+
+# API Endpoints
+@app.get("/")
+async def root():
+    return {"message": "Get Me A Job API is running!", "firebase_status": "connected" if db else "disconnected"}
+
+@app.post("/getmeajob/api/auth/register", response_model=TokenResponse)
+async def register(user: UserRegister):
+    if not db:
+        raise HTTPException(status_code=503, detail="Database not available")
+    
+    try:
+        # Check if user already exists
+        users_ref = db.collection('users')
+        existing_user = users_ref.where('email', '==', user.email).limit(1).get()
+        
+        if existing_user:
+            raise HTTPException(status_code=400, detail="Email already exists")
+        
+        # Hash password and create user
+        password_hash = hash_password(user.password)
+        
+        # Create user document
+        user_data = {
+            'email': user.email,
+            'password_hash': password_hash,
+            'created_at': firestore.SERVER_TIMESTAMP,
+            'updated_at': firestore.SERVER_TIMESTAMP
+        }
+        
+        # Add user to Firestore
+        user_ref = users_ref.add(user_data)
+        user_id = user_ref[1].id
+        
+        # Create default subscription (free plan)
+        subscription_data = {
+            'user_id': user_id,
+            'plan': 'free',
+            'is_active': True,
+            'created_at': firestore.SERVER_TIMESTAMP,
+            'expires_at': None
+        }
+        db.collection('subscriptions').add(subscription_data)
+        
+        # Create usage record (10 free uses)
+        usage_data = {
+            'user_id': user_id,
+            'usage_count': 10,
+            'last_reset': firestore.SERVER_TIMESTAMP,
+            'created_at': firestore.SERVER_TIMESTAMP
+        }
+        db.collection('usage').add(usage_data)
+        
+        # Generate JWT token
+        token = create_jwt_token(user_id, user.email)
+        
+        return TokenResponse(
+            token=token,
+            user=UserResponse(id=user_id, email=user.email)
+        )
+        
+    except Exception as e:
+        if "Email already exists" in str(e):
+            raise e
+        print(f"Registration error: {e}")
+        raise HTTPException(status_code=500, detail="Registration failed")
+
+@app.post("/getmeajob/api/auth/login", response_model=TokenResponse)
+async def login(user: UserLogin):
+    if not db:
+        raise HTTPException(status_code=503, detail="Database not available")
+    
+    try:
+        # Get user by email
+        users_ref = db.collection('users')
+        user_query = users_ref.where('email', '==', user.email).limit(1).get()
+        
+        if not user_query:
+            raise HTTPException(status_code=401, detail="Invalid credentials")
+        
+        user_doc = user_query[0]
+        user_data = user_doc.to_dict()
+        
+        # Verify password
+        if not verify_password(user.password, user_data['password_hash']):
+            raise HTTPException(status_code=401, detail="Invalid credentials")
+        
+        # Generate JWT token
+        token = create_jwt_token(user_doc.id, user_data['email'])
+        
+        return TokenResponse(
+            token=token,
+            user=UserResponse(id=user_doc.id, email=user_data['email'])
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Login error: {e}")
+        raise HTTPException(status_code=500, detail="Login failed")
+
+@app.get("/getmeajob/api/auth/verify")
+async def verify_token(current_user: dict = Depends(get_current_user)):
+    return {
+        "valid": True,
+        "user": {
+            "id": current_user["user_id"],
+            "email": current_user["email"]
+        }
+    }
+
+@app.get("/getmeajob/api/subscription/status", response_model=SubscriptionResponse)
+async def get_subscription_status(current_user: dict = Depends(get_current_user)):
+    if not db:
+        raise HTTPException(status_code=503, detail="Database not available")
+    
+    try:
+        user_id = current_user["user_id"]
+        
+        # Get subscription info
+        subscriptions_ref = db.collection('subscriptions')
+        subscription_query = subscriptions_ref.where('user_id', '==', user_id).where('is_active', '==', True).limit(1).get()
+        
+        if not subscription_query:
+            # Create default free subscription if none exists
+            subscription_data = {
+                'user_id': user_id,
+                'plan': 'free',
+                'is_active': True,
+                'created_at': firestore.SERVER_TIMESTAMP,
+                'expires_at': None
+            }
+            db.collection('subscriptions').add(subscription_data)
+            plan = 'free'
+        else:
+            subscription_doc = subscription_query[0]
+            subscription_data = subscription_doc.to_dict()
+            plan = subscription_data.get('plan', 'free')
+        
+        is_paid = plan != 'free'
+        
+        # Get usage info for free users
+        usage_left = None
+        usage_limit = None
+        
+        if not is_paid:
+            usage_ref = db.collection('usage')
+            usage_query = usage_ref.where('user_id', '==', user_id).limit(1).get()
+            
+            if usage_query:
+                usage_doc = usage_query[0]
+                usage_data = usage_doc.to_dict()
+                usage_left = max(0, usage_data.get('usage_count', 0))
+                usage_limit = 10  # Free tier limit
+            else:
+                # Create usage record if none exists
+                usage_data = {
+                    'user_id': user_id,
+                    'usage_count': 10,
+                    'last_reset': firestore.SERVER_TIMESTAMP,
+                    'created_at': firestore.SERVER_TIMESTAMP
+                }
+                db.collection('usage').add(usage_data)
+                usage_left = 10
+                usage_limit = 10
+        
+        return SubscriptionResponse(
+            isPaid=is_paid,
+            plan=plan,
+            usageLeft=usage_left,
+            usageLimit=usage_limit
+        )
+        
+    except Exception as e:
+        print(f"Subscription status error: {e}")
+        raise HTTPException(status_code=500, detail="Failed to get subscription status")
+
+@app.get("/getmeajob/api/check-updates", response_model=UpdateResponse)
+async def check_updates():
+    return UpdateResponse(
+        latestVersion="0.1.1",  # Update this when you release new versions
+        downloadUrl="https://yashgori20.vercel.app/getmeajob/download"
+    )
+
+# Usage tracking endpoint (for decrementing usage count)
+@app.post("/getmeajob/api/usage/track")
+async def track_usage(current_user: dict = Depends(get_current_user)):
+    if not db:
+        raise HTTPException(status_code=503, detail="Database not available")
+    
+    try:
+        user_id = current_user["user_id"]
+        
+        # Get current usage
+        usage_ref = db.collection('usage')
+        usage_query = usage_ref.where('user_id', '==', user_id).limit(1).get()
+        
+        if usage_query:
+            usage_doc = usage_query[0]
+            usage_data = usage_doc.to_dict()
+            current_count = usage_data.get('usage_count', 0)
+            
+            if current_count > 0:
+                # Decrement usage count
+                usage_doc.reference.update({
+                    'usage_count': current_count - 1,
+                    'updated_at': firestore.SERVER_TIMESTAMP
+                })
+                return {"success": True, "remaining": current_count - 1}
+            else:
+                return {"success": False, "error": "No usage left"}
+        else:
+            return {"success": False, "error": "Usage record not found"}
+            
+    except Exception as e:
+        print(f"Usage tracking error: {e}")
+        raise HTTPException(status_code=500, detail="Failed to track usage")
+
+# Health check endpoint
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy", 
+        "timestamp": datetime.utcnow().isoformat(),
+        "firebase_connected": db is not None
+    }
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)  # Port 7860 is standard for Hugging Face Spaces

app_interface.py

@@ -0,0 +1,61 @@
+# This file is required for Hugging Face Spaces
+# It wraps our FastAPI app to work with Gradio interface
+
+import gradio as gr
+from app import app
+import uvicorn
+import threading
+import time
+import requests
+
+# Start FastAPI server in background thread
+def start_fastapi():
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+
+# Start the server
+thread = threading.Thread(target=start_fastapi, daemon=True)
+thread.start()
+
+# Wait for server to start
+time.sleep(3)
+
+def test_api():
+    """Test function to verify API is working"""
+    try:
+        response = requests.get("http://localhost:7860/health")
+        if response.status_code == 200:
+            return f"✅ API is running!\n\nHealth Check: {response.json()}\n\nAPI Base URL: https://yashgori20-get-me-a-job-api.hf.space/getmeajob/api/"
+        else:
+            return f"❌ API returned status code: {response.status_code}"
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+# Create Gradio interface (required for Hugging Face Spaces)
+with gr.Blocks(title="Get Me A Job API") as demo:
+    gr.Markdown("# 🚀 Get Me A Job - Backend API")
+    gr.Markdown("FastAPI backend with Firebase integration")
+    
+    with gr.Row():
+        test_btn = gr.Button("Test API Status", variant="primary")
+        result = gr.Textbox(label="API Status", lines=10)
+    
+    test_btn.click(test_api, outputs=result)
+    
+    # Auto-test on load
+    demo.load(test_api, outputs=result)
+    
+    gr.Markdown("## API Endpoints")
+    gr.Markdown("""
+    - `POST /getmeajob/api/auth/register` - User registration
+    - `POST /getmeajob/api/auth/login` - User login  
+    - `GET /getmeajob/api/auth/verify` - Token verification
+    - `GET /getmeajob/api/subscription/status` - Check subscription
+    - `GET /getmeajob/api/check-updates` - App update check
+    - `POST /getmeajob/api/usage/track` - Track API usage
+    """)
+    
+    gr.Markdown("## Integration")
+    gr.Markdown("Your Electron app will connect to: `https://yashgori20-get-me-a-job-api.hf.space/getmeajob/api/`")
+
+if __name__ == "__main__":
+    demo.launch(server_port=7860, share=True)

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+firebase-admin==6.2.0
+pydantic[email]==2.5.0
+python-multipart==0.0.6
+pyjwt==2.8.0
+bcrypt==4.0.1
+python-dotenv==1.0.0