Up

app.py

@@ -1,101 +1,112 @@
-from fastapi import FastAPI, HTTPException, Request, Form, Depends, status
-from fastapi.responses import HTMLResponse, FileResponse, RedirectResponse, JSONResponse
+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, HTTPBasicCredentials
+from fastapi.security import HTTPBasic
 from datetime import datetime, timedelta
 import random
 import folium
+import uuid as uuid_module
 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
+import io
 import csv
-import os
-from pydantic import BaseModel
-from typing import List, Optional
+from typing import Dict
+
+# Database setup
+SQLALCHEMY_DATABASE_URL = "sqlite:///./database.db"
+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()
+    try:
+        # Create default admin user if not exists
+        if not db.query(User).filter(User.username == "admin").first():
+            admin_user = User(
+                username="admin",
+                email="[email protected]",
+                password="admin",
+                is_admin=True,
+                is_active=True
+            )
+            db.add(admin_user)
+
+        # Create default system settings if not exists
+        if not db.query(SystemSetting).first():
+            default_settings = SystemSetting()
+            db.add(default_settings)
+
+        db.commit()
+    except Exception as e:
+        db.rollback()
+        print(f"Error creating default data: {str(e)}")
+    finally:
+        db.close()
+
+create_default_data()
 
 app = FastAPI()
 templates = Jinja2Templates(directory="templates")
+security = HTTPBasic()
 
+# Create APIRouters for grouping
+admin_router = APIRouter(prefix="/admin", tags=["admin"])
+api_router = APIRouter(prefix="/api", tags=["api"])
 
-CSV_FILE = "wifi_signals.csv"
-USERS_FILE = "users.csv"
-security = HTTPBasic()
+# Dependency to get the database session
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
 
-class User(BaseModel):
-    username: str
-    email: str
-    password: str
-    is_admin: bool = False
-    last_login: Optional[datetime] = None
-    is_active: bool = True
-
-users = []
-
-def load_users():
-    global users
-    if os.path.exists(USERS_FILE):
-        with open(USERS_FILE, mode='r') as file:
-            reader = csv.reader(file)
-            next(reader)  # Skip header
-            users = []
-            for row in reader:
-                user = User(
-                    username=row[0],
-                    email=row[1],
-                    password=row[2],
-                    is_admin=row[3] == 'True',
-                    last_login=datetime.fromisoformat(row[4]) if row[4] else None,
-                    is_active=row[5] == 'True'
-                )
-                users.append(user)
-
-def save_users():
-    with open(USERS_FILE, mode='w', newline='') as file:
-        writer = csv.writer(file)
-        writer.writerow(['username', 'email', 'password', 'is_admin', 'last_login', 'is_active'])
-        for user in users:
-            writer.writerow([
-                user.username,
-                user.email,
-                user.password,
-                user.is_admin,
-                user.last_login.isoformat() if user.last_login else '',
-                user.is_active
-            ])
-
-load_users()
-
-def get_current_user(request: Request) -> Optional[User]:
+def get_current_user(request: Request, db: Session = Depends(get_db)) -> Optional[User]:
     username = request.cookies.get("username")
     if username:
-        return next((u for u in users if u.username == username), None)
+        return db.query(User).filter(User.username == username).first()
     return None
 
-def login_required(request: Request):
+def login_required(request: Request, db: Session = Depends(get_db)):
     username = request.cookies.get("username")
     if not username:
         return RedirectResponse(url="/login", status_code=status.HTTP_302_FOUND)
-    user = next((u for u in users if u.username == username), None)
+    user = db.query(User).filter(User.username == username).first()
     if not user:
         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)):
+    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")
+    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(...)):
-    user = next((u for u in users if u.username == username and u.password == password), None)
-    if user and user.is_active:
+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()
-        save_users()
+        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"})
 
 @app.get("/logout")
-async def logout(response: JSONResponse):
+async def logout():
     response = RedirectResponse(url="/login", status_code=status.HTTP_302_FOUND)
     response.delete_cookie("username")
     return response
