2309464ab8
Cherry-pick ofc8f5907(originally FIX-M20 on main) onto quality-program-2026-04-12 — renamed to FIX-M21 here to avoid clashing with this branch's existing [FIX-M20] (trip enrichment, commit144dede). Behaviour and code are unchanged from the main-branch original; the annotation tag is the only difference. Background ---------- A field audit of liveposition.rahamafresh.com on 2026-05-21 surfaced two freshness gaps that share a single root cause: tracksolid.live_positions was being written by only one path (the 60s polled sweep), and that path silently omits devices that don't have a "current" fix in Jimi's location.list response. Effect on the dashboard: * 18 vehicles show OFFLINE for days-to-months — last fix is whatever the sweep wrote before Jimi dropped them. * 3 vehicles (KDK 780K, KCQ 618K, KCZ 476E) depend on dashcam fallback because their dedicated tracker has been silent; the camera's lat/lng arrives via /pushalarm webhooks (5,287/day, 100% lat/lng fill) but we discard it after writing to tracksolid.alarms. Verified upstream subscription state: only /pushalarm is registered with Jimi; the n8n forwarders for /pushgps, /pushtripreport, /pushobd are inactive. This change uses only data that already arrives. What's in this commit --------------------- ts_shared_rev.py * upsert_live_position(cur, imei, lat, lng, gps_time, ..., extras=None) — single time-guarded upsert all three writers will share. Guards on is_valid_fix() (filters Zero-Island and out-of-range) and EXCLUDED.gps_time > stored.gps_time so late-arriving alarms or webhook retries can't rewind a fresher marker. COALESCE on optional columns so sparse callers don't blank dense ones' values. * get_stale_imeis(stale_minutes=30) — SELECT enabled_flag=1 devices whose live_positions.gps_time is NULL or older than the threshold, ordered NULLS FIRST so worst-offenders are in batch #1. * ensure_device(cur, imei, device_name=None) — relocated from webhook_receiver_rev so every live_positions writer can satisfy the FK without re-defining the helper. The original underscore-prefixed name in webhook_receiver_rev becomes a backwards-compat alias. webhook_receiver_rev.py * /pushalarm — after the alarm row insert, call upsert_live_position with the alarm's lat/lng and alarmTime. Sits inside the existing per-item SAVEPOINT, so a cross-feed failure rolls back only that one alarm's cross-feed, not the alarm row. ingest_movement_rev.py * poll_live_positions — inline INSERT replaced with upsert_live_position (extras dict carries the sweep-only columns). Same data, time-guarded. * get_device_locations — inline INSERT replaced; also gains an ensure_device call so it can be safely fed arbitrary IMEIs. * poll_stale_locations() — new wrapper. Pulls get_stale_imeis() and hands it to get_device_locations. Scheduled every 10 minutes plus a startup catch-up call. Uses jimi.device.location.get which returns *last-known* fix, so devices the 60s sweep drops can be re-warmed. Expected post-deploy effect (estimates, see 06_live_location/260521_timescale_location_upgrade_major.md §4) * ~1,100-1,600 additional live_positions upserts/day from the alarm cross-feed, after the time-guard rejects ~70-80% of races vs the fresher 60s sweep. * The 3 camera-fallback plates flip to "seconds-after-alarm" cadence (JC400P emits ~107 alarms/day per device). * 8-14 of the 24 OFFLINE plates expected to recover via location.get's last-known-fix path within the first 30 minutes. * Dashboard's "Offline 24h+" KPI: 24 → 10-14 within the first hour. * No 06_live_location code changes required — reads through reporting.v_live_positions transparently. Tests ----- 12 webhook integration tests pass (3 new: cross-feed fires on valid fix; skips without lat/lng; skips Zero-Island). 8 new unit tests in test_stale_imeis.py cover the stale selector, the poll wrapper, and the time-guard contract on upsert_live_position. Full suite: 77 passed. Deployment ---------- No schema migration. Both webhook_receiver and ingest_movement containers must be rebuilt — source is image-baked, not bind-mounted. Rollback is git revert + rebuild. Plan & monitoring SQL: 06_live_location/260521_timescale_location_upgrade_major.md Verification playbook: 06_live_location/260521_timescale_location_upgrade_verification.md Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
637 lines
27 KiB
Python
637 lines
27 KiB
Python
"""
|
||
webhook_receiver_rev.py — Fireside Communications · Tracksolid Webhook Receiver
|
||
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
RESPONSIBILITY: Receives real-time push data from Jimi Tracksolid Pro servers.
|
||
|
||
Jimi's Data Push API POSTs telemetry to these endpoints as it arrives from
|
||
devices, providing real-time ingestion without polling. This is the ONLY way
|
||
to receive OBD diagnostics and DTC fault codes — those data types have no
|
||
polling endpoint.
|
||
|
||
ENDPOINTS:
|
||
/pushobd — OBD CAN bus diagnostics (Priority 1)
|
||
/pushfaultinfo — DTC fault codes (Priority 1)
|
||
/pushalarm — Alarm events (Priority 2)
|
||
/pushgps — GPS positions (Priority 2)
|
||
/pushhb — Device heartbeats (Priority 2)
|
||
/pushtripreport — Trip reports (Priority 2)
|
||
/pushevent — Device LOGIN/LOGOUT events (Priority 3)
|
||
/health — Healthcheck for Docker/monitoring
|
||
|
||
REVISIONS (QA-Verified):
|
||
[BUG-01] OBD event_time: try unix_to_ts before clean_ts (handles epoch timestamps).
|
||
[BUG-02] push_alarm: guard also checks alarm_type is not null (prevents FK violation).
|
||
[BUG-03] push_trip_report: _parse_trip_ts handles Jimi BCD format YYMMDDHHmmss.
|
||
[BUG-04] SAVEPOINT per item in all DB-writing endpoints (one bad item won't abort batch).
|
||
[BUG-05] Added /pushevent endpoint → writes to tracksolid.device_events.
|
||
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import hmac
|
||
import json
|
||
import os
|
||
import time
|
||
from contextlib import asynccontextmanager
|
||
from datetime import datetime, timezone
|
||
from typing import Optional
|
||
|
||
# Cap on items per webhook POST. Prevents a malformed/malicious push from
|
||
# monopolising a worker or blowing the DB pool. Jimi normally sends ≤ 200.
|
||
MAX_ITEMS_PER_POST = int(os.getenv("WEBHOOK_MAX_ITEMS", "5000"))
|
||
|
||
from fastapi import FastAPI, HTTPException, Request
|
||
from fastapi.responses import JSONResponse
|
||
from psycopg2.extras import execute_values
|
||
|
||
from ts_shared_rev import (
|
||
close_pool,
|
||
get_conn,
|
||
log_ingestion,
|
||
clean,
|
||
clean_num,
|
||
clean_int,
|
||
clean_ts,
|
||
is_valid_fix,
|
||
get_logger,
|
||
ensure_device,
|
||
upsert_live_position,
|
||
)
|
||
|
||
log = get_logger("webhook")
|
||
|
||
# ── Configuration ─────────────────────────────────────────────────────────────
|
||
|
||
WEBHOOK_TOKEN = os.getenv("JIMI_WEBHOOK_TOKEN", "")
|
||
|
||
# ── Lifespan ──────────────────────────────────────────────────────────────────
|
||
|
||
@asynccontextmanager
|
||
async def lifespan(app: FastAPI):
|
||
log.info("Webhook receiver starting (v1.1)...")
|
||
yield
|
||
log.info("Webhook receiver shutting down...")
|
||
close_pool()
|
||
|
||
app = FastAPI(title="Tracksolid Webhook Receiver", lifespan=lifespan)
|
||
|
||
# ── Helpers ───────────────────────────────────────────────────────────────────
|
||
|
||
SUCCESS = {"code": 0, "msg": "success"}
|
||
|
||
|
||
def _validate_token(token: str) -> None:
|
||
"""Raise 403 if token is invalid. Skips validation if JIMI_WEBHOOK_TOKEN is empty."""
|
||
if WEBHOOK_TOKEN and not hmac.compare_digest(token, WEBHOOK_TOKEN):
|
||
raise HTTPException(status_code=403, detail="Invalid token")
|
||
|
||
|
||
def _parse_data_list(raw: str) -> list[dict]:
|
||
"""Parse a JSON string into a list of dicts. raw may be a JSON array or single object."""
|
||
try:
|
||
parsed = json.loads(raw)
|
||
items = parsed if isinstance(parsed, list) else [parsed]
|
||
if len(items) > MAX_ITEMS_PER_POST:
|
||
log.warning("data_list truncated: %d items exceeded cap of %d",
|
||
len(items), MAX_ITEMS_PER_POST)
|
||
items = items[:MAX_ITEMS_PER_POST]
|
||
return items
|
||
except (json.JSONDecodeError, TypeError):
|
||
return []
|
||
|
||
|
||
async def _parse_request(request: Request) -> tuple[str, list[dict]]:
|
||
"""Extract token + data_list from either a JSON body or form-encoded body.
|
||
|
||
Jimi's integration push API sends:
|
||
Content-Type: application/json
|
||
Body: {"token": "...", "data_list": [{...}, ...]}
|
||
|
||
Some older/configured endpoints may still use form-encoded. This helper
|
||
handles both so each endpoint doesn't need to know which format arrived.
|
||
"""
|
||
body = await request.body()
|
||
if not body:
|
||
return "", []
|
||
|
||
# Jimi integration push format (observed live):
|
||
# Content-Type: application/x-www-form-urlencoded
|
||
# Body: msgType=<topic>&data=<URL-encoded JSON object or array>
|
||
# The `data` field holds a single JSON object per event, not an array.
|
||
try:
|
||
form = await request.form()
|
||
except Exception:
|
||
log.warning("push: form parse failed", exc_info=True)
|
||
return "", []
|
||
|
||
token = str(form.get("token", ""))
|
||
raw_data = form.get("data") or form.get("data_list") or ""
|
||
if not raw_data:
|
||
return token, []
|
||
|
||
try:
|
||
parsed = json.loads(raw_data)
|
||
except (json.JSONDecodeError, TypeError):
|
||
log.warning("push: data JSON parse failed — %.200s", raw_data)
|
||
return token, []
|
||
|
||
items = parsed if isinstance(parsed, list) else [parsed]
|
||
if len(items) > MAX_ITEMS_PER_POST:
|
||
log.warning("push: truncated %d → %d items", len(items), MAX_ITEMS_PER_POST)
|
||
items = items[:MAX_ITEMS_PER_POST]
|
||
return token, items
|
||
|
||
|
||
def unix_to_ts(v) -> Optional[str]:
|
||
"""Convert Unix timestamp (seconds or milliseconds) to ISO string."""
|
||
if v is None:
|
||
return None
|
||
try:
|
||
ts = int(v)
|
||
if ts > 1e12:
|
||
ts = ts // 1000
|
||
return datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
|
||
except (ValueError, TypeError, OSError):
|
||
return None
|
||
|
||
|
||
def _parse_trip_ts(v) -> Optional[str]:
|
||
"""[BUG-03] Parse trip timestamps. Handles ISO strings and Jimi BCD formats."""
|
||
iso = clean_ts(v)
|
||
if iso:
|
||
return iso
|
||
s = clean(v)
|
||
if s is None:
|
||
return None
|
||
try:
|
||
if len(s) == 12: # YYMMDDHHmmss
|
||
return datetime.strptime(s, "%y%m%d%H%M%S").strftime("%Y-%m-%d %H:%M:%S")
|
||
if len(s) == 14: # YYYYMMDDHHmmss
|
||
return datetime.strptime(s, "%Y%m%d%H%M%S").strftime("%Y-%m-%d %H:%M:%S")
|
||
except (ValueError, TypeError):
|
||
pass
|
||
log.warning("Cannot parse trip timestamp: %r", v)
|
||
return None
|
||
|
||
|
||
def _make_geom_params(lat, lng):
|
||
"""Return (lng, lat, lng, lat) tuple for the CASE WHEN ST_MakePoint pattern."""
|
||
return (lng, lat, lng, lat)
|
||
|
||
|
||
# Backwards-compat shim. The implementation was relocated to ts_shared_rev
|
||
# (as `ensure_device`) so ingest_movement_rev and any future writer can share
|
||
# the FK-guard without re-defining it. Existing call sites in this file
|
||
# continue to use the underscore-prefixed name.
|
||
_ensure_device = ensure_device
|
||
|
||
# ── Health Check ──────────────────────────────────────────────────────────────
|
||
|
||
@app.get("/health")
|
||
def health():
|
||
return {"status": "ok"}
|
||
|
||
# ── 1. OBD Diagnostics (Priority 1) ──────────────────────────────────────────
|
||
|
||
@app.post("/pushobd")
|
||
async def push_obd(request: Request):
|
||
token, items = await _parse_request(request)
|
||
_validate_token(token)
|
||
if not items:
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
t0 = time.time()
|
||
inserted = 0
|
||
|
||
with get_conn() as conn:
|
||
with conn.cursor() as cur:
|
||
for item in items:
|
||
try:
|
||
cur.execute("SAVEPOINT sp")
|
||
imei = clean(item.get("deviceImei"))
|
||
obd = item.get("obdJson", {})
|
||
if isinstance(obd, str):
|
||
try:
|
||
obd = json.loads(obd)
|
||
except json.JSONDecodeError:
|
||
obd = {}
|
||
|
||
# [BUG-01] Try unix epoch first, fall back to ISO string.
|
||
event_time = (
|
||
unix_to_ts(obd.get("event_time"))
|
||
or clean_ts(obd.get("event_time"))
|
||
)
|
||
if not imei or not event_time:
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
continue
|
||
|
||
lat = clean_num(obd.get("lat"))
|
||
lng = clean_num(obd.get("lng"))
|
||
|
||
cur.execute("""
|
||
INSERT INTO tracksolid.obd_readings (
|
||
imei, reading_time, car_type, acc_state, status_flags,
|
||
lat, lng, geom, obd_data, updated_at
|
||
) VALUES (
|
||
%s, %s, %s, %s, %s, %s, %s,
|
||
CASE WHEN %s IS NOT NULL AND %s IS NOT NULL
|
||
THEN ST_SetSRID(ST_MakePoint(%s, %s), 4326)
|
||
ELSE NULL END,
|
||
%s, NOW()
|
||
) ON CONFLICT (imei, reading_time) DO UPDATE SET
|
||
obd_data = EXCLUDED.obd_data,
|
||
updated_at = NOW()
|
||
""", (
|
||
imei, event_time,
|
||
clean_int(obd.get("car_type")),
|
||
clean_int(obd.get("AccState")),
|
||
clean_int(obd.get("statusFlags")),
|
||
lat, lng,
|
||
*_make_geom_params(lat, lng),
|
||
json.dumps(obd),
|
||
))
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
inserted += 1
|
||
except Exception:
|
||
cur.execute("ROLLBACK TO SAVEPOINT sp")
|
||
log.warning("Failed to process OBD item for %s", item.get("deviceImei"), exc_info=True)
|
||
|
||
log_ingestion(cur, "webhook/pushobd", len(items), 0, inserted,
|
||
int((time.time() - t0) * 1000), True)
|
||
|
||
log.info("pushobd: %d/%d items processed.", inserted, len(items))
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
# ── 2. DTC Fault Codes (Priority 1) ──────────────────────────────────────────
|
||
|
||
@app.post("/pushfaultinfo")
|
||
async def push_fault_info(request: Request):
|
||
token, items = await _parse_request(request)
|
||
_validate_token(token)
|
||
if not items:
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
t0 = time.time()
|
||
inserted = 0
|
||
|
||
with get_conn() as conn:
|
||
with conn.cursor() as cur:
|
||
for item in items:
|
||
try:
|
||
cur.execute("SAVEPOINT sp")
|
||
imei = clean(item.get("deviceImei"))
|
||
gate_time = clean_ts(item.get("gateTime"))
|
||
if not imei or not gate_time:
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
continue
|
||
|
||
fault_codes = item.get("faultCodeList", [])
|
||
if isinstance(fault_codes, str):
|
||
try:
|
||
fault_codes = json.loads(fault_codes)
|
||
except json.JSONDecodeError:
|
||
fault_codes = []
|
||
|
||
lat = clean_num(item.get("lat"))
|
||
lng = clean_num(item.get("lng"))
|
||
evt_time = unix_to_ts(item.get("eventTime")) or clean_ts(item.get("eventTime"))
|
||
|
||
for code in fault_codes:
|
||
fault_code = clean(code)
|
||
# Guard NULL: ON CONFLICT won't deduplicate NULL fault_codes
|
||
# because NULL != NULL in Postgres unique constraints.
|
||
if not fault_code:
|
||
continue
|
||
cur.execute("""
|
||
INSERT INTO tracksolid.fault_codes (
|
||
imei, reported_at, fault_code, status_flags,
|
||
lat, lng, geom, event_time
|
||
) VALUES (
|
||
%s, %s, %s, %s, %s, %s,
|
||
CASE WHEN %s IS NOT NULL AND %s IS NOT NULL
|
||
THEN ST_SetSRID(ST_MakePoint(%s, %s), 4326)
|
||
ELSE NULL END,
|
||
%s
|
||
) ON CONFLICT (imei, reported_at, fault_code) DO NOTHING
|
||
""", (
|
||
imei, gate_time, fault_code,
|
||
clean_int(item.get("statusFlags")),
|
||
lat, lng,
|
||
*_make_geom_params(lat, lng),
|
||
evt_time,
|
||
))
|
||
inserted += 1
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
except Exception:
|
||
cur.execute("ROLLBACK TO SAVEPOINT sp")
|
||
log.warning("Failed to process fault item for %s", item.get("deviceImei"), exc_info=True)
|
||
|
||
log_ingestion(cur, "webhook/pushfaultinfo", len(items), 0, inserted,
|
||
int((time.time() - t0) * 1000), True)
|
||
|
||
log.info("pushfaultinfo: %d fault codes from %d items.", inserted, len(items))
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
# ── 3. Alarm Events (Priority 2) ─────────────────────────────────────────────
|
||
|
||
@app.post("/pushalarm")
|
||
async def push_alarm(request: Request):
|
||
token, items = await _parse_request(request)
|
||
_validate_token(token)
|
||
if not items:
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
t0 = time.time()
|
||
inserted = 0
|
||
|
||
with get_conn() as conn:
|
||
with conn.cursor() as cur:
|
||
for item in items:
|
||
try:
|
||
cur.execute("SAVEPOINT sp")
|
||
# Jimi integration push uses `imei` + `alarmTime`, NOT the
|
||
# `deviceImei` + `gateTime` fields shown in the API docs.
|
||
imei = clean(item.get("imei") or item.get("deviceImei"))
|
||
alarm_type = clean(item.get("alarmType"))
|
||
alarm_time = clean_ts(item.get("alarmTime") or item.get("gateTime"))
|
||
# [BUG-02] Also guard alarm_type — NULL alarm_type violates NOT NULL constraint.
|
||
if not imei or not alarm_time or not alarm_type:
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
continue
|
||
|
||
# Ensure parent devices row exists to satisfy FK constraint.
|
||
_ensure_device(cur, imei, clean(item.get("deviceName")))
|
||
|
||
lat = clean_num(item.get("lat"))
|
||
lng = clean_num(item.get("lng"))
|
||
|
||
cur.execute("""
|
||
INSERT INTO tracksolid.alarms (
|
||
imei, alarm_type, alarm_name, alarm_time, geom,
|
||
lat, lng, speed, source, updated_at
|
||
) VALUES (
|
||
%s, %s, %s, %s,
|
||
CASE WHEN %s IS NOT NULL AND %s IS NOT NULL
|
||
THEN ST_SetSRID(ST_MakePoint(%s, %s), 4326)
|
||
ELSE NULL END,
|
||
%s, %s, %s, 'push', NOW()
|
||
) ON CONFLICT (imei, alarm_type, alarm_time) DO NOTHING
|
||
""", (
|
||
imei, alarm_type, clean(item.get("alarmName")), alarm_time,
|
||
*_make_geom_params(lat, lng),
|
||
lat, lng,
|
||
clean_num(item.get("speed")),
|
||
))
|
||
|
||
# [FIX-M21] Cross-feed: every Jimi alarm carries lat/lng.
|
||
# Refresh live_positions so dashboard markers don't have to
|
||
# wait up to 60s for the next polled sweep. Time-guarded
|
||
# inside the helper — alarms older than the current fix lose.
|
||
upsert_live_position(
|
||
cur, imei, lat, lng, alarm_time,
|
||
speed=clean_num(item.get("speed")),
|
||
)
|
||
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
inserted += 1
|
||
except Exception:
|
||
cur.execute("ROLLBACK TO SAVEPOINT sp")
|
||
log.warning("Failed to process alarm for %s",
|
||
item.get("imei") or item.get("deviceImei"), exc_info=True)
|
||
|
||
log_ingestion(cur, "webhook/pushalarm", len(items), 0, inserted,
|
||
int((time.time() - t0) * 1000), True)
|
||
|
||
log.info("pushalarm: %d/%d items processed.", inserted, len(items))
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
# ── 4. GPS Positions (Priority 2) ────────────────────────────────────────────
|
||
|
||
@app.post("/pushgps")
|
||
async def push_gps(request: Request):
|
||
token, items = await _parse_request(request)
|
||
_validate_token(token)
|
||
if not items:
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
t0 = time.time()
|
||
# Validation phase — pre-clean and filter without touching the DB.
|
||
# Per-row INSERT with SAVEPOINT was ~1 ms/row overhead at this volume;
|
||
# one batched execute_values is 10-50× faster for the same rows.
|
||
rows = []
|
||
for item in items:
|
||
imei = clean(item.get("deviceImei"))
|
||
gps_time = clean_ts(item.get("gpsTime"))
|
||
lat = clean_num(item.get("lat"))
|
||
lng = clean_num(item.get("lng"))
|
||
if not imei or not gps_time or not is_valid_fix(lat, lng):
|
||
continue
|
||
rows.append((
|
||
imei, gps_time, lng, lat, lat, lng,
|
||
clean_num(item.get("gpsSpeed")),
|
||
clean_num(item.get("direction")),
|
||
str(item.get("acc")) if item.get("acc") is not None else None,
|
||
clean_int(item.get("satelliteNum")),
|
||
clean_num(item.get("distance")),
|
||
clean_num(item.get("altitude")),
|
||
clean_int(item.get("postType")),
|
||
))
|
||
|
||
inserted = 0
|
||
if rows:
|
||
with get_conn() as conn:
|
||
with conn.cursor() as cur:
|
||
execute_values(
|
||
cur,
|
||
"""
|
||
INSERT INTO tracksolid.position_history (
|
||
imei, gps_time, geom, lat, lng, speed, direction,
|
||
acc_status, satellite, current_mileage,
|
||
altitude, post_type, source
|
||
) VALUES %s
|
||
ON CONFLICT (imei, gps_time) DO NOTHING
|
||
""",
|
||
rows,
|
||
template="(%s, %s, ST_SetSRID(ST_MakePoint(%s, %s), 4326),"
|
||
" %s, %s, %s, %s, %s, %s, %s, %s, %s, 'push')",
|
||
page_size=len(rows),
|
||
)
|
||
inserted = cur.rowcount
|
||
log_ingestion(cur, "webhook/pushgps", len(items), 0, inserted,
|
||
int((time.time() - t0) * 1000), True)
|
||
else:
|
||
# No valid rows, still record the call for observability.
|
||
with get_conn() as conn:
|
||
with conn.cursor() as cur:
|
||
log_ingestion(cur, "webhook/pushgps", len(items), 0, 0,
|
||
int((time.time() - t0) * 1000), True)
|
||
|
||
log.info("pushgps: %d/%d items inserted.", inserted, len(items))
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
# ── 5. Device Heartbeats (Priority 2) ────────────────────────────────────────
|
||
|
||
@app.post("/pushhb")
|
||
async def push_heartbeat(request: Request):
|
||
token, items = await _parse_request(request)
|
||
_validate_token(token)
|
||
if not items:
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
t0 = time.time()
|
||
inserted = 0
|
||
|
||
with get_conn() as conn:
|
||
with conn.cursor() as cur:
|
||
for item in items:
|
||
try:
|
||
cur.execute("SAVEPOINT sp")
|
||
imei = clean(item.get("deviceImei"))
|
||
gate_time = clean_ts(item.get("gateTime"))
|
||
if not imei or not gate_time:
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
continue
|
||
|
||
cur.execute("""
|
||
INSERT INTO tracksolid.heartbeats (
|
||
imei, gate_time, power_level, gsm_signal,
|
||
acc_status, power_status, fortify
|
||
) VALUES (%s, %s, %s, %s, %s, %s, %s)
|
||
ON CONFLICT (imei, gate_time) DO NOTHING
|
||
""", (
|
||
imei, gate_time,
|
||
clean_int(item.get("powerLevel")),
|
||
clean_int(item.get("gsmSign")),
|
||
clean_int(item.get("acc")),
|
||
clean_int(item.get("powerStatus")),
|
||
clean_int(item.get("fortify")),
|
||
))
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
inserted += 1
|
||
except Exception:
|
||
cur.execute("ROLLBACK TO SAVEPOINT sp")
|
||
log.warning("Failed to process heartbeat for %s", item.get("deviceImei"), exc_info=True)
|
||
|
||
log_ingestion(cur, "webhook/pushhb", len(items), 0, inserted,
|
||
int((time.time() - t0) * 1000), True)
|
||
|
||
log.info("pushhb: %d/%d items processed.", inserted, len(items))
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
# ── 6. Trip Reports (Priority 2) ─────────────────────────────────────────────
|
||
|
||
@app.post("/pushtripreport")
|
||
async def push_trip_report(request: Request):
|
||
token, items = await _parse_request(request)
|
||
_validate_token(token)
|
||
if not items:
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
t0 = time.time()
|
||
inserted = 0
|
||
|
||
with get_conn() as conn:
|
||
with conn.cursor() as cur:
|
||
for item in items:
|
||
try:
|
||
cur.execute("SAVEPOINT sp")
|
||
imei = clean(item.get("deviceImei"))
|
||
# [BUG-03] Use _parse_trip_ts to handle Jimi BCD format YYMMDDHHmmss.
|
||
begin_time = _parse_trip_ts(item.get("beginTime"))
|
||
end_time = _parse_trip_ts(item.get("endTime"))
|
||
if not imei or not begin_time:
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
continue
|
||
|
||
# [FIX-M11] API sends km. Store directly as distance_km.
|
||
distance_km = clean_num(item.get("miles"))
|
||
|
||
begin_lat = clean_num(item.get("beginLat"))
|
||
begin_lng = clean_num(item.get("beginLng"))
|
||
end_lat = clean_num(item.get("endLat"))
|
||
end_lng = clean_num(item.get("endLng"))
|
||
|
||
cur.execute("""
|
||
INSERT INTO tracksolid.trips (
|
||
imei, start_time, end_time, distance_km,
|
||
start_geom, end_geom,
|
||
fuel_consumed_l, idle_time_s, trip_seq, source,
|
||
updated_at
|
||
) VALUES (
|
||
%s, %s, %s, %s,
|
||
CASE WHEN %s IS NOT NULL AND %s IS NOT NULL
|
||
THEN ST_SetSRID(ST_MakePoint(%s, %s), 4326)
|
||
ELSE NULL END,
|
||
CASE WHEN %s IS NOT NULL AND %s IS NOT NULL
|
||
THEN ST_SetSRID(ST_MakePoint(%s, %s), 4326)
|
||
ELSE NULL END,
|
||
%s, %s, %s, 'push', NOW()
|
||
) ON CONFLICT (imei, start_time) DO UPDATE SET
|
||
end_time = EXCLUDED.end_time,
|
||
distance_km = EXCLUDED.distance_km,
|
||
end_geom = EXCLUDED.end_geom,
|
||
fuel_consumed_l = EXCLUDED.fuel_consumed_l,
|
||
idle_time_s = EXCLUDED.idle_time_s,
|
||
updated_at = NOW()
|
||
""", (
|
||
imei, begin_time, end_time, distance_km,
|
||
begin_lng, begin_lat, begin_lng, begin_lat,
|
||
end_lng, end_lat, end_lng, end_lat,
|
||
clean_num(item.get("oils")),
|
||
clean_int(item.get("idleTimes")),
|
||
clean_int(item.get("tripSeq")),
|
||
))
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
inserted += 1
|
||
except Exception:
|
||
cur.execute("ROLLBACK TO SAVEPOINT sp")
|
||
log.warning("Failed to process trip for %s", item.get("deviceImei"), exc_info=True)
|
||
|
||
log_ingestion(cur, "webhook/pushtripreport", len(items), 0, inserted,
|
||
int((time.time() - t0) * 1000), True)
|
||
|
||
log.info("pushtripreport: %d/%d items processed.", inserted, len(items))
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
# ── 7. Device Events (LOGIN / LOGOUT) ────────────────────────────────────────
|
||
|
||
@app.post("/pushevent")
|
||
async def push_event(request: Request):
|
||
token, items = await _parse_request(request)
|
||
_validate_token(token)
|
||
if not items:
|
||
return JSONResponse(content=SUCCESS)
|
||
|
||
t0 = time.time()
|
||
inserted = 0
|
||
|
||
with get_conn() as conn:
|
||
with conn.cursor() as cur:
|
||
for item in items:
|
||
try:
|
||
cur.execute("SAVEPOINT sp")
|
||
imei = clean(item.get("deviceImei"))
|
||
event_type = clean(item.get("type"))
|
||
event_time = clean_ts(item.get("gateTime"))
|
||
if not imei or not event_type or not event_time:
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
continue
|
||
|
||
cur.execute("""
|
||
INSERT INTO tracksolid.device_events
|
||
(imei, event_type, event_time, timezone)
|
||
VALUES (%s, %s, %s, %s)
|
||
ON CONFLICT (imei, event_type, event_time) DO NOTHING
|
||
""", (imei, event_type, event_time, clean(item.get("timezone"))))
|
||
cur.execute("RELEASE SAVEPOINT sp")
|
||
inserted += 1
|
||
except Exception:
|
||
cur.execute("ROLLBACK TO SAVEPOINT sp")
|
||
log.warning("Failed to process event for %s", item.get("deviceImei"), exc_info=True)
|
||
|
||
log_ingestion(cur, "webhook/pushevent", len(items), 0, inserted,
|
||
int((time.time() - t0) * 1000), True)
|
||
|
||
log.info("pushevent: %d/%d items processed.", inserted, len(items))
|
||
return JSONResponse(content=SUCCESS)
|