Update app.py

app.py

@@ -5,29 +5,35 @@ from datetime import datetime
 import folium
 from folium import plugins
 from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
 import uvicorn
 from threading import Thread
 from geopy.distance import geodesic
 
-# Configuração do banco de dados e API
-app = FastAPI()
-init_db()
+# Configuração do banco de dados
+def init_db():
+    conn = sqlite3.connect('locations.db', check_same_thread=False)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS locations (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            device_id TEXT NOT NULL,
+            device_name TEXT NOT NULL,
+            latitude REAL NOT NULL,
+            longitude REAL NOT NULL,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+            accuracy REAL,
+            battery_level INTEGER,
+            ip_address TEXT
+        )
+    ''')
+    conn.commit()
+    conn.close()
 
-# Endpoint para receber localizações via API
-@app.post("/api/location")
-async def receive_location(request: Request):
-    data = await request.json()
-    device_id = data.get('device_id')
-    device_name = data.get('device_name')
-    latitude = data.get('latitude')
-    longitude = data.get('longitude')
-    accuracy = data.get('accuracy', 10)
-    battery = data.get('battery', 100)
-    
-    result = add_location(device_id, device_name, latitude, longitude, accuracy, battery)
-    return {"status": "success" if "✅" in result else "error", "message": result}
+init_db()
+app = FastAPI()
 
-# Função para verificar movimento significativo (mais de 50 metros)
+# Função para verificar movimento significativo
 def is_significant_movement(device_id, new_lat, new_lng):
     conn = sqlite3.connect('locations.db', check_same_thread=False)
     cursor = conn.cursor()
@@ -44,26 +50,133 @@ def is_significant_movement(device_id, new_lat, new_lng):
     
     old_lat, old_lng = last_location
     distance = geodesic((old_lat, old_lng), (new_lat, new_lng)).meters
-    return distance > 50  # Só atualiza se mover mais de 50 metros
+    return distance > 50
 
-# Modificação na função add_location para verificar movimento
+# Função para adicionar localização
 def add_location(device_id, device_name, latitude, longitude, accuracy=0, battery=100):
     try:
         lat = float(latitude)
         lng = float(longitude)
+        acc = float(accuracy) if accuracy else 0
+        bat = int(battery) if battery else 100
+        
+        if not (-90 <= lat <= 90) or not (-180 <= lng <= 180):
+            return "❌ Erro: Coordenadas inválidas!"
         
         if not is_significant_movement(device_id, lat, lng):
             return "✅ Localização recebida (sem movimento significativo)"
+        
+        conn = sqlite3.connect('locations.db', check_same_thread=False)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            INSERT INTO locations (device_id, device_name, latitude, longitude, accuracy, battery_level)
+            VALUES (?, ?, ?, ?, ?, ?)
+        ''', (device_id, device_name, lat, lng, acc, bat))
+        
+        conn.commit()
+        conn.close()
+        
+        return f"✅ Localização adicionada com sucesso!\n📍 {lat:.6f}, {lng:.6f}\n⏰ {datetime.now().strftime('%H:%M:%S')}"
+    
+    except ValueError:
+        return "❌ Erro: Valores numéricos inválidos!"
+    except Exception as e:
+        return f"❌ Erro: {str(e)}"
+
+# Endpoint API
+@app.post("/api/location")
+async def receive_location(request: Request):
+    data = await request.json()
+    result = add_location(
+        data.get('device_id'),
+        data.get('device_name'),
+        data.get('latitude'),
+        data.get('longitude'),
+        data.get('accuracy', 10),
+        data.get('battery', 100)
+    )
+    return {"status": "success" if "✅" in result else "error", "message": result}
+
+# Função para obter mapa atualizado
+def get_updated_map():
+    try:
+        conn = sqlite3.connect('locations.db', check_same_thread=False)
+        query = '''
+            SELECT device_id, device_name, latitude, longitude, 
+                   timestamp, accuracy, battery_level,
+                   ROW_NUMBER() OVER (PARTITION BY device_id ORDER BY timestamp DESC) as rn
+            FROM locations 
+            WHERE timestamp > datetime('now', '-1 day')
+        '''
+        df = pd.read_sql_query(query, conn)
+        df_latest = df[df['rn'] == 1].copy()
+        conn.close()
+        
+        if df_latest.empty:
+            m = folium.Map(location=[-14.235, -51.9253], zoom_start=4)
+            folium.Marker(
+                [-14.235, -51.9253],
+                popup="Nenhum dispositivo encontrado",
+                icon=folium.Icon(color='gray', icon='info-sign')
+            ).add_to(m)
+            return m._repr_html_()
+        
+        center_lat = df_latest['latitude'].mean()
+        center_lng = df_latest['longitude'].mean()
+        m = folium.Map(location=[center_lat, center_lng], zoom_start=12)
+        
+        colors = ['red', 'blue', 'green', 'purple', 'orange', 'darkred', 'lightred', 
+                 'beige', 'darkblue', 'darkgreen', 'cadetblue', 'darkpurple', 'white', 
+                 'pink', 'lightblue', 'lightgreen', 'gray', 'black', 'lightgray']
+        
+        for idx, row in df_latest.iterrows():
+            last_update = datetime.strptime(row['timestamp'], '%Y-%m-%d %H:%M:%S')
+            is_online = (datetime.now() - last_update).total_seconds() < 300
+            
+            popup_html = f"""
+            <div style="font-family: Arial; width: 200px;">
+                <h4>📱 {row['device_name']}</h4>
+                <p><b>ID:</b> {row['device_id']}</p>
+                <p><b>Status:</b> <span style="color: {'green' if is_online else 'red'};">
+                    {'🟢 Online' if is_online else '🔴 Offline'}</span></p>
+                <p><b>Última atualização:</b><br>{row['timestamp']}</p>
+                <p><b>Coordenadas:</b><br>{row['latitude']:.6f}, {row['longitude']:.6f}</p>
+                <p><b>Precisão:</b> ±{row['accuracy']:.0f}m</p>
+                <p><b>Bateria:</b> 🔋 {row['battery_level']}%</p>
+            </div>
+            """
             
