Update app.py

app.py

@@ -1,14 +1,10 @@
-from flask import Flask, Response, request, jsonify
 import json
 import os
-import hmac
-import hashlib
-from urllib.parse import unquote
+import requests
+from flask import Flask, Response, request, jsonify
 
 app = Flask(__name__)
 
-# ВАЖНО: В реальном проекте храните токен в переменных окружения, а не в коде.
-BOT_TOKEN = "6909363967:AAGl58czIt7Vra_V8wWR7MyXkN_ayS27Soo"
 HOTSPOTS_FILE = 'hotspots.json'
 
 def get_all_hotspots():
@@ -39,32 +35,16 @@ def index():
         <link rel="stylesheet" href="https://unpkg.com/[email protected]/dist/leaflet.css" />
         <script src="https://unpkg.com/[email protected]/dist/leaflet.js"></script>
         <style>
-            :root {
-                --tg-theme-bg-color: #000000;
-                --tg-theme-text-color: #ffffff;
-                --tg-theme-button-color: #007aff;
-                --tg-theme-button-text-color: #ffffff;
-            }
             body, html {
                 margin: 0;
                 padding: 0;
                 width: 100%;
                 height: 100%;
                 overflow: hidden;
-                background-color: var(--tg-theme-bg-color);
-                color: var(--tg-theme-text-color);
-                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
-            }
-            #info-bar {
-                position: fixed;
-                top: 10px;
-                left: 10px;
-                background-color: rgba(0, 0, 0, 0.7);
-                color: white;
-                padding: 5px 10px;
-                border-radius: 8px;
-                z-index: 51;
-                font-size: 14px;
+                background-color: #000;
+                color: var(--tg-theme-text-color, white);
+                font-family: Arial, sans-serif;
+                touch-action: pan-x pan-y; /* Prevent default touch actions like pull-to-refresh */
             }
             #ar-container {
                 position: absolute;
@@ -85,11 +65,11 @@ def index():
             }
             .hotspot {
                 position: absolute;
-                background-color: rgba(0, 122, 255, 0.8);
-                color: white;
+                background-color: var(--tg-theme-button-color, rgba(0, 122, 255, 0.8));
+                color: var(--tg-theme-button-text-color, white);
                 padding: 10px 15px;
                 border-radius: 10px;
-                border: 1px solid rgba(255, 255, 255, 0.5);
+                border: 1px solid var(--tg-theme-secondary-bg-color, rgba(255, 255, 255, 0.5));
                 box-shadow: 0 4px 15px rgba(0, 0, 0, 0.5);
                 transform: translate(-50%, -50%);
                 transition: opacity 0.3s, transform 0.1s linear;
@@ -116,7 +96,7 @@ def index():
                 left: 10px;
                 width: 200px;
                 height: 200px;
-                background-color: rgba(0, 0, 0, 0.7);
+                background-color: var(--tg-theme-bg-color, rgba(0, 0, 0, 0.7));
                 border-radius: 10px;
                 overflow: hidden;
                 transition: all 0.3s ease;
@@ -145,8 +125,8 @@ def index():
                 border-radius: 0;
             }
             #toggle-map-button {
-                background-color: rgba(0, 0, 0, 0.5);
-                color: white;
+                background-color: var(--tg-theme-secondary-bg-color, rgba(0, 0, 0, 0.5));
+                color: var(--tg-theme-text-color, white);
                 border: none;
                 padding: 5px 10px;
                 margin: 5px;
@@ -162,54 +142,69 @@ def index():
                 font-size: 16px;
                 margin: 0;
             }
+            #loading-overlay {
+                position: fixed;
+                top: 0;
+                left: 0;
+                width: 100%;
+                height: 100%;
+                background-color: var(--tg-theme-bg-color, #111);
+                color: var(--tg-theme-text-color, white);
+                z-index: 100;
+                display: flex;
+                flex-direction: column;
+                align-items: center;
+                justify-content: center;
+                font-size: 1.2em;
+                text-align: center;
+            }
         </style>
     </head>
     <body>
