Clarity for operations.
Control for developers.

import requests

BASE = "http://localhost:8000/v1"

# 1. Register — get token + API key
r = requests.post(f"{BASE}/auth/register", json={
    "company_name": "Acme Rides",
    "email": "ops@acme.com",
    "password": "secure123",
})
data = r.json()
token = data["token"]
api_key = data["api_key"]
H = {"Authorization": f"Bearer {token}"}

# 2. Add a vehicle
v = requests.post(f"{BASE}/vehicles", headers=H, json={
    "vehicle_number": "DL01AB1234",
    "driver_name": "Ravi",
    "driver_phone": "+919876543210",
}).json()
print(f"Vehicle: {v['vehicle_number']} (id={v['id']})")

# 3. Start a safety session
s = requests.post(f"{BASE}/sessions/start", headers=H, json={
    "vehicle_id": v["id"],
    "origin": "Delhi",
    "destination": "Noida",
}).json()
session_id = s["session_id"]
print(f"Session started: {session_id}")

# 4. Send signals — get EPS risk score in real time
result = requests.post(
    f"{BASE}/sessions/{session_id}/update",
    headers=H,
    json={
        "checkin_score": 0.1,
        "temporal_score": 0.9,
        "route_score": 0.8,
        "ai_anomaly_score": 0.7,
        "intent_score": 0.6,
        "historical_score": 0.5,
        "behavioral_score": 0.6,
        "context_score": 0.7,
    },
).json()
print(f"EPS={result['eps']:.3f} phase={result['phase']} emergency={result['emergency']}")

# 5. List alerts
alerts = requests.get(f"{BASE}/alerts", headers=H).json()
for a in alerts:
    print(f"  Alert: {a['alert_type']} severity={a.get('severity','?')}")

# 6. Acknowledge an alert
if alerts:
    requests.post(f"{BASE}/alerts/{alerts[0]['id']}/acknowledge", headers=H)

# 7. End session
requests.post(f"{BASE}/sessions/{session_id}/end", headers=H)

# 8. Register a webhook
requests.post(f"{BASE}/webhooks", headers=H, json={
    "url": "https://your-server.com/webhook",
    "events": ["alert.created", "session.ended"],
})

# API key auth also works (no JWT needed):
H2 = {"X-API-Key": api_key}
vehicles = requests.get(f"{BASE}/vehicles", headers=H2).json()

const BASE = "http://localhost:8000/v1";

// 1. Register — get token + API key
const reg = await fetch(`${BASE}/auth/register`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    company_name: "Acme Rides",
    email: "ops@acme.com",
    password: "secure123",
  }),
}).then(r => r.json());

const token = reg.token;
const apiKey = reg.api_key;
const H = {
  "Authorization": `Bearer ${token}`,
  "Content-Type": "application/json",
};

// 2. Add a vehicle
const vehicle = await fetch(`${BASE}/vehicles`, {
  method: "POST", headers: H,
  body: JSON.stringify({
    vehicle_number: "DL01AB1234",
    driver_name: "Ravi",
    driver_phone: "+919876543210",
  }),
}).then(r => r.json());
console.log(`Vehicle: ${vehicle.vehicle_number} (id=${vehicle.id})`);

// 3. Start a safety session
const session = await fetch(`${BASE}/sessions/start`, {
  method: "POST", headers: H,
  body: JSON.stringify({
    vehicle_id: vehicle.id,
    origin: "Delhi",
    destination: "Noida",
  }),
}).then(r => r.json());
const sessionId = session.session_id;

// 4. Send signals — get EPS risk score in real time
const result = await fetch(
  `${BASE}/sessions/${sessionId}/update`,
  {
    method: "POST", headers: H,
    body: JSON.stringify({
      checkin_score: 0.1,
      temporal_score: 0.9,
      route_score: 0.8,
      ai_anomaly_score: 0.7,
      intent_score: 0.6,
      historical_score: 0.5,
      behavioral_score: 0.6,
      context_score: 0.7,
    }),
  },
).then(r => r.json());
console.log(`EPS=${result.eps} phase=${result.phase} emergency=${result.emergency}`);

// 5. List alerts
const alerts = await fetch(`${BASE}/alerts`, { headers: H })
  .then(r => r.json());