-        # Restante da função permanece igual...
-        # ... (código anterior da função add_location)
+            folium.Marker(
+                [row['latitude'], row['longitude']],
+                popup=folium.Popup(popup_html, min_width=200, max_width=300),
+                tooltip=f"{row['device_name']} - {'Online' if is_online else 'Offline'}",
+                icon=folium.Icon(color='green' if is_online else 'red', icon='phone', prefix='fa')
+            ).add_to(m)
+            
+            folium.Circle(
+                [row['latitude'], row['longitude']],
+                radius=row['accuracy'],
+                popup=f"Área de precisão: ±{row['accuracy']:.0f}m",
+                color=colors[idx % len(colors)],
+                fill=True,
+                fillOpacity=0.1,
+                weight=1
+            ).add_to(m)
+        
+        plugins.Fullscreen().add_to(m)
+        minimap = plugins.MiniMap()
+        m.add_child(minimap)
+        
+        return m._repr_html_()
+    except Exception as e:
+        return f"<div style='color: red; padding: 20px;'>Erro ao carregar mapa: {str(e)}</div>"
 
-# Interface Gradio com atualização automática
+# Interface Gradio
 def create_interface():
     with gr.Blocks(title="📍 Monitor GPS em Tempo Real", theme=gr.themes.Soft()) as demo:
         gr.Markdown("""
         # 📍 Monitoramento GPS em Tempo Real
-        
         **Visualize a localização de dispositivos com atualização automática**
         """)
         
@@ -72,21 +185,19 @@ def create_interface():
                 map_html = gr.HTML(label="Mapa GPS em Tempo Real")
                 gr.Markdown("""
                 ### Instruções para Celular:
-                1. Acesse este link no seu celular: [Enviar Localização](#)
+                1. Acesse: http://[SEU-SERVIDOR]:8000/mobile
                 2. Permita o acesso à localização
                 3. Sua posição será atualizada automaticamente
                 """)
-                
-                # Atualização mais frequente para o mapa
                 gr.Timer(10.0, get_updated_map, [], [map_html])
             
             with gr.TabItem("📋 Dispositivos"):
                 devices_table = gr.Dataframe(label="Dispositivos Conectados")
-                gr.Timer(15.0, get_device_list, [], [devices_table])
+                gr.Timer(15.0, lambda: get_device_list(), [], [devices_table])
     
     return demo
 
-# Código HTML/JS para captura de localização no celular
+# Página mobile
 mobile_page = """
 <!DOCTYPE html>
 <html>
@@ -95,7 +206,8 @@ mobile_page = """
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <style>
         body { font-family: Arial, sans-serif; padding: 20px; }
-        button { padding: 10px 15px; font-size: 16px; }
+        button { padding: 10px 15px; font-size: 16px; margin: 10px 0; }
+        #status { margin: 15px 0; font-weight: bold; }
     </style>
 </head>
 <body>
