upload batch

app.py

@@ -1,5 +1,19 @@
-from fastapi import FastAPI, HTTPException, Request, Form, Depends, status, APIRouter, Header
-from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse, StreamingResponse
+from fastapi import (
+    FastAPI,
+    HTTPException,
+    Request,
+    Form,
+    Depends,
+    status,
+    APIRouter,
+    Header,
+)
+from fastapi.responses import (
+    HTMLResponse,
+    RedirectResponse,
+    JSONResponse,
+    StreamingResponse,
+)
 from fastapi.templating import Jinja2Templates
 from fastapi.staticfiles import StaticFiles
 from fastapi.security import HTTPBasic
@@ -11,18 +25,21 @@ from folium.plugins import MarkerCluster
 from typing import Optional
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker, Session
-from models import Base, User, StatusRecord, SystemSetting, Device
+from models import Base, User, StatusRecord, SystemSetting, Device, StatusRecordBatch
 import io
 import csv
 from typing import Dict
 
 # Database setup
 SQLALCHEMY_DATABASE_URL = "sqlite:///./database.db"
-engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
+)
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
 Base.metadata.create_all(bind=engine)
 
+
 # Create default admin user and system settings
 def create_default_data():
     db = SessionLocal()
@@ -34,7 +51,7 @@ def create_default_data():
                 email="[email protected]",
                 password="admin",
                 is_admin=True,
-                is_active=True
+                is_active=True,
             )
             db.add(admin_user)
 
@@ -50,6 +67,7 @@ def create_default_data():
     finally:
         db.close()
 
+
 create_default_data()
 
 app = FastAPI()
@@ -60,6 +78,7 @@ security = HTTPBasic()
 admin_router = APIRouter(prefix="/admin", tags=["admin"])
 api_router = APIRouter(prefix="/api", tags=["api"])
 
+
 # Dependency to get the database session
 def get_db():
     db = SessionLocal()
@@ -68,12 +87,14 @@ def get_db():
     finally:
         db.close()
 
+
 def get_current_user(request: Request, db: Session = Depends(get_db)) -> Optional[User]:
     username = request.cookies.get("username")
     if username:
         return db.query(User).filter(User.username == username).first()
     return None
 
+
 def login_required(request: Request, db: Session = Depends(get_db)):
     username = request.cookies.get("username")
     if not username:
@@ -83,27 +104,50 @@ def login_required(request: Request, db: Session = Depends(get_db)):
         return RedirectResponse(url="/login", status_code=status.HTTP_302_FOUND)
     return user
 
+
 # Device authentication function
-def authenticate_device(device_id: str, device_password: str, db: Session = Depends(get_db)):
+def authenticate_device(
+    device_id: str, device_password: str, db: Session = Depends(get_db)
+):
     device = db.query(Device).filter(Device.device_id == device_id).first()
     if not device or device.password != device_password:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid device credentials")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid device credentials",
+        )
     return device
 
+
 @app.get("/login", response_class=HTMLResponse)
 async def login_page(request: Request):
     return templates.TemplateResponse("login.html", {"request": request})
 
+
 @app.post("/login")
-async def login(request: Request, username: str = Form(...), password: str = Form(...), db: Session = Depends(get_db)):
-    user = db.query(User).filter(User.username == username, User.password == password, User.is_active == True).first()
+async def login(
+    request: Request,
+    username: str = Form(...),
+    password: str = Form(...),
+    db: Session = Depends(get_db),
+):
+    user = (
+        db.query(User)
+        .filter(
+            User.username == username, User.password == password, User.is_active == True
+        )
+        .first()
+    )
     if user:
         user.last_login = datetime.now()
         db.commit()
         response = RedirectResponse(url="/", status_code=status.HTTP_302_FOUND)
         response.set_cookie(key="username", value=username, httponly=True)
         return response
-    return templates.TemplateResponse("login.html", {"request": request, "error": "Invalid credentials or inactive account"})
+    return templates.TemplateResponse(
+        "login.html",
+        {"request": request, "error": "Invalid credentials or inactive account"},
+    )
+
 
 @app.get("/logout")
 async def logout():
@@ -111,20 +155,30 @@ async def logout():
     response.delete_cookie("username")
     return response
 
+
 @app.get("/register", response_class=HTMLResponse)
 async def register_page(request: Request):
     return templates.TemplateResponse("register.html", {"request": request})
 