@@ -105,168 +116,313 @@ 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(...)):
-    if any(u.username == username for u in users):
+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)
     new_user = User(username=username, email=email, password=password)
-    users.append(new_user)
-    save_users()
+    db.add(new_user)
+    db.commit()
     return RedirectResponse(url="/login", status_code=status.HTTP_302_FOUND)
 
-@app.get("/logout")
-async def logout(request: Request):
-    response = RedirectResponse(url="/login", status_code=status.HTTP_302_FOUND)
-    response.delete_cookie("username")
-    return response
-
-@app.get("/admin", response_class=HTMLResponse)
-async def admin_page(request: Request):
-    current_user = login_required(request)
+# Admin routes
+@admin_router.get("", response_class=HTMLResponse)
+async def admin_page(request: Request, 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")
-    return templates.TemplateResponse("admin.html", {"request": request, "users": users})
+    users = db.query(User).all()
+    devices = db.query(Device).all()
+    return templates.TemplateResponse("admin.html", {"request": request, "users": users, "devices": devices})
 
-@app.post("/admin/delete/{username}")
-async def delete_user(request: Request, username: str):
-    current_user = login_required(request)
+@admin_router.post("/delete/{username}")
+async def delete_user(request: Request, username: 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")
-    global users
-    users = [u for u in users if u.username != username]
-    save_users()
+    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)
 
-@app.post("/admin/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)):
-    current_user = login_required(request)
+@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)):
+    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")
-    user = next((u for u in users if u.username == username), None)
+    user = db.query(User).filter(User.username == username).first()
     if user:
-        # Check if the new username already exists
-        if new_username != username and any(u.username == new_username for u in users):
+        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
         user.is_admin = is_admin
         user.is_active = is_active
-        save_users()
+        db.commit()
+    return RedirectResponse(url="/admin", status_code=status.HTTP_302_FOUND)
+
+@admin_router.post("/add_device")
+async def add_device(
+    request: Request,
+    name: str = Form(...),
+    description: str = Form(...),
+    device_id: str = Form(...),
+    password: str = Form(...),
+    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")
+    
+    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)
+    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,
+    device_id: str,
+    name: str = Form(...),
+    description: str = Form(...),
+    new_device_id: str = Form(...),
+    password: str = Form(...),
+    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")
+    
+    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():
+        raise HTTPException(status_code=400, detail="New Device ID already exists")
+    
+    device.name = name
+    device.description = description
+    device.device_id = new_device_id
+    device.password = password
+    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)):
+    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")
+    
+    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)
 
-@app.post("/api/generate-data")
-def generate_data():
+# API routes
+@api_router.post("/generate-data")
+def generate_data(
+    device_id: str = Header(...),
+    device_password: str = Header(...),
+    db: Session = Depends(get_db)
+):
+    authenticate_device(device_id, device_password, db)
     base_latitude = 35.6837
     base_longitude = 139.6805
     start_date = datetime(2024, 8, 1)
     end_date = datetime(2024, 8, 7)
     delta = end_date - start_date
 
-    with open(CSV_FILE, mode='w', newline='') as file:
-        writer = csv.writer(file)
-        writer.writerow(['latitude', 'longitude', 'timestamp', 'signal_strength'])
-
-        for _ in range(100):
-            random_days = random.randint(0, delta.days)
-            random_seconds = random.randint(0, 86400)
-            random_time = start_date + timedelta(days=random_days, seconds=random_seconds)
-
-            random_latitude = base_latitude + random.uniform(-0.01, 0.01)
-            random_longitude = base_longitude + random.uniform(-0.01, 0.01)
-            random_signal_strength = random.randint(0, 4)
-
-            writer.writerow([
-                random_latitude,
-                random_longitude,
-                random_time.strftime('%Y-%m-%d %H:%M:%S'),
-                random_signal_strength
-            ])
-
+    for _ in range(100):
+        random_days = random.randint(0, delta.days)
+        random_seconds = random.randint(0, 86400)
+        random_time = start_date + timedelta(days=random_days, seconds=random_seconds)
+
+        random_latitude = base_latitude + random.uniform(-0.01, 0.01)
+        random_longitude = base_longitude + random.uniform(-0.01, 0.01)
+        random_connect_status = random.choice([0, 1])
+
+        status_record = StatusRecord(
+            device_id=device_id,
+            latitude=random_latitude,
+            longitude=random_longitude,
+            timestamp=random_time,
+            connect_status=random_connect_status
+        )
+        db.add(status_record)
+
+    db.commit()
     return {"message": "Demo data generated successfully"}
 