@@ -106,38 +218,57 @@ mobile_page = """
     
     <script>
         const deviceId = "celular_" + Math.random().toString(36).substring(2, 8);
-        const deviceName = "Celular " + prompt("Digite seu nome:", "Usuário");
+        const deviceName = prompt("Digite seu nome:", "Usuário") || "Usuário";
         let watchId = null;
+        let batteryLevel = 100;
+        
+        // Verificar suporte a bateria
+        if (navigator.getBattery) {
+            navigator.getBattery().then(battery => {
+                batteryLevel = Math.round(battery.level * 100);
+                battery.addEventListener('levelchange', () => {
+                    batteryLevel = Math.round(battery.level * 100);
+                });
+            });
+        }
         
-        document.getElementById("startBtn").addEventListener("click", () => {
+        document.getElementById("startBtn").addEventListener("click", async () => {
             if (watchId) {
                 navigator.geolocation.clearWatch(watchId);
                 watchId = null;
                 document.getElementById("status").textContent = "Compartilhamento parado";
+                document.getElementById("startBtn").textContent = "Iniciar Compartilhamento";
                 return;
             }
             
             document.getElementById("status").textContent = "Obtendo localização...";
+            document.getElementById("startBtn").textContent = "Parar Compartilhamento";
             
             watchId = navigator.geolocation.watchPosition(
-                (position) => {
+                async (position) => {
                     const { latitude, longitude, accuracy } = position.coords;
-                    document.getElementById("coordinates").textContent = 
-                        `Lat: ${latitude.toFixed(6)}, Long: ${longitude.toFixed(6)} (Precisão: ${accuracy}m)`;
+                    document.getElementById("coordinates").innerHTML = 
+                        `<strong>Coordenadas:</strong> ${latitude.toFixed(6)}, ${longitude.toFixed(6)}<br>
+                         <strong>Precisão:</strong> ${Math.round(accuracy)} metros<br>
+                         <strong>Bateria:</strong> ${batteryLevel}%`;
                     
-                    // Enviar para o servidor
-                    fetch("/api/location", {
-                        method: "POST",
-                        headers: { "Content-Type": "application/json" },
-                        body: JSON.stringify({
-                            device_id: deviceId,
-                            device_name: deviceName,
-                            latitude,
-                            longitude,
-                            accuracy,
-                            battery: navigator.getBattery ? (await navigator.getBattery()).level * 100 : 100
-                        })
-                    }).then(response => console.log("Localização enviada"));
+                    try {
+                        const response = await fetch("/api/location", {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json" },
+                            body: JSON.stringify({
+                                device_id: deviceId,
+                                device_name: deviceName,
+                                latitude,
+                                longitude,
+                                accuracy,
+                                battery: batteryLevel
+                            })
+                        });
+                        console.log("Localização enviada:", await response.json());
+                    } catch (error) {
+                        console.error("Erro ao enviar localização:", error);
+                    }
                 },
                 (error) => {
                     document.getElementById("status").textContent = "Erro: " + error.message;
@@ -148,28 +279,50 @@ mobile_page = """
                     timeout: 5000
                 }
             );
-            
-            document.getElementById("status").textContent = "Compartilhando localização...";
         });
     </script>
 </body>
 </html>
 """
 
-# Rota para a página mobile
 @app.get("/mobile")
 async def mobile_client():
     return HTMLResponse(mobile_page)
 
-# Executar tanto o Gradio quanto o FastAPI
-def run_app():
-    gradio_app = create_interface()
-    gradio_app.launch(server_name="0.0.0.0", server_port=7860, share=False)
+def get_device_list():
+    try:
+        conn = sqlite3.connect('locations.db', check_same_thread=False)
+        query = '''
+            SELECT device_id, device_name, latitude, longitude, 
+                   timestamp, battery_level, accuracy,
+                   ROW_NUMBER() OVER (PARTITION BY device_id ORDER BY timestamp DESC) as rn
+            FROM locations 
+            WHERE timestamp > datetime('now', '-1 day')
+        '''
+        df = pd.read_sql_query(query, conn)
+        conn.close()
+        
+        if df.empty:
+            return pd.DataFrame([{"Mensagem": "Nenhum dispositivo encontrado nas últimas 24 horas"}])
+        
+        df_latest = df[df['rn'] == 1].copy()
+        df_latest['status'] = df_latest['timestamp'].apply(
+            lambda x: '🟢 Online' if (datetime.now() - datetime.strptime(x, '%Y-%m-%d %H:%M:%S')).total_seconds() < 300 else '🔴 Offline'
+        )
+        
+        display_df = df_latest[['device_name', 'device_id', 'status', 'latitude', 'longitude', 'timestamp', 'battery_level', 'accuracy']]
+        display_df.columns = ['Nome', 'ID', 'Status', 'Latitude', 'Longitude', 'Última Atualização', 'Bateria (%)', 'Precisão (m)']
+        
+        return display_df
+    except Exception as e:
+        return pd.DataFrame([{"Erro": f"Erro ao carregar dispositivos: {str(e)}"}])
+
+def run_gradio():
+    demo = create_interface()
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
 
 if __name__ == "__main__":
-    # Iniciar Gradio em uma thread separada
-    gradio_thread = Thread(target=run_app)
+    gradio_thread = Thread(target=run_gradio)
     gradio_thread.start()
     
-    # Iniciar FastAPI
     uvicorn.run(app, host="0.0.0.0", port=8000)