connect to the ML prediction API

.env.example

@@ -4,6 +4,11 @@ DATABASE_URL=
 # If set, protects the API from unauthorized called
 FASTAPI_API_KEY=
 
+# API of the ML model
+FRAUD_ML_API_KEY=
+FRAUD_ML_HEALTHCHECK_ENDPOINT=
+FRAUD_ML_PREDICTION_ENDPOINT=
+
 # Mail notification configurations
 RECEIVER_EMAIL="jedha.fraud@yopmail.com"
 

src/entity/api/fraud_prediction_api.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class FraudPredictionInput(BaseModel):
+    """
+    FraudPredictionInput is a class that represents the input data for fraud prediction.
+    """
+    transaction_category: str
+    transaction_amount: float
+    customer_job: str
+    customer_address_state: str
+    customer_address_city: str
+    customer_address_city_population: int
+
+class FraudPredictionOutput(BaseModel):
+    """
+    FraudPredictionOutput is a class that represents the output data for fraud prediction.
+    """
+    result: int
+    fraud_probability: float
+    model_metadata: dict

src/main.py

@@ -1,6 +1,7 @@
 import os
 import logging
 import secrets
+import requests
 from typing import Annotated
 from fastapi import (
     FastAPI,
@@ -10,19 +11,22 @@ from fastapi import (
     Depends
 )
 from fastapi.background import BackgroundTasks
-from fastapi.responses import RedirectResponse
+from fastapi.responses import RedirectResponse, JSONResponse
 from fastapi.security.api_key import APIKeyHeader
 from pydantic import BaseModel, Field
 from psycopg.errors import UniqueViolation, IntegrityError
 from starlette.status import (
+    HTTP_200_OK,
     HTTP_403_FORBIDDEN,
     HTTP_422_UNPROCESSABLE_ENTITY,
-    HTTP_500_INTERNAL_SERVER_ERROR)
+    HTTP_500_INTERNAL_SERVER_ERROR,
+    HTTP_503_SERVICE_UNAVAILABLE)
 from dotenv import load_dotenv
 from src.entity.api.transaction_api import TransactionApi
+from sqlalchemy import text
 from sqlalchemy.orm import Session
 
-from src.service.fraud_service import check_for_fraud
+from src.service.fraud_service import check_for_fraud_api
 from src.service.notification_service import send_notification
 from src.repository.common import get_session
 from src.repository.fraud_details_repo import insert_fraud
@@ -32,6 +36,8 @@ from src.repository.transaction_repo import insert_transaction
 
 load_dotenv()
 FASTAPI_API_KEY = os.getenv("FASTAPI_API_KEY")
+FRAUD_ML_API_KEY = os.getenv("FRAUD_ML_API_KEY")
+FRAUD_ML_HEALTHCHECK_ENDPOINT = os.getenv("FRAUD_ML_HEALTHCHECK_ENDPOINT")
 safe_clients = ['127.0.0.1']
 
 api_key_header = APIKeyHeader(name='Authorization', auto_error=False)
@@ -120,15 +126,16 @@ async def process_transaction(
             detail="An error occurred while processing the transaction. See logs for details."
         )
     
-    # Check for fraud
-    is_fraud = check_for_fraud(transaction)
+    # Call the fraud detection API
+    fraud_output = check_for_fraud_api(transaction)
+    is_fraud = fraud_output.result == 1
 
     if is_fraud:
         insert_fraud(
             db=db,
             transaction=transaction,
-            fraud_score=0.5,
-            model_version='latest'
+            fraud_score=fraud_output.fraud_probability,
+            model_version=fraud_output.model_metadata['model_version'] if 'model_version' in fraud_output.model_metadata else 'unknown'
         )
 
         # Send notification to the user
@@ -138,8 +145,8 @@ async def process_transaction(
 
     # Return the result
     output = {
-        'is_fraud': 1 if is_fraud else 0,
-        'fraud_score': 0.5 if is_fraud else 0.0
+        'is_fraud': fraud_output.result,
+        'fraud_score': fraud_output.fraud_probability
     }
 
     return output
@@ -150,18 +157,22 @@ async def check_health(session: Annotated[Session, Depends(get_session)]):
     """
     Check all the services in the infrastructure are working
     """
-    healthy = 0
-    unhealthy = 1
-
-    # DB check
-    db_status = False
+    # Check if the database is alive
     try:
-        session.execute("SELECT 1")
-        db_status = True
-    except Exception:
-        pass
-
-    if db_status:
-        return healthy
-    else:
-        return unhealthy
+        session.execute(text("SELECT 1"))
+    except Exception as e:
+        logging.error(f"DB check failed: {e}")
+        return JSONResponse(content={"status": "unhealthy"}, status_code=HTTP_503_SERVICE_UNAVAILABLE)
+    
+    # Check if the fraud detection API is alive
+    response = requests.get(FRAUD_ML_HEALTHCHECK_ENDPOINT,
+                            headers={
+                                'Content-Type': 'application/json',
+                                'Authorization': FRAUD_ML_API_KEY,
+                            })
+    
+    if response.status_code != HTTP_200_OK:
+        logging.error(f"Fraud detection API check failed: {response.status_code} - {response.text}")
+        return JSONResponse(content={"status": "unhealthy"}, status_code=HTTP_503_SERVICE_UNAVAILABLE)
+    
+    return JSONResponse(content={"status": "healthy"}, status_code=HTTP_200_OK)

src/service/fraud_service.py

@@ -1,10 +1,56 @@
+import os
 import logging
+from typing import Optional
+import requests
 from src.entity.transaction import Transaction
+from src.entity.api.fraud_prediction_api import FraudPredictionInput, FraudPredictionOutput
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Set up the API key and endpoint
+FRAUD_ML_API_KEY = os.getenv("FRAUD_ML_API_KEY")
+FRAUD_ML_PREDICTION_ENDPOINT = os.getenv("FRAUD_ML_PREDICTION_ENDPOINT")
 
 # Configure logging
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
+def check_for_fraud_api(transaction: Transaction) -> Optional[FraudPredictionOutput]:
+    """
+    Check for fraud in the transaction API.
+    """
+    logger.debug("Checking for fraud in the API...")
+    
+    # Create an instance of the FraudPredictionInput model
+    fraud_input = FraudPredictionInput(
+        transaction_category=transaction.transaction_category,
+        transaction_amount=transaction.transaction_amount,
+        customer_job=transaction.customer_job,
+        customer_address_state=transaction.customer_address_state,
+        customer_address_city=transaction.customer_address_city,
+        customer_address_city_population=transaction.customer_address_city_population
+    )
+
+    # Send a POST request to the fraud detection API
+    response = requests.post(FRAUD_ML_PREDICTION_ENDPOINT,
+                             json=fraud_input.model_dump(mode='json'),
+                             headers={
+                                 'Content-Type': 'application/json',
+                                 'Authorization': FRAUD_ML_API_KEY,
+                             })
+    
+    if response.status_code == 200:
+        fraud_response = response.json()
+        logger.info(f"Fraud detection API response: {fraud_response}")
+
+        fraud_output = FraudPredictionOutput(**fraud_response)
+
+        return fraud_output
+    else:
+        logger.error(f"Failed to call fraud detection API: {response.status_code} - {response.text}")
+        return None
 
 def check_for_fraud(transaction: Transaction) -> bool:
     """