-        <div id="info-bar">Авторизация...</div>
+        <div id="loading-overlay">
+            Загрузка AR-окружения...
+            <br>Ожидание GPS и камеры...
+        </div>
+
         <video id="camera-view" playsinline autoplay muted></video>
         <div id="ar-container"></div>
+
         <div id="map-container">
             <div id="map"></div>
             <button id="toggle-map-button">Minimap</button>
         </div>
 
         <script>
-            const tg = window.Telegram.WebApp;
-            
             const state = {
                 hotspots: [],
-                currentUser: null,
                 currentUserPosition: null,
-                smoothedPosition: null,
                 deviceOrientation: { alpha: 0, beta: 0, gamma: 0 },
-                smoothedOrientation: { alpha: 0, beta: 0, gamma: 0 },
-                cameraFov: 60,
+                cameraFov: 60, /* Approximate FOV for a typical smartphone camera */
                 map: null,
                 userMarker: null,
                 hotspotMarkers: [],
-                initialMapSet: false
+                initialMapSet: false,
+                isGPSReady: false,
+                isCameraReady: false,
+                isOrientationReady: false
             };
 
-            const SMOOTHING_FACTOR_GPS = 0.05;
-            const SMOOTHING_FACTOR_ORIENTATION = 0.1;
-            const MAX_VISIBLE_DISTANCE = 1000;
+            const MAX_VISIBLE_DISTANCE = 100; // Increased visible distance for better AR experience
 
-            async function verifyTelegramData(initData) {
-                try {
-                    const response = await fetch('/verify_telegram_data', {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ initData: initData })
-                    });
-                    const data = await response.json();
-                    return data.ok;
-                } catch (error) {
-                    console.error('Verification failed:', error);
-                    return false;
-                }
+            function showLoadingOverlay(message) {
+                const overlay = document.getElementById('loading-overlay');
+                overlay.innerText = message;
+                overlay.style.display = 'flex';
             }
-            
+
+            function hideLoadingOverlay() {
+                document.getElementById('loading-overlay').style.display = 'none';
+            }
+
             async function initArApp() {
+                Telegram.WebApp.ready();
+                Telegram.WebApp.expand();
+                hideLoadingOverlay();
                 await setupCamera();
                 setupGPS();
                 setupOrientationListener();
@@ -219,28 +214,29 @@ def index():
                 requestAnimationFrame(update);
             }
 
-            tg.onEvent('viewportChanged', () => tg.expand());
-
-            window.addEventListener('load', async () => {
-                tg.ready();
-                tg.expand();
-                
-                const initData = tg.initData;
-                const isVerified = await verifyTelegramData(initData);
-                
-                if (!isVerified && !tg.initDataUnsafe.query_id) {
-                     document.body.innerHTML = '<h1>Ошибка авторизации. Пожалуйста, откройте это приложение через Telegram.</h1>';
-                     return;
+            function checkAllReady() {
+                if (state.isGPSReady && state.isCameraReady && state.isOrientationReady && Telegram.WebApp.initDataUnsafe.user) {
+                    initArApp();
+                } else {
+                    let message = 'Загрузка AR-окружения...\n';
+                    if (!state.isCameraReady) message += 'Ожидание камеры...\n';
+                    if (!state.isGPSReady) message += 'Ожидание GPS...\n';
+                    if (!state.isOrientationReady) message += 'Ожидание датчика ориентации...\n';
+                    if (!Telegram.WebApp.initDataUnsafe.user) message += 'Ожидание данных пользователя Telegram...\n';
+                    showLoadingOverlay(message);
                 }
+            }
 
-                state.currentUser = tg.initDataUnsafe.user;
-                if(state.currentUser) {
-                    document.getElementById('info-bar').innerText = `Привет, ${state.currentUser.first_name}!`;
+            document.addEventListener('DOMContentLoaded', () => {
+                if (window.Telegram && Telegram.WebApp) {
+                    Telegram.WebApp.onEvent('mainButtonStateChanged', () => {
+                        // Handle Main Button if needed, currently not used
+                    });
+                    Telegram.WebApp.ready();
+                    checkAllReady();
                 } else {
-                    document.getElementById('info-bar').innerText = 'Гость';
+                    alert('Это приложение предназначено для запуска в Telegram Mini App.');
                 }
-
-                initArApp();
             });
 
             async function setupCamera() {
@@ -252,9 +248,14 @@ def index():
                         });
                         video.srcObject = stream;
                         await video.play();
+                        state.isCameraReady = true;
+                        checkAllReady();
                     } catch (err) {
-                        alert('Не удалось получить доступ к камере: ' + err);
+                        alert('Не удалось получить доступ к камере: ' + err.message);
+                        console.error('Camera access error:', err);
                     }
+                } else {
+                    alert('Камера не поддерживается вашим браузером.');
                 }
             }
 