-@app.delete("/api/delete-data")
-def delete_data():
+@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)
+):
+    """
+    Delete all status records from the database.
+    Requires device authentication.
+    """
+    authenticate_device(device_id, device_password, db)
     try:
-        if os.path.exists(CSV_FILE):
-            os.remove(CSV_FILE)
-        
-        # Create a new empty CSV file with headers
-        with open(CSV_FILE, mode='w', newline='') as file:
-            writer = csv.writer(file)
-            writer.writerow(['latitude', 'longitude', 'timestamp', 'signal_strength'])
-        
-        return {"message": "Data file deleted and reset successfully"}
+        db.query(StatusRecord).delete()
+        db.commit()
+        return {"message": "All data deleted successfully"}
     except Exception as e:
+        db.rollback()
         raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
 
-@app.post("/api/upload")
+@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)
+):
+    """
+    Delete status records for a specific device ID.
+    Requires device authentication.
+    """
+    authenticate_device(auth_device_id, device_password, db)
+    try:
+        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}"}
+        return {"message": f"Data for device ID {device_id} deleted successfully"}
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+
+@api_router.post("/upload")
 async def upload_data(
+    device_id: str = Header(...),
+    device_password: str = Header(...),
+    uuid_str: str = Form(...),
     latitude: float = Form(...),
     longitude: float = Form(...),
     timestamp: str = Form(...),
-    signal_strength: int = Form(...)
+    connect_status: int = Form(...),
+    db: Session = Depends(get_db)
 ):
+    """
+    Upload a new status record.
+    Requires device authentication and a unique UUID.
+    """
+    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")
+
     try:
-        # Validate timestamp format
-        datetime.strptime(timestamp, '%Y-%m-%d %H:%M:%S')
-        
-        with open(CSV_FILE, mode='a', newline='') as file:
-            writer = csv.writer(file)
-            writer.writerow([latitude, longitude, timestamp, signal_strength])
-        
+        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)}")
 
+@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)
+):
+    """
+    Perform a health check on the API.
+    Requires device authentication.
+    Returns a 200 status code if successful.
+    Returns a 401 Unauthorized error if authentication fails.
+    """
+    try:
+        authenticate_device(device_id, device_password, db)
+        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)
+        raise e
+
+@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)
+):
+    """
+    Retrieve the system configuration from SystemSetting.
+    Requires device authentication.
+    """
+    authenticate_device(device_id, device_password, db)
+    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
+    }
+
 @app.get("/", response_class=HTMLResponse)
-def show_map(request: Request, start_date: str = None, end_date: str = None):
-    current_user = login_required(request)
+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
     
-    signal_data = []
-
-    if os.path.exists(CSV_FILE):
-        with open(CSV_FILE, mode='r') as file:
-            reader = csv.reader(file)
-            next(reader)  # Skip header row
-            for row in reader:
-                lat, lon, timestamp, strength = row
-                timestamp = datetime.strptime(timestamp, '%Y-%m-%d %H:%M:%S')
-                if start_date and end_date:
-                    start_datetime = datetime.strptime(start_date, '%Y-%m-%d')
-                    end_datetime = datetime.strptime(end_date, '%Y-%m-%d')
-                    if start_datetime <= timestamp <= end_datetime:
-                        signal_data.append((float(lat), float(lon), int(strength)))
-                else:
-                    signal_data.append((float(lat), float(lon), int(strength)))
-
-    if signal_data:
-        min_signal = min(s[2] for s in signal_data)
-        max_signal = max(s[2] for s in signal_data)
-    else:
-        min_signal = max_signal = 1
+    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()]
 
     m = folium.Map(location=[35.6837, 139.6805], zoom_start=12)
     marker_cluster = MarkerCluster().add_to(m)
 