+
 @app.post("/register")
-async def register(username: str = Form(...), email: str = Form(...), password: str = Form(...), db: Session = Depends(get_db)):
+async def register(
+    username: str = Form(...),
+    email: str = Form(...),
+    password: str = Form(...),
+    db: Session = Depends(get_db),
+):
     existing_user = db.query(User).filter(User.username == username).first()
     if existing_user:
-        return RedirectResponse(url="/register?error=1", status_code=status.HTTP_302_FOUND)
+        return RedirectResponse(
+            url="/register?error=1", status_code=status.HTTP_302_FOUND
+        )
     new_user = User(username=username, email=email, password=password)
     db.add(new_user)
     db.commit()
     return RedirectResponse(url="/login", status_code=status.HTTP_302_FOUND)
 
+
 # Admin routes
 @admin_router.get("", response_class=HTMLResponse)
 async def admin_page(request: Request, db: Session = Depends(get_db)):
@@ -132,10 +186,15 @@ async def admin_page(request: Request, db: Session = Depends(get_db)):
     if isinstance(current_user, RedirectResponse):
         return current_user
     if not current_user.is_admin:
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized"
+        )
     users = db.query(User).all()
     devices = db.query(Device).all()
-    return templates.TemplateResponse("admin.html", {"request": request, "users": users, "devices": devices})
+    return templates.TemplateResponse(
+        "admin.html", {"request": request, "users": users, "devices": devices}
+    )
+
 
 @admin_router.post("/delete/{username}")
 async def delete_user(request: Request, username: str, db: Session = Depends(get_db)):
@@ -143,23 +202,39 @@ async def delete_user(request: Request, username: str, db: Session = Depends(get
     if isinstance(current_user, RedirectResponse):
         return current_user
     if not current_user.is_admin:
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized"
+        )
     user = db.query(User).filter(User.username == username).first()
     if user:
         db.delete(user)
         db.commit()
     return RedirectResponse(url="/admin", status_code=status.HTTP_302_FOUND)
 
+
 @admin_router.post("/edit/{username}")
-async def edit_user(request: Request, username: str, new_username: str = Form(...), email: str = Form(...), is_admin: bool = Form(False), is_active: bool = Form(False), db: Session = Depends(get_db)):
+async def edit_user(
+    request: Request,
+    username: str,
+    new_username: str = Form(...),
+    email: str = Form(...),
+    is_admin: bool = Form(False),
+    is_active: bool = Form(False),
+    db: Session = Depends(get_db),
+):
     current_user = login_required(request, db)
     if isinstance(current_user, RedirectResponse):
         return current_user
     if not current_user.is_admin:
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized"
+        )
     user = db.query(User).filter(User.username == username).first()
     if user:
-        if new_username != username and db.query(User).filter(User.username == new_username).first():
+        if (
+            new_username != username
+            and db.query(User).filter(User.username == new_username).first()
+        ):
             raise HTTPException(status_code=400, detail="Username already exists")
         user.username = new_username
         user.email = email