@@ -262,30 +263,35 @@ def index():
                 if (navigator.geolocation) {
                     navigator.geolocation.watchPosition(
                         (position) => {
-                            state.currentUserPosition = {
-                                lat: position.coords.latitude,
-                                lon: position.coords.longitude
-                            };
-                            
-                            if (!state.smoothedPosition) {
-                                state.smoothedPosition = { ...state.currentUserPosition };
-                            } else {
-                                state.smoothedPosition.lat = (state.currentUserPosition.lat * SMOOTHING_FACTOR_GPS) + (state.smoothedPosition.lat * (1 - SMOOTHING_FACTOR_GPS));
-                                state.smoothedPosition.lon = (state.currentUserPosition.lon * SMOOTHING_FACTOR_GPS) + (state.smoothedPosition.lon * (1 - SMOOTHING_FACTOR_GPS));
-                            }
-                            
-                            if (state.userMarker && state.smoothedPosition) {
-                                state.userMarker.setLatLng([state.smoothedPosition.lat, state.smoothedPosition.lon]);
-                                if (!state.initialMapSet) {
-                                    state.map.setView([state.smoothedPosition.lat, state.smoothedPosition.lon], 16);
-                                    state.initialMapSet = true;
+                            const newLat = position.coords.latitude;
+                            const newLon = position.coords.longitude;
+                            // Update position only if it has significantly changed or is first update
+                            if (!state.currentUserPosition || 
+                                Math.abs(newLat - state.currentUserPosition.lat) > 0.00001 || 
+                                Math.abs(newLon - state.currentUserPosition.lon) > 0.00001) {
+                                
+                                state.currentUserPosition = {
+                                    lat: newLat,
+                                    lon: newLon,
+                                    accuracy: position.coords.accuracy // meters
+                                };
+
+                                if (state.userMarker) {
+                                    state.userMarker.setLatLng([state.currentUserPosition.lat, state.currentUserPosition.lon]);
+                                    if (!state.initialMapSet) {
+                                        state.map.setView([state.currentUserPosition.lat, state.currentUserPosition.lon], 15);
+                                        state.initialMapSet = true;
+                                    }
                                 }
                             }
+                            state.isGPSReady = true;
+                            checkAllReady();
                         },
                         (error) => {
-                            alert('Не удалось получить доступ к GPS: ' + error.message);
+                            alert('Не удалось получить доступ к GPS: ' + error.message + '. Убедитесь, что GPS включен и разрешен для этого приложения.');
+                            console.error('GPS error:', error);
                         },
-                        { enableHighAccuracy: true, maximumAge: 0, timeout: 5000 }
+                        { enableHighAccuracy: true, maximumAge: 0, timeout: 10000 } // Increased timeout
                     );
                 } else {
                     alert('GPS не поддерживается вашим браузером.');
@@ -293,44 +299,48 @@ def index():
             }
             
             function setupOrientationListener() {
-                const handler = (event) => {
-                    if (event.alpha !== null) {
-                        state.deviceOrientation.alpha = event.alpha;
-                        state.deviceOrientation.beta = event.beta;
-                        state.deviceOrientation.gamma = event.gamma;
-
-                        let diff = state.deviceOrientation.alpha - state.smoothedOrientation.alpha;
-                        if (diff > 180) diff -= 360;
-                        if (diff < -180) diff += 360;
-                        
-                        state.smoothedOrientation.alpha = (state.smoothedOrientation.alpha + diff * SMOOTHING_FACTOR_ORIENTATION + 360) % 360;
-                        state.smoothedOrientation.beta = (state.deviceOrientation.beta * SMOOTHING_FACTOR_ORIENTATION) + (state.smoothedOrientation.beta * (1 - SMOOTHING_FACTOR_ORIENTATION));
-                        state.smoothedOrientation.gamma = (state.deviceOrientation.gamma * SMOOTHING_FACTOR_ORIENTATION) + (state.smoothedOrientation.gamma * (1 - SMOOTHING_FACTOR_ORIENTATION));
+                if (window.DeviceOrientationEvent) {
+                    // Request permission for iOS 13+
+                    if (typeof DeviceOrientationEvent.requestPermission === 'function') {
+                        DeviceOrientationEvent.requestPermission()
+                            .then(permissionState => {
+                                if (permissionState === 'granted') {
+                                    window.addEventListener('deviceorientation', handleOrientation, true);
+                                    state.isOrientationReady = true;
+                                    checkAllReady();
+                                } else {
+                                    alert('Разрешение на отслеживание ориентации устройства отклонено.');
+                                }
+                            })
+                            .catch(console.error);
+                    } else {
+                        // Handle regular non-iOS 13+ browsers
+                        window.addEventListener('deviceorientation', handleOrientation, true);
+                        state.isOrientationReady = true;
+                        checkAllReady();
                     }
-                };
-                if (typeof DeviceOrientationEvent.requestPermission === 'function') {
-                    DeviceOrientationEvent.requestPermission()
-                        .then(permissionState => {
-                            if (permissionState === 'granted') {
-                                window.addEventListener('deviceorientation', handler, true);
-                            } else {
-                                alert('Доступ к ориентации устройства не предоставлен.');
-                            }
-                        })
-                        .catch(console.error);
-                } else if (window.DeviceOrientationEvent) {
-                     window.addEventListener('deviceorientation', handler, true);
                 } else {
                     alert('Отслеживание ориентации устройства не поддерживается.');
                 }
             }
 
+            function handleOrientation(event) {
+                if (event.alpha !== null) {
+                    // For better stability, apply a small smoothing factor
+                    const smoothing = 0.1; 
+                    state.deviceOrientation.alpha = state.deviceOrientation.alpha * (1 - smoothing) + event.alpha * smoothing;
+                    state.deviceOrientation.beta = state.deviceOrientation.beta * (1 - smoothing) + event.beta * smoothing;
+                    state.deviceOrientation.gamma = state.deviceOrientation.gamma * (1 - smoothing) + event.gamma * smoothing;
+                }
+            }
+
             function initMap() {
                 state.map = L.map('map').setView([0, 0], 2);
                 L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
-                    attribution: '© OpenStreetMap'
+                    attribution: '© OpenStreetMap contributors'
                 }).addTo(state.map);
-                state.userMarker = L.marker([0, 0]).addTo(state.map).bindPopup('Вы здесь');
+                state.userMarker = L.marker([0, 0]).addTo(state.map).bindPopup('Ваше местоположение');
+
                 document.getElementById('toggle-map-button').addEventListener('click', toggleMap);
             }
 
@@ -339,8 +349,8 @@ def index():
                 mapContainer.classList.toggle('fullscreen');
                 setTimeout(() => {
                     state.map.invalidateSize();
-                    if (state.smoothedPosition) {
-                        state.map.setView([state.smoothedPosition.lat, state.smoothedPosition.lon], state.map.getZoom());
+                    if (state.currentUserPosition) {
+                        state.map.setView([state.currentUserPosition.lat, state.currentUserPosition.lon], state.map.getZoom());
                     }
                 }, 300);
             }
@@ -357,6 +367,16 @@ def index():
                 }
             }
 