-    for lat, lon, signal_strength in signal_data:
-        if max_signal - min_signal != 0:
-            radius = 5 + 10 * ((signal_strength - min_signal) / (max_signal - min_signal))
-        else:
-            radius = 15
+    for lat, lon, connect_status, device_id in status_data:
+        color = 'green' if connect_status == 1 else 'red'
         folium.CircleMarker(
             location=[lat, lon],
-            radius=radius,
-            popup=f'Signal Strength: {signal_strength}',
-            color='blue',
+            radius=10,
+            popup=f'{device_id}',
+            color=color,
             fill=True,
             fill_opacity=0.6
         ).add_to(marker_cluster)
@@ -280,17 +436,36 @@ def show_map(request: Request, start_date: str = None, end_date: str = None):
         "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"])
+    
+    for record in status_records:
+        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)
 
-@app.get("/download-csv")
-async def download_csv():
-    if os.path.exists(CSV_FILE):
-        return FileResponse(CSV_FILE, filename="wifi_signals.csv")
-    raise HTTPException(status_code=404, detail="CSV file not found")
+# Include the routers
+app.include_router(admin_router)
+app.include_router(api_router)
 
 if __name__ == "__main__":
     import uvicorn

models.py

@@ -1,10 +1,46 @@
-from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import Column, Integer, String, Float, DateTime, Boolean, Enum
+from sqlalchemy.ext.declarative import declarative_base
+from datetime import datetime
+import uuid
 
-db = SQLAlchemy()
+Base = declarative_base()
 
-class WifiSignal(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
-    latitude = db.Column(db.Float, nullable=False)
-    longitude = db.Column(db.Float, nullable=False)
-    timestamp = db.Column(db.DateTime, nullable=False)
-    signal_strength = db.Column(db.Integer, nullable=False)
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    email = Column(String, unique=True, index=True)
+    password = Column(String)
+    is_admin = Column(Boolean, default=False)
+    last_login = Column(DateTime, nullable=True)
+    is_active = Column(Boolean, default=True)
+
+class StatusRecord(Base):
+    __tablename__ = "status_records"
+
+    id = Column(Integer, primary_key=True, index=True)
+    uuid = Column(String, unique=True, default=lambda: str(uuid.uuid4()))
+    device_id = Column(String, index=True)
+    latitude = Column(Float)
+    longitude = Column(Float)
+    timestamp = Column(DateTime)
+    connect_status = Column(Integer)  # 0 or 1
+
+class SystemSetting(Base):
+    __tablename__ = "system_settings"
+
+    id = Column(Integer, primary_key=True, index=True)
+    check_connect_period = Column(Integer, default=10)
+    data_sync_period = Column(Integer, default=3600)
+    get_config_period = Column(Integer, default=60)
+    point_distance = Column(Integer, default=5)
+
+class Device(Base):
+    __tablename__ = "devices"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String)
+    description = Column(String)
+    device_id = Column(String, unique=True, index=True)
+    password = Column(String)

templates/admin.html

@@ -38,6 +38,35 @@
                 {% endfor %}
             </tbody>
         </table>
+        
+        <h2>Devices</h2>
+        <button class="btn btn-success mb-3" onclick="addDevice()">Add Device</button>
+        <table class="table">
+            <thead>
+                <tr>
+                    <th>Name</th>
+                    <th>Description</th>
+                    <th>Device ID</th>
+                    <th>Actions</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for device in devices %}
+                <tr>
+                    <td>{{ device.name }}</td>
+                    <td>{{ device.description }}</td>
+                    <td>{{ device.device_id }}</td>
+                    <td>
+                        <button class="btn btn-sm btn-primary" onclick="editDevice('{{ device.name }}', '{{ device.description }}', '{{ device.device_id }}')">Edit</button>
+                        <form method="post" action="/admin/delete_device/{{ device.device_id }}" style="display: inline;">
+                            <button type="submit" class="btn btn-sm btn-danger">Delete</button>
+                        </form>
+                    </td>
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+        
         <a href="/" class="btn btn-secondary">Back to Map</a>
     </div>
 