// 6. Acknowledge an alert
if (alerts.length > 0) {
  await fetch(`${BASE}/alerts/${alerts[0].id}/acknowledge`, {
    method: "POST", headers: H,
  });
}

// 7. End session
await fetch(`${BASE}/sessions/${sessionId}/end`, {
  method: "POST", headers: H,
});

// 8. Register a webhook
await fetch(`${BASE}/webhooks`, {
  method: "POST", headers: H,
  body: JSON.stringify({
    url: "https://your-server.com/webhook",
    events: ["alert.created", "session.ended"],
  }),
});

// API key auth also works (no JWT needed):
const vehicles = await fetch(`${BASE}/vehicles`, {
  headers: { "X-API-Key": apiKey },
}).then(r => r.json());

// Expo / React Native — SafeRoute Mobile SDK
// Background location + motion monitoring — no button press needed

import React, { useEffect, useRef } from 'react';
import * as Location from 'expo-location';
import * as TaskManager from 'expo-task-manager';
import * as BackgroundFetch from 'expo-background-fetch';

const SAFEROUTE = 'http://localhost:8000/v1';
const API_KEY = 'sr_your_api_key';
const TASK_NAME = 'SAFETY_MONITOR';

// 1. Define the background safety task
TaskManager.defineTask(TASK_NAME, ({ data, error }) => {
  if (error) return BackgroundFetch.Result.Failed;

  const { locations } = data;
  const loc = locations[0];

  // Compute signal scores from device sensors
  const signals = {
    checkin_score: computeCheckin(loc),       // 0.0-1.0
    temporal_score: computeTemporal(loc),      // 0.0-1.0
    route_score: computeRouteDeviation(loc),   // 0.0-1.0
    ai_anomaly_score: computeAnomaly(loc),     // 0.0-1.0
    intent_score: 0.3,
    historical_score: 0.2,
    behavioral_score: 0.3,
    context_score: 0.4,
  };

  // Send to SafeRoute EPS engine — get risk score back
  fetch(`${SAFEROUTE}/sessions/${sessionId}/update`, {
    method: 'POST',
    headers: {
      'X-API-Key': API_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(signals),
  })
    .then(r => r.json())
    .then(result => {
      console.log(`EPS=${result.eps} phase=${result.phase}`);
      if (result.emergency) {
        // Alert dispatched by backend — webhook + SMS + WhatsApp
        console.log('EMERGENCY ALERT DISPATCHED');
      }
    });

  return BackgroundFetch.Result.NewData;
});

// 2. Start monitoring — call when ride begins
async function startSafetySession(vehicleId) {
  // Request permissions
  const { status } = await Location.requestForegroundPermissionsAsync();
  if (status !== 'granted') return;

  const bg = await Location.requestBackgroundPermissionsAsync();
  if (bg.status !== 'granted') return;

  // Start session via API
  const res = await fetch(`${SAFEROUTE}/sessions/start`, {
    method: 'POST',
    headers: { 'X-API-Key': API_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify({ vehicle_id: vehicleId }),
  }).then(r => r.json());

  sessionId = res.session_id;

  // Start background location tracking — every 5 seconds
  await Location.startLocationUpdatesAsync(TASK_NAME, {
    accuracy: Location.Accuracy.High,
    timeInterval: 5000,
    distanceInterval: 10,
    showsBackgroundLocationIndicator: true,
    foregroundService: {
      notificationTitle: 'Safety monitoring active',
      notificationBody: 'VV is protecting your journey',
    },
  });
}

// 3. Stop monitoring — call when ride ends
async function endSafetySession() {
  await Location.stopLocationUpdatesAsync(TASK_NAME);
  await fetch(`${SAFEROUTE}/sessions/${sessionId}/end`, {
    method: 'POST',
    headers: { 'X-API-Key': API_KEY },
  });
}

// 4. Use in your app
export default function RideScreen() {
  const sessionIdRef = useRef(null);

  useEffect(() => {
    startSafetySession('vehicle-uuid')
      .then(() => { sessionIdRef.current = sessionId; });
    return () => endSafetySession();
  }, []);

  return <Text>Safety monitoring active</Text>;
}