+            function getCreatorDisplayName(hotspot) {
+                if (hotspot.creator_info) {
+                    const info = hotspot.creator_info;
+                    return info.username ? `@${info.username}` : 
+                           info.first_name ? `${info.first_name}${info.last_name ? ' ' + info.last_name : ''}` : 
+                           'Unknown User';
+                }
+                return 'Unknown';
+            }
+
             function renderHotspots() {
                 const container = document.getElementById('ar-container');
                 container.innerHTML = '';
@@ -364,19 +384,21 @@ def index():
                     const el = document.createElement('div');
                     el.className = 'hotspot';
                     el.id = `hotspot-${index}`;
-                    el.innerHTML = `${hotspot.text}<br><small>by ${hotspot.creator_username || 'Unknown'}</small>`;
+                    el.innerHTML = `${hotspot.text}<br><small>by ${getCreatorDisplayName(hotspot)}</small>`;
                     container.appendChild(el);
                 });
             }
 
             function renderHotspotsOnMap() {
                 if (!state.map) return;
+
                 state.hotspotMarkers.forEach(marker => state.map.removeLayer(marker));
                 state.hotspotMarkers = [];
+
                 state.hotspots.forEach(hotspot => {
                     const marker = L.marker([hotspot.lat, hotspot.lon])
                                    .addTo(state.map)
-                                   .bindPopup(`${hotspot.text}<br>by ${hotspot.creator_username || 'Unknown'}`);
+                                   .bindPopup(`${hotspot.text}<br>by ${getCreatorDisplayName(hotspot)}`);
                     state.hotspotMarkers.push(marker);
                 });
             }