@@ -79,6 +108,78 @@
         </div>
     </div>
 
+    <!-- Add Device Modal -->
+    <div class="modal fade" id="addDeviceModal" tabindex="-1" aria-hidden="true">
+        <div class="modal-dialog">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">Add Device</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                </div>
+                <form id="addDeviceForm" method="post" action="/admin/add_device">
+                    <div class="modal-body">
+                        <div class="mb-3">
+                            <label for="deviceName" class="form-label">Name</label>
+                            <input type="text" class="form-control" id="deviceName" name="name" required>
+                        </div>
+                        <div class="mb-3">
+                            <label for="deviceDescription" class="form-label">Description</label>
+                            <input type="text" class="form-control" id="deviceDescription" name="description" required>
+                        </div>
+                        <div class="mb-3">
+                            <label for="deviceId" class="form-label">Device ID</label>
+                            <input type="text" class="form-control" id="deviceId" name="device_id" required>
+                        </div>
+                        <div class="mb-3">
+                            <label for="devicePassword" class="form-label">Password</label>
+                            <input type="password" class="form-control" id="devicePassword" name="password" required>
+                        </div>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
+                        <button type="submit" class="btn btn-primary">Add Device</button>
+                    </div>
+                </form>
+            </div>
+        </div>
+    </div>
+
+    <!-- Edit Device Modal -->
+    <div class="modal fade" id="editDeviceModal" tabindex="-1" aria-hidden="true">
+        <div class="modal-dialog">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">Edit Device</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                </div>
+                <form id="editDeviceForm" method="post">
+                    <div class="modal-body">
+                        <div class="mb-3">
+                            <label for="editDeviceName" class="form-label">Name</label>
+                            <input type="text" class="form-control" id="editDeviceName" name="name" required>
+                        </div>
+                        <div class="mb-3">
+                            <label for="editDeviceDescription" class="form-label">Description</label>
+                            <input type="text" class="form-control" id="editDeviceDescription" name="description" required>
+                        </div>
+                        <div class="mb-3">
+                            <label for="editDeviceId" class="form-label">Device ID</label>
+                            <input type="text" class="form-control" id="editDeviceId" name="new_device_id" required>
+                        </div>
+                        <div class="mb-3">
+                            <label for="editDevicePassword" class="form-label">Password</label>
+                            <input type="password" class="form-control" id="editDevicePassword" name="password" placeholder="Leave blank to keep current password">
+                        </div>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
+                        <button type="submit" class="btn btn-primary">Save changes</button>
+                    </div>
+                </form>
+            </div>
+        </div>
+    </div>
+
     <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"></script>
     <script>
         function editUser(username, email, isAdmin, isActive) {
@@ -90,6 +191,21 @@
             var editUserModal = new bootstrap.Modal(document.getElementById('editUserModal'));
             editUserModal.show();
         }
+
+        function addDevice() {
+            var addDeviceModal = new bootstrap.Modal(document.getElementById('addDeviceModal'));
+            addDeviceModal.show();
+        }
+
+        function editDevice(name, description, deviceId) {
+            document.getElementById('editDeviceForm').action = `/admin/edit_device/${deviceId}`;
+            document.getElementById('editDeviceName').value = name;
+            document.getElementById('editDeviceDescription').value = description;
+            document.getElementById('editDeviceId').value = deviceId;
+            document.getElementById('editDevicePassword').value = ''; // Clear password field for security
+            var editDeviceModal = new bootstrap.Modal(document.getElementById('editDeviceModal'));
+            editDeviceModal.show();
+        }
     </script>
 </body>
 </html>