Working Supabase connection and receipt request processing

api/receipt_routes.py

@@ -1,28 +1,66 @@
-from fastapi import APIRouter, File, UploadFile, HTTPException
+from fastapi import APIRouter, File, UploadFile, HTTPException, Request, Depends
 from receipt_processor.google_ocr import GoogleVisionOCR
 from receipt_processor.parsers.parser_selector import ParserSelector
+from db.receipt_repository import ReceiptRepository
+from utils.rate_limiter import RateLimiter
+import re
 
 # Initialize OCR and parser selector
+rate_limiter = RateLimiter(max_requests=5)
+receipt_repository = ReceiptRepository()
 ocr_processor = GoogleVisionOCR()
 parser_selector = ParserSelector()
 
 router = APIRouter(prefix="/receipts", tags=["Receipt Processing"])
 
 @router.post("/scan")
-async def process_receipt(file: UploadFile = File(...)):
+async def process_receipt(
+    request: Request,
+    file: UploadFile = File(...),
+    client_ip: str = Depends(rate_limiter.check_rate_limit)
+):
     try:
+        print(f"Received file: {file.filename} ({file.content_type})")
+        
+        # Read the file content
         content = await file.read()
+        print(f"File size: {len(content)} bytes")
+        
+        # Extract text using Google OCR
         extracted_text = ocr_processor.extract_text(content)
+        print(f"Extracted text length: {len(extracted_text)} chars")
         
         if not extracted_text:
             raise HTTPException(400, "No text extracted from image")
 
+        # Select and use appropriate parser
         parser = parser_selector.get_store_parser(extracted_text)
+        print(f"Using parser: {parser.__class__.__name__}")
+        
         parsed_receipt = parser.parse(extracted_text)
+        print("Parsing completed successfully")
+        
+        # Try to extract date from the receipt
+        receipt_date = None
+        date_match = re.search(r'(\d{2}[./]\d{2}[./]\d{2,4})', extracted_text)
+        if date_match:
+            receipt_date = date_match.group(1)
+        
+        # Store the receipt in Supabase
+        receipt_repository.create_receipt_request(
+            receipt_image=content,
+            parsed_data=parsed_receipt,
+            receipt_date=receipt_date,
+            submission_ip=client_ip
+        )
         
         return {
             "status": "success",
-            "receipt": parsed_receipt
+            "message": "Receipt submitted successfully and pending review."
         }
+
+    except HTTPException as e:
+        raise e
     except Exception as e:
+        print(f"ERROR: {str(e)}")
         raise HTTPException(500, f"Receipt processing error: {str(e)}")

config/settings.py

@@ -1,3 +1,8 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
 # Model config
 MODEL_ONNX_PATH = "product_detector/models/model.onnx"
 CLASS_NAMES = [
@@ -33,5 +38,12 @@ INPUT_SIZE = 640
 API_HOST = "0.0.0.0"
 API_PORT = 7860
 
+# Rate limiting
+MAX_RECEIPTS_PER_HOUR = 5
+
+# Supabase
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+
 # Google OCR config
 GOOGLE_VISION_KEY_PATH = "receipt-vision-key.json"

db/receipt_repository.py

@@ -0,0 +1,82 @@
+import uuid
+import json
+import base64
+from datetime import datetime
+from typing import Optional, Dict, Any
+from .supabase_client import SupabaseClient
+
+class ReceiptRepository:
+    def __init__(self):
+        self.supabase = SupabaseClient().get_client()
+    
+    def create_receipt_request(
+        self, 
+        receipt_image: bytes, 
+        parsed_data: Dict[str, Any],
+        receipt_date: Optional[str] = None,
+        submission_ip: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Store a new receipt request in the database
+        """
+        base64_image = base64.b64encode(receipt_image).decode('utf-8')
+        
+        receipt_data = {
+            "receipt_image": base64_image,
+            "parsed_data": json.dumps(parsed_data),
+            "receipt_date": receipt_date,
+            "request_status": "pending",
+            "submission_ip": submission_ip
+        }
+        
+        result = self.supabase.table("receipt_requests").insert(receipt_data).execute()
+        
+        if len(result.data) > 0:
+            return result.data[0]
+        else:
+            raise Exception("Failed to create receipt request")
+    
+    def get_submission_count(self, ip_address: str) -> int:
+        """
+        Get the number of submissions from a specific IP in the last hour
+        """
+        # Get current rate limit record
+        result = self.supabase.table("submission_rate_limits") \
+            .select("*") \
+            .eq("ip_address", ip_address) \
+            .execute()
+            
+        # Check if the IP has a record
+        if len(result.data) == 0:
+            # Create new record
+            self.supabase.table("submission_rate_limits").insert({
+                "ip_address": ip_address,
+                "submission_count": 1,
+                "window_start_time": datetime.now().isoformat()
+            }).execute()
+            return 1
+        
+        # Get the existing record
+        record = result.data[0]
+        window_start = datetime.fromisoformat(record["window_start_time"])
+        current_time = datetime.now()
+        
+        # If the window is older than 1 hour, reset it
+        if (current_time - window_start).total_seconds() > 3600:
+            self.supabase.table("submission_rate_limits") \
+                .update({
+                    "submission_count": 1,
+                    "window_start_time": current_time.isoformat()
+                }) \
+                .eq("ip_address", ip_address) \
+                .execute()
+            return 1
+        
+        # Increment the counter
+        new_count = record["submission_count"] + 1
+        self.supabase.table("submission_rate_limits") \
+            .update({"submission_count": new_count}) \
+            .eq("ip_address", ip_address) \
+            .execute()
+            
+        return new_count

db/supabase_client.py

@@ -0,0 +1,21 @@
+import os
+from supabase import create_client, Client
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class SupabaseClient:
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(SupabaseClient, cls).__new__(cls)
+            # Initialize the Supabase client
+            url = os.getenv("SUPABASE_URL")
+            key = os.getenv("SUPABASE_KEY")
+            cls._instance.client = create_client(url, key)
+        return cls._instance
+
+    def get_client(self) -> Client:
+        return self.client

requirements.txt

@@ -7,4 +7,6 @@ Pillow
 torch
 ultralytics
 python-multipart
-google-cloud-vision
+google-cloud-vision
+python-dotenv
+supabase

utils/rate_limiter.py

@@ -0,0 +1,25 @@
+from fastapi import Request, HTTPException
+from db.receipt_repository import ReceiptRepository
+
+class RateLimiter:
+    def __init__(self, max_requests: int = 5):
+        self.max_requests = max_requests
+        self.repository = ReceiptRepository()
+    
+    async def check_rate_limit(self, request: Request):
+        """
+        Check if the client has exceeded the rate limit
+        """
+        client_ip = request.client.host
+        
+        # Get the current submission count for this IP
+        submission_count = self.repository.get_submission_count(client_ip)
+        
+        # If they've exceeded the limit, raise an exception
+        if submission_count > self.max_requests:
+            raise HTTPException(
+                status_code=429,
+                detail=f"Rate limit exceeded. Maximum {self.max_requests} receipts per hour."
+            )
+        
+        return client_ip