@@ -384,65 +406,49 @@ def index():
             function setupAddHotspotListener() {
                 const container = document.getElementById('ar-container');
                 container.addEventListener('click', async (event) => {
-                    if (event.target.classList.contains('hotspot')) return;
-
-                    if (!state.smoothedPosition) {
-                        tg.showAlert('GPS-координаты еще не определены. Подождите.');
+                    if (!state.currentUserPosition) {
+                        alert('GPS-координаты еще не определены. Подождите немного.');
                         return;
                     }
-                    if (!state.currentUser) {
-                        tg.showAlert('Не удалось определить пользователя Telegram.');
+                    if (!Telegram.WebApp.initDataUnsafe.user) {
+                        alert('Не удалось получить данные пользователя Telegram. Попробуйте перезапустить приложение.');
                         return;
                     }
 
-                    tg.showPopup({
-                        title: 'Новый хотспот',
-                        message: 'Введите текст для нового хотспота:',
-                        buttons: [
-                            {id: 'save', type: 'default', text: 'Сохранить'},
-                            {type: 'cancel'},
-                        ]
-                    }, async (buttonId) => {
-                        if (buttonId === 'save') {
-                            const text = 'Новый хотспот'; // Placeholder, as popup doesn't have input
-                            tg.showScanQrPopup({ text: "Введите текст для хотспота:" }, async (promptText) => {
-                                if (promptText) {
-                                     const newHotspot = {
-                                        text: promptText,
-                                        lat: state.currentUserPosition.lat,
-                                        lon: state.currentUserPosition.lon,
-                                        creator_id: state.currentUser.id,
-                                        creator_username: state.currentUser.username || `${state.currentUser.first_name} ${state.currentUser.last_name || ''}`.trim()
-                                    };
-                                    try {
-                                        const response = await fetch('/hotspots', {
-                                            method: 'POST',
-                                            headers: { 'Content-Type': 'application/json' },
-                                            body: JSON.stringify(newHotspot)
-                                        });
-                                        if(response.ok) {
-                                            const savedHotspot = await response.json();
-                                            state.hotspots.push(savedHotspot.hotspot);
-                                            renderHotspots();
-                                            renderHotspotsOnMap();
-                                            tg.closeScanQrPopup();
-                                        } else {
-                                            tg.showAlert('Не удалось сохранить хотспот.');
-                                        }
-                                    } catch (error) {
-                                        tg.showAlert('Ошибка сети при сохранении хотспота.');
-                                    }
-                                }
-                                return true;
+                    const text = prompt('Введите т��кст для нового хотспота:');
+                    if (text) {
+                        const newHotspot = {
+                            text: text,
+                            lat: state.currentUserPosition.lat,
+                            lon: state.currentUserPosition.lon,
+                            creator_info: Telegram.WebApp.initDataUnsafe.user // Store full user object
+                        };
+
+                        try {
+                            const response = await fetch('/hotspots', {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify(newHotspot)
                             });
+                            if(response.ok) {
+                                const savedHotspot = await response.json();
+                                state.hotspots.push(savedHotspot.hotspot);
+                                renderHotspots();
+                                renderHotspotsOnMap();
+                            } else {
+                                alert('Не удалось сохранить хотспот.');
+                            }
+                        } catch (error) {
+                            console.error('Ошибка сохранения хотспота:', error);
+                            alert('Ошибка сети при сохранении хотспота.');
                         }
-                    });
+                    }
                 });
             }
 
             function haversineDistance(coords1, coords2) {
                 function toRad(x) { return x * Math.PI / 180; }
-                const R = 6371e3;
+                const R = 6371; // Earth's radius in kilometers
                 const dLat = toRad(coords2.lat - coords1.lat);
                 const dLon = toRad(coords2.lon - coords1.lon);
                 const lat1 = toRad(coords1.lat);
@@ -450,7 +456,7 @@ def index():
                 const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
                           Math.sin(dLon / 2) * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
                 const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-                return R * c;
+                return R * c * 1000; // Distance in meters
             }
 
             function calculateBearing(start, end) {
@@ -467,7 +473,7 @@ def index():
             }
 
             function update() {
-                if (!state.smoothedPosition) {
+                if (!state.currentUserPosition || !state.isOrientationReady) {
                     requestAnimationFrame(update);
                     return;
                 }
@@ -479,34 +485,38 @@ def index():
                     const el = document.getElementById(`hotspot-${index}`);
                     if (!el) return;
 
-                    const distance = haversineDistance(state.smoothedPosition, hotspot);
+                    const distance = haversineDistance(state.currentUserPosition, hotspot);
                     
                     if (distance > MAX_VISIBLE_DISTANCE) {
                         el.classList.add('hidden');
                         return;
                     }
 
-                    const bearing = calculateBearing(state.smoothedPosition, hotspot);
-                    let angleDiff = bearing - state.smoothedOrientation.alpha;
+                    const bearing = calculateBearing(state.currentUserPosition, hotspot);
+                    let angleDiff = bearing - state.deviceOrientation.alpha;
 
                     if (angleDiff > 180) angleDiff -= 360;
                     if (angleDiff < -180) angleDiff += 360;
 
-                    if (Math.abs(angleDiff) > state.cameraFov / 2) {
-                        el.classList.add('hidden');
-                    } else {
-                        el.classList.remove('hidden');
-                        
-                        const x = screenWidth / 2 + (angleDiff / (state.cameraFov / 2)) * (screenWidth / 2);
-                        const y = screenHeight / 2;
-                        
-                        const scale = Math.max(0.3, 1 - (distance / MAX_VISIBLE_DISTANCE));
-
-                        el.style.left = `${x}px`;
-                        el.style.top = `${y}px`;
-                        el.style.transform = `translate(-50%, -50%) scale(${scale})`;
-                        el.style.zIndex = Math.round(10000 - distance);
-                    }
+                    // Calculate horizontal position based on FOV
+                    // We need to map an angle difference (e.g., -30 to +30 for a 60 FOV) to screen pixels (0 to screenWidth)
+                    // (angleDiff / (cameraFov / 2)) gives a ratio from -1 to 1 for visible objects
+                    // screenWidth / 2 * (1 + ratio) gives position from 0 to screenWidth
+                    const x = screenWidth / 2 + (angleDiff / (state.cameraFov / 2)) * (screenWidth / 2);
+                    
+                    // Simple vertical positioning (can be improved with beta/gamma for tilt)
+                    const y = screenHeight / 2; // Center vertically for simplicity
+
+                    // Apply perspective scaling based on distance
+                    const scale = Math.max(0.3, 1 - distance / MAX_VISIBLE_DISTANCE); // Min scale 0.3
+                    
+                    // Apply inverse distance for z-index (closer elements appear above)
+                    el.style.zIndex = Math.round(1000 - distance);
+
+                    el.style.left = `${x}px`;
+                    el.style.top = `${y}px`;
+                    el.style.transform = `translate(-50%, -50%) scale(${scale})`;
+                    el.classList.remove('hidden');
                 });
                 
                 requestAnimationFrame(update);
@@ -517,44 +527,6 @@ def index():
     '''
     return Response(html_content, mimetype='text/html')
 
-@app.route('/verify_telegram_data', methods=['POST'])
-def verify_telegram_data():
-    if not request.is_json:
-        return jsonify({"ok": False, "error": "Request must be JSON"}), 400
-
-    data = request.get_json()
-    init_data_str = data.get('initData')
-
-    if not init_data_str:
-        return jsonify({"ok": False, "error": "initData not in request"}), 400
-
-    try:
-        unquoted_data = unquote(init_data_str)
-        
-        data_check_list = []
-        hash_from_telegram = ''
-        
-        for pair in unquoted_data.split('&'):
-            key, value = pair.split('=', 1)
-            if key == 'hash':
-                hash_from_telegram = value
-            else:
-                data_check_list.append(f"{key}={value}")
-        
-        data_check_list.sort()
-        data_check_string = "\n".join(data_check_list)
-        
-        secret_key = hmac.new("WebAppData".encode(), BOT_TOKEN.encode(), hashlib.sha256).digest()
-        calculated_hash = hmac.new(secret_key, data_check_string.encode(), hashlib.sha256).hexdigest()
-
-        if calculated_hash == hash_from_telegram:
-            return jsonify({"ok": True}), 200
-        else:
-            return jsonify({"ok": False, "error": "Hash validation failed"}), 403
-            
-    except Exception as e:
-        return jsonify({"ok": False, "error": str(e)}), 500
-
 @app.route('/hotspots', methods=['GET', 'POST'])
 def handle_hotspots():
     if request.method == 'GET':
@@ -568,26 +540,22 @@ def handle_hotspots():
         text = data.get('text')
         lat = data.get('lat')
         lon = data.get('lon')
-        creator_id = data.get('creator_id')
-        creator_username = data.get('creator_username')
+        creator_info = data.get('creator_info') # This will be the Telegram user object
 
-        if not all([text, lat, lon, creator_id]):
-            return jsonify({"error": "Missing data: text, lat, lon, or creator_id"}), 400
+        if not all([text, lat, lon, creator_info]):
+            return jsonify({"error": "Missing data: text, lat, lon, or creator_info"}), 400
         
         try:
             new_hotspot = {
                 "text": str(text),
                 "lat": float(lat),
                 "lon": float(lon),
-                "creator_id": int(creator_id),
-                "creator_username": str(creator_username)
+                "creator_info": creator_info # Store the full object as received
             }
             save_hotspot(new_hotspot)
             return jsonify({"success": True, "hotspot": new_hotspot}), 201
-        except (ValueError, TypeError):
-            return jsonify({"error": "Invalid data types"}), 400
+        except (ValueError, TypeError) as e:
+            return jsonify({"error": f"Invalid data types: {e}"}), 400
 
 if __name__ == '__main__':
-    # Для локального тестирования может потребоваться запуск с SSL-сертификатом
-    # Для развертывания на хостинге с Nginx/Caddy это не нужно
     app.run(host='0.0.0.0', port=7860, debug=False)