@@ -168,6 +243,7 @@ async def edit_user(request: Request, username: str, new_username: str = Form(..
         db.commit()
     return RedirectResponse(url="/admin", status_code=status.HTTP_302_FOUND)
 
+
 @admin_router.post("/add_device")
 async def add_device(
     request: Request,
@@ -175,23 +251,28 @@ async def add_device(
     description: str = Form(...),
     device_id: str = Form(...),
     password: str = Form(...),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     current_user = login_required(request, db)
     if isinstance(current_user, RedirectResponse):
         return current_user
     if not current_user.is_admin:
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized")
-    
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized"
+        )
+
     existing_device = db.query(Device).filter(Device.device_id == device_id).first()
     if existing_device:
         raise HTTPException(status_code=400, detail="Device ID already exists")
-    
-    new_device = Device(name=name, description=description, device_id=device_id, password=password)
+
+    new_device = Device(
+        name=name, description=description, device_id=device_id, password=password
+    )
     db.add(new_device)
     db.commit()
     return RedirectResponse(url="/admin", status_code=status.HTTP_302_FOUND)
 
+
 @admin_router.post("/edit_device/{device_id}")
 async def edit_device(
     request: Request,
@@ -200,21 +281,26 @@ async def edit_device(
     description: str = Form(...),
     new_device_id: str = Form(...),
     password: str = Form(...),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     current_user = login_required(request, db)
     if isinstance(current_user, RedirectResponse):
         return current_user
     if not current_user.is_admin:
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized")
-    
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized"
+        )
+
     device = db.query(Device).filter(Device.device_id == device_id).first()
     if not device:
         raise HTTPException(status_code=404, detail="Device not found")
-    
-    if new_device_id != device_id and db.query(Device).filter(Device.device_id == new_device_id).first():
+
+    if (
+        new_device_id != device_id
+        and db.query(Device).filter(Device.device_id == new_device_id).first()
+    ):
         raise HTTPException(status_code=400, detail="New Device ID already exists")
-    
+
     device.name = name
     device.description = description
     device.device_id = new_device_id
@@ -222,26 +308,32 @@ async def edit_device(
     db.commit()
     return RedirectResponse(url="/admin", status_code=status.HTTP_302_FOUND)
 
+
 @admin_router.post("/delete_device/{device_id}")
-async def delete_device(request: Request, device_id: str, db: Session = Depends(get_db)):
+async def delete_device(
+    request: Request, device_id: str, db: Session = Depends(get_db)
+):
     current_user = login_required(request, db)
     if isinstance(current_user, RedirectResponse):
         return current_user
     if not current_user.is_admin:
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized")
-    
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="Not authorized"
+        )
+
     device = db.query(Device).filter(Device.device_id == device_id).first()
     if device:
         db.delete(device)
         db.commit()
     return RedirectResponse(url="/admin", status_code=status.HTTP_302_FOUND)
 
+
 # API routes
 @api_router.post("/generate-data")
 def generate_data(
     device_id: str = Header(...),
     device_password: str = Header(...),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     authenticate_device(device_id, device_password, db)
     base_latitude = 35.6837
@@ -264,18 +356,19 @@ def generate_data(
             latitude=random_latitude,
             longitude=random_longitude,
             timestamp=random_time,
-            connect_status=random_connect_status
+            connect_status=random_connect_status,
         )
         db.add(status_record)
 
     db.commit()
     return {"message": "Demo data generated successfully"}
 
+
 @api_router.delete("/delete-data", summary="Delete all status records")
 def delete_all_data(
     device_id: str = Header(...),
     device_password: str = Header(...),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """
     Delete all status records from the database.
@@ -290,12 +383,15 @@ def delete_all_data(
         db.rollback()
         raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
 
-@api_router.delete("/delete-data/{device_id}", summary="Delete status records for a specific device")
+
+@api_router.delete(
+    "/delete-data/{device_id}", summary="Delete status records for a specific device"
+)
 def delete_device_data(
     device_id: str,
     auth_device_id: str = Header(...),
     device_password: str = Header(...),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """
     Delete status records for a specific device ID.
@@ -303,7 +399,9 @@ def delete_device_data(
     """
     authenticate_device(auth_device_id, device_password, db)
     try:
-        deleted_count = db.query(StatusRecord).filter(StatusRecord.device_id == device_id).delete()
+        deleted_count = (
+            db.query(StatusRecord).filter(StatusRecord.device_id == device_id).delete()
+        )
         db.commit()
         if deleted_count == 0:
             return {"message": f"No data found for device ID: {device_id}"}
@@ -312,56 +410,81 @@ def delete_device_data(
         db.rollback()
         raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
 
-@api_router.post("/upload")
-async def upload_data(
+
+@api_router.post("/upload_batch")
+async def upload_data_batch(
+    records: StatusRecordBatch,
     device_id: str = Header(...),
     device_password: str = Header(...),
-    uuid_str: str = Form(...),
-    latitude: float = Form(...),
-    longitude: float = Form(...),
-    timestamp: str = Form(...),
-    connect_status: int = Form(...),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """
-    Upload a new status record.
-    Requires device authentication and a unique UUID.
+    Upload multiple status records in a single request.
+    Requires device authentication and unique UUIDs for each record.
+    Uses the device_id from the header for all records.
     """
     authenticate_device(device_id, device_password, db)
-    
-    # Validate UUID
-    try:
-        uuid_obj = uuid_module.UUID(uuid_str)
-    except ValueError:
-        raise HTTPException(status_code=400, detail="Invalid UUID format")
+
+    successful_uploads = 0
+    failed_uploads = 0
+    error_messages = []
+
+    for record in records.records:
+        try:
+            # Validate UUID
+            uuid_obj = uuid_module.UUID(record.uuid)
+
+            # Validate timestamp
+            timestamp_dt = datetime.strptime(record.timestamp, "%Y-%m-%d %H:%M:%S")
+
+            status_record = StatusRecord(
+                uuid=str(uuid_obj),
+                device_id=device_id,
+                latitude=record.latitude,
+                longitude=record.longitude,
+                timestamp=timestamp_dt,
+                connect_status=record.connect_status,
+            )
+            db.add(status_record)
+            successful_uploads += 1
+        except ValueError as ve:
+            failed_uploads += 1
+            error_messages.append(f"Invalid data format: {str(ve)}")
+        except IntegrityError:
+            db.rollback()
+            failed_uploads += 1
+            error_messages.append(f"Duplicate UUID: {record.uuid}")
+        except Exception as e:
+            db.rollback()
+            failed_uploads += 1
+            error_messages.append(f"Error processing record: {str(e)}")
 
     try:
-        timestamp_dt = datetime.strptime(timestamp, '%Y-%m-%d %H:%M:%S')
-        status_record = StatusRecord(
-            uuid=str(uuid_obj),
-            device_id=device_id,
-            latitude=latitude,
-            longitude=longitude,
-            timestamp=timestamp_dt,
-            connect_status=connect_status
-        )
-        db.add(status_record)
         db.commit()
-        return {"message": "Data uploaded successfully"}
-    except IntegrityError:
-        db.rollback()
-        raise HTTPException(status_code=400, detail="UUID already exists")
-    except ValueError:
-        raise HTTPException(status_code=400, detail="Invalid timestamp format. Use 'YYYY-MM-DD HH:MM:SS'")
     except Exception as e:
         db.rollback()
-        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={"message": f"Error committing to database: {str(e)}"},
+        )
+
+    return JSONResponse(
+        status_code=status.HTTP_200_OK,
+        content={
+            "status": "ok",
+            "message": "Batch upload completed",
+            "successful_uploads": successful_uploads,
+            "failed_uploads": failed_uploads,
+            "errors": error_messages,
+        },
+    )
+
 
 @api_router.get("/health_check", summary="Check if the API is functioning correctly")
 def health_check(
     device_id: str = Header(...),
     device_password: str = Header(...),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """
     Perform a health check on the API.
@@ -374,14 +497,20 @@ def health_check(
         return JSONResponse(content={"status": "ok"}, status_code=status.HTTP_200_OK)
     except HTTPException as e:
         if e.status_code == status.HTTP_401_UNAUTHORIZED:
-            return JSONResponse(content={"status": "error", "detail": "Unauthorized"}, status_code=status.HTTP_401_UNAUTHORIZED)
+            return JSONResponse(
+                content={"status": "error", "detail": "Unauthorized"},
+                status_code=status.HTTP_401_UNAUTHORIZED,
+            )
         raise e
 
-@api_router.get("/config", summary="Get system configuration", response_model=Dict[str, int])
+
+@api_router.get(
+    "/config", summary="Get system configuration", response_model=Dict[str, int]
+)
 def get_config(
     device_id: str = Header(...),
     device_password: str = Header(...),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
 ):
     """
     Retrieve the system configuration from SystemSetting.
@@ -391,77 +520,108 @@ def get_config(
     system_setting = db.query(SystemSetting).first()
     if not system_setting:
         raise HTTPException(status_code=404, detail="System settings not found")
-    
+
     return {
         "check_connect_period": system_setting.check_connect_period,
         "data_sync_period": system_setting.data_sync_period,
         "get_config_period": system_setting.get_config_period,
-        "point_distance": system_setting.point_distance
+        "point_distance": system_setting.point_distance,
     }
 
+
 @app.get("/", response_class=HTMLResponse)
-def show_map(request: Request, start_date: str = None, end_date: str = None, db: Session = Depends(get_db)):
+def show_map(
+    request: Request,
+    start_date: str = None,
+    end_date: str = None,
+    db: Session = Depends(get_db),
+):
     current_user = login_required(request, db)
     if isinstance(current_user, RedirectResponse):
         return current_user
-    
+
     query = db.query(StatusRecord)
     if start_date and end_date:
-        start_datetime = datetime.strptime(start_date, '%Y-%m-%d')
-        end_datetime = datetime.strptime(end_date, '%Y-%m-%d')
-        query = query.filter(StatusRecord.timestamp.between(start_datetime, end_datetime))
-    
-    status_data = [(s.latitude, s.longitude, s.connect_status, s.device_id) for s in query.all()]
+        start_datetime = datetime.strptime(start_date, "%Y-%m-%d")
+        end_datetime = datetime.strptime(end_date, "%Y-%m-%d")
+        query = query.filter(
+            StatusRecord.timestamp.between(start_datetime, end_datetime)
+        )
+
+    status_data = [
+        (s.latitude, s.longitude, s.connect_status, s.device_id) for s in query.all()
+    ]
 
     m = folium.Map(location=[35.6837, 139.6805], zoom_start=12)
     marker_cluster = MarkerCluster().add_to(m)
 
     for lat, lon, connect_status, device_id in status_data:
-        color = 'green' if connect_status == 1 else 'red'
+        color = "green" if connect_status == 1 else "red"
         folium.CircleMarker(
             location=[lat, lon],
             radius=10,
-            popup=f'{device_id}',
+            popup=f"{device_id}",
             color=color,
             fill=True,
-            fill_opacity=0.6
+            fill_opacity=0.6,
         ).add_to(marker_cluster)
-    
+
     map_html = m._repr_html_()
-    return templates.TemplateResponse("map.html", {
-        "request": request,
-        "map_html": map_html,
-        "start_date": start_date,
-        "end_date": end_date,
-        "current_user": current_user
-    })
+    return templates.TemplateResponse(
+        "map.html",
+        {
+            "request": request,
+            "map_html": map_html,
+            "start_date": start_date,
+            "end_date": end_date,
+            "current_user": current_user,
+        },
+    )
+
 
 @app.get("/download-csv")
 async def download_csv(request: Request, db: Session = Depends(get_db)):
     current_user = login_required(request, db)
     if isinstance(current_user, RedirectResponse):
         return current_user
-    
+
     status_records = db.query(StatusRecord).all()
-    
+
     output = io.StringIO()
     writer = csv.writer(output)
-    
-    writer.writerow(["UUID", "Device ID", "Latitude", "Longitude", "Timestamp", "Connect Status"])
-    
+
+    writer.writerow(
+        ["UUID", "Device ID", "Latitude", "Longitude", "Timestamp", "Connect Status"]
+    )
+
     for record in status_records:
-        writer.writerow([record.uuid, record.device_id, record.latitude, record.longitude, record.timestamp, record.connect_status])
-    
+        writer.writerow(
+            [
+                record.uuid,
+                record.device_id,
+                record.latitude,
+                record.longitude,
+                record.timestamp,
+                record.connect_status,
+            ]
+        )
+
     response = StreamingResponse(iter([output.getvalue()]), media_type="text/csv")
     response.headers["Content-Disposition"] = "attachment; filename=status_records.csv"
-    
+
     return response
 
+
 @app.exception_handler(HTTPException)
 async def http_exception_handler(request: Request, exc: HTTPException):
     if exc.status_code == status.HTTP_401_UNAUTHORIZED:
         return RedirectResponse(url="/login", status_code=status.HTTP_302_FOUND)
-    return templates.TemplateResponse("error.html", {"request": request, "detail": exc.detail}, status_code=exc.status_code)
+    return templates.TemplateResponse(
+        "error.html",
+        {"request": request, "detail": exc.detail},
+        status_code=exc.status_code,
+    )
+
 
 # Include the routers
 app.include_router(admin_router)
@@ -469,5 +629,5 @@ app.include_router(api_router)
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
 
+    uvicorn.run(app, host="0.0.0.0", port=7860)

models.py

@@ -2,6 +2,8 @@ from sqlalchemy import Column, Integer, String, Float, DateTime, Boolean, Enum
 from sqlalchemy.ext.declarative import declarative_base
 from datetime import datetime
 import uuid
+from pydantic import BaseModel
+from typing import List
 
 Base = declarative_base()
 
@@ -43,4 +45,14 @@ class Device(Base):
     name = Column(String)
     description = Column(String)
     device_id = Column(String, unique=True, index=True)
-    password = Column(String)
+    password = Column(String)
+
+class StatusRecordCreate(BaseModel):
+    uuid: str
+    latitude: float
+    longitude: float
+    timestamp: str
+    connect_status: int
+
+class StatusRecordBatch(BaseModel):
+    records: List[StatusRecordCreate]