911 lines
34 KiB
Python
911 lines
34 KiB
Python
from urllib.parse import urlencode
|
|
import re
|
|
|
|
from rest_framework import status, viewsets
|
|
from rest_framework.decorators import action
|
|
from rest_framework.permissions import IsAuthenticated
|
|
from rest_framework.response import Response
|
|
from django.conf import settings
|
|
import requests
|
|
from geopy.distance import geodesic
|
|
import logging
|
|
from ..geocoding import search_osm
|
|
from integrations.models import EncryptionConfigurationError, UserAPIKey
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class RecommendationsViewSet(viewsets.ViewSet):
|
|
permission_classes = [IsAuthenticated]
|
|
OVERPASS_URL = "https://overpass-api.de/api/interpreter"
|
|
NOMINATIM_URL = "https://nominatim.openstreetmap.org/search"
|
|
HEADERS = {"User-Agent": "Voyage Server"}
|
|
|
|
# Quality thresholds
|
|
MIN_GOOGLE_RATING = 3.0 # Minimum rating to include
|
|
MIN_GOOGLE_REVIEWS = 5 # Minimum number of reviews
|
|
MAX_RESULTS = 50 # Maximum results to return
|
|
|
|
def _get_google_api_key(self, request):
|
|
user_key = UserAPIKey.objects.filter(
|
|
user=request.user, provider="google_maps"
|
|
).first()
|
|
if user_key:
|
|
try:
|
|
decrypted = user_key.get_api_key()
|
|
except EncryptionConfigurationError:
|
|
decrypted = None
|
|
if decrypted:
|
|
return decrypted
|
|
return getattr(settings, "GOOGLE_MAPS_API_KEY", None)
|
|
|
|
def _search_google_text(self, query, api_key):
|
|
if not api_key:
|
|
return None
|
|
|
|
url = "https://places.googleapis.com/v1/places:searchText"
|
|
headers = {
|
|
"Content-Type": "application/json",
|
|
"X-Goog-Api-Key": api_key,
|
|
"X-Goog-FieldMask": "places.displayName.text,places.formattedAddress,places.location",
|
|
}
|
|
payload = {
|
|
"textQuery": query,
|
|
"maxResultCount": 5,
|
|
}
|
|
|
|
try:
|
|
response = requests.post(url, json=payload, headers=headers, timeout=10)
|
|
response.raise_for_status()
|
|
data = response.json()
|
|
except Exception:
|
|
return None
|
|
|
|
places = data.get("places", []) or []
|
|
if not places:
|
|
return None
|
|
|
|
normalized = []
|
|
for place in places:
|
|
loc = place.get("location") or {}
|
|
normalized.append(
|
|
{
|
|
"lat": loc.get("latitude"),
|
|
"lon": loc.get("longitude"),
|
|
"name": (place.get("displayName") or {}).get("text"),
|
|
"display_name": place.get("formattedAddress"),
|
|
}
|
|
)
|
|
return normalized
|
|
|
|
def calculate_quality_score(self, place_data):
|
|
"""
|
|
Calculate a quality score based on multiple factors.
|
|
Higher score = better quality recommendation.
|
|
"""
|
|
import math
|
|
|
|
score = 0.0
|
|
|
|
# Rating contribution (0-50 points)
|
|
rating = place_data.get("rating")
|
|
if rating is not None and rating > 0:
|
|
score += (rating / 5.0) * 50
|
|
|
|
# Review count contribution (0-30 points, logarithmic scale)
|
|
review_count = place_data.get("review_count")
|
|
if review_count is not None and review_count > 0:
|
|
# Logarithmic scale: 10 reviews = ~10 pts, 100 = ~20 pts, 1000 = ~30 pts
|
|
score += min(30, math.log10(review_count) * 10)
|
|
|
|
# Distance penalty (0-20 points, closer is better)
|
|
distance_km = place_data.get("distance_km")
|
|
if distance_km is not None:
|
|
if distance_km < 1:
|
|
score += 20
|
|
elif distance_km < 5:
|
|
score += 15
|
|
elif distance_km < 10:
|
|
score += 10
|
|
elif distance_km < 20:
|
|
score += 5
|
|
|
|
# Verified/business status bonus (0-10 points)
|
|
if (
|
|
place_data.get("is_verified")
|
|
or place_data.get("business_status") == "OPERATIONAL"
|
|
):
|
|
score += 10
|
|
|
|
# Has photos bonus (0-5 points)
|
|
photos = place_data.get("photos")
|
|
if photos and len(photos) > 0:
|
|
score += 5
|
|
|
|
# Has opening hours bonus (0-5 points)
|
|
opening_hours = place_data.get("opening_hours")
|
|
if opening_hours and len(opening_hours) > 0:
|
|
score += 5
|
|
|
|
return round(score, 2)
|
|
|
|
def parse_google_places(self, places, origin):
|
|
"""
|
|
Parse Google Places API results into unified format.
|
|
Enhanced with quality filtering and comprehensive data extraction.
|
|
"""
|
|
locations = []
|
|
|
|
for place in places:
|
|
location = place.get("location", {})
|
|
types = place.get("types", [])
|
|
|
|
# Extract display name
|
|
display_name = place.get("displayName", {})
|
|
name = (
|
|
display_name.get("text")
|
|
if isinstance(display_name, dict)
|
|
else display_name
|
|
)
|
|
|
|
# Extract coordinates
|
|
lat = location.get("latitude")
|
|
lon = location.get("longitude")
|
|
|
|
if not name or not lat or not lon:
|
|
continue
|
|
|
|
# Extract rating information
|
|
rating = place.get("rating")
|
|
review_count = place.get("userRatingCount", 0)
|
|
|
|
# Quality filter: Skip low-rated or unreviewed places
|
|
if rating and rating < self.MIN_GOOGLE_RATING:
|
|
continue
|
|
if review_count < self.MIN_GOOGLE_REVIEWS:
|
|
continue
|
|
|
|
# Calculate distance
|
|
distance_km = geodesic(origin, (lat, lon)).km
|
|
|
|
# Extract address information
|
|
formatted_address = place.get("formattedAddress") or place.get(
|
|
"shortFormattedAddress"
|
|
)
|
|
|
|
# Extract business status
|
|
business_status = place.get("businessStatus")
|
|
is_operational = business_status == "OPERATIONAL"
|
|
|
|
# Extract opening hours
|
|
opening_hours = place.get("regularOpeningHours", {})
|
|
current_opening_hours = place.get("currentOpeningHours", {})
|
|
is_open_now = current_opening_hours.get("openNow")
|
|
|
|
# Extract photos and construct URLs
|
|
photos = place.get("photos", [])
|
|
photo_urls = []
|
|
if photos:
|
|
# Get first 5 photos and construct full URLs
|
|
for photo in photos[:5]:
|
|
photo_name = photo.get("name", "")
|
|
if photo_name:
|
|
query = urlencode(
|
|
{
|
|
"photo_name": photo_name,
|
|
"max_height": 800,
|
|
"max_width": 800,
|
|
}
|
|
)
|
|
photo_url = f"/api/recommendations/google-photo/?{query}"
|
|
photo_urls.append(photo_url)
|
|
|
|
# Extract contact information
|
|
phone_number = place.get("nationalPhoneNumber") or place.get(
|
|
"internationalPhoneNumber"
|
|
)
|
|
website = place.get("websiteUri")
|
|
google_maps_uri = place.get("googleMapsUri")
|
|
|
|
# Extract price level
|
|
price_level = place.get("priceLevel")
|
|
|
|
# Extract editorial summary/description
|
|
editorial_summary = place.get("editorialSummary", {})
|
|
description = (
|
|
editorial_summary.get("text")
|
|
if isinstance(editorial_summary, dict)
|
|
else None
|
|
)
|
|
|
|
# Filter out unwanted types (generic categories)
|
|
filtered_types = [
|
|
t for t in types if t not in ["point_of_interest", "establishment"]
|
|
]
|
|
|
|
# Build unified response
|
|
place_data = {
|
|
"id": f"google:{place.get('id')}",
|
|
"external_id": place.get("id"),
|
|
"source": "google",
|
|
"name": name,
|
|
"description": description,
|
|
"latitude": lat,
|
|
"longitude": lon,
|
|
"address": formatted_address,
|
|
"distance_km": round(distance_km, 2),
|
|
"rating": rating,
|
|
"review_count": review_count,
|
|
"price_level": price_level,
|
|
"types": filtered_types,
|
|
"primary_type": filtered_types[0] if filtered_types else None,
|
|
"business_status": business_status,
|
|
"is_open_now": is_open_now,
|
|
"opening_hours": opening_hours.get("weekdayDescriptions", [])
|
|
if opening_hours
|
|
else None,
|
|
"phone_number": phone_number,
|
|
"website": website,
|
|
"google_maps_url": google_maps_uri,
|
|
"photos": photo_urls,
|
|
"is_verified": is_operational,
|
|
}
|
|
|
|
# Calculate quality score
|
|
place_data["quality_score"] = self.calculate_quality_score(place_data)
|
|
|
|
locations.append(place_data)
|
|
|
|
return locations
|
|
|
|
def parse_overpass_response(self, data, request, origin):
|
|
"""
|
|
Parse Overpass API (OSM) results into unified format.
|
|
Enhanced with quality filtering and comprehensive data extraction.
|
|
"""
|
|
nodes = data.get("elements", [])
|
|
locations = []
|
|
|
|
for node in nodes:
|
|
if node.get("type") not in ["node", "way", "relation"]:
|
|
continue
|
|
|
|
tags = node.get("tags", {})
|
|
|
|
# Get coordinates (for ways/relations, use center)
|
|
lat = node.get("lat") or node.get("center", {}).get("lat")
|
|
lon = node.get("lon") or node.get("center", {}).get("lon")
|
|
|
|
# Extract name (with fallbacks)
|
|
name = tags.get("name") or tags.get("official_name") or tags.get("alt_name")
|
|
|
|
if not name or lat is None or lon is None:
|
|
continue
|
|
|
|
# Calculate distance
|
|
distance_km = round(geodesic(origin, (lat, lon)).km, 2) if origin else None
|
|
|
|
# Extract address information
|
|
address_parts = [
|
|
tags.get("addr:housenumber"),
|
|
tags.get("addr:street"),
|
|
tags.get("addr:suburb") or tags.get("addr:neighbourhood"),
|
|
tags.get("addr:city"),
|
|
tags.get("addr:state"),
|
|
tags.get("addr:postcode"),
|
|
tags.get("addr:country"),
|
|
]
|
|
formatted_address = ", ".join(filter(None, address_parts)) or None
|
|
|
|
# Extract contact information
|
|
phone = tags.get("phone") or tags.get("contact:phone")
|
|
website = (
|
|
tags.get("website") or tags.get("contact:website") or tags.get("url")
|
|
)
|
|
|
|
# Extract opening hours
|
|
opening_hours = tags.get("opening_hours")
|
|
|
|
# Extract rating/stars (if available)
|
|
stars = tags.get("stars")
|
|
|
|
# Determine category/type hierarchy
|
|
category_keys = [
|
|
"tourism",
|
|
"leisure",
|
|
"amenity",
|
|
"natural",
|
|
"historic",
|
|
"attraction",
|
|
"shop",
|
|
"sport",
|
|
]
|
|
types = [tags.get(key) for key in category_keys if key in tags]
|
|
primary_type = types[0] if types else None
|
|
|
|
# Extract description and additional info
|
|
description = tags.get("description") or tags.get("note")
|
|
wikipedia = tags.get("wikipedia") or tags.get("wikidata")
|
|
|
|
# Extract image if available
|
|
image = tags.get("image") or tags.get("wikimedia_commons")
|
|
|
|
# Quality filters for OSM data
|
|
# Skip if it's just a generic POI without specific category
|
|
if not primary_type:
|
|
continue
|
|
|
|
# Skip construction or disused places
|
|
if tags.get("disused") or tags.get("construction"):
|
|
continue
|
|
|
|
# Build unified response
|
|
place_data = {
|
|
"id": f"osm:{node.get('type')}:{node.get('id')}",
|
|
"external_id": str(node.get("id")),
|
|
"source": "osm",
|
|
"name": name,
|
|
"description": description,
|
|
"latitude": lat,
|
|
"longitude": lon,
|
|
"address": formatted_address,
|
|
"distance_km": distance_km,
|
|
"rating": None, # OSM doesn't have ratings
|
|
"review_count": None,
|
|
"price_level": None,
|
|
"types": types,
|
|
"primary_type": primary_type,
|
|
"business_status": None,
|
|
"is_open_now": None,
|
|
"opening_hours": [opening_hours] if opening_hours else None,
|
|
"phone_number": phone,
|
|
"website": website,
|
|
"google_maps_url": None,
|
|
"photos": [image] if image else [],
|
|
"is_verified": bool(wikipedia), # Has Wikipedia = more verified
|
|
"osm_type": node.get("type"),
|
|
"wikipedia": wikipedia,
|
|
"stars": stars,
|
|
}
|
|
|
|
# Calculate quality score (will be lower without ratings)
|
|
place_data["quality_score"] = self.calculate_quality_score(place_data)
|
|
|
|
locations.append(place_data)
|
|
|
|
return locations
|
|
|
|
def query_overpass(self, lat, lon, radius, category, request):
|
|
"""
|
|
Query Overpass API (OpenStreetMap) for nearby places.
|
|
Enhanced with better queries and error handling.
|
|
"""
|
|
# Limit radius for OSM to prevent timeouts (max 5km for OSM due to server limits)
|
|
osm_radius = min(radius, 5000)
|
|
|
|
# Build optimized query - use simpler queries and limit results
|
|
# Reduced timeout and simplified queries to prevent 504 errors
|
|
if category == "tourism":
|
|
query = f"""
|
|
[out:json][timeout:25];
|
|
(
|
|
nwr["tourism"~"attraction|viewpoint|museum|gallery|zoo|aquarium"](around:{osm_radius},{lat},{lon});
|
|
nwr["historic"~"monument|castle|memorial"](around:{osm_radius},{lat},{lon});
|
|
nwr["leisure"~"park|garden|nature_reserve"](around:{osm_radius},{lat},{lon});
|
|
);
|
|
out center tags 50;
|
|
"""
|
|
elif category == "lodging":
|
|
query = f"""
|
|
[out:json][timeout:25];
|
|
nwr["tourism"~"hotel|motel|guest_house|hostel"](around:{osm_radius},{lat},{lon});
|
|
out center tags 50;
|
|
"""
|
|
elif category == "food":
|
|
query = f"""
|
|
[out:json][timeout:25];
|
|
nwr["amenity"~"restaurant|cafe|bar|pub"](around:{osm_radius},{lat},{lon});
|
|
out center tags 50;
|
|
"""
|
|
else:
|
|
logger.error(f"Invalid category requested: {category}")
|
|
return {"error": "Invalid category.", "results": []}
|
|
|
|
try:
|
|
response = requests.post(
|
|
self.OVERPASS_URL, data=query, headers=self.HEADERS, timeout=30
|
|
)
|
|
response.raise_for_status()
|
|
data = response.json()
|
|
except requests.exceptions.Timeout:
|
|
logger.warning(
|
|
f"Overpass API timeout for {category} at ({lat}, {lon}) with radius {osm_radius}m"
|
|
)
|
|
return {
|
|
"error": f"OpenStreetMap query timed out. The service is overloaded. Radius limited to {int(osm_radius)}m.",
|
|
"results": [],
|
|
}
|
|
except requests.exceptions.HTTPError as e:
|
|
if e.response.status_code == 504:
|
|
logger.warning(f"Overpass API 504 Gateway Timeout for {category}")
|
|
return {
|
|
"error": "OpenStreetMap server is overloaded. Try again later or use Google source.",
|
|
"results": [],
|
|
}
|
|
logger.warning(f"Overpass API HTTP error: {e}")
|
|
return {
|
|
"error": f"OpenStreetMap error: please try again later.",
|
|
"results": [],
|
|
}
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"Overpass API error: {e}")
|
|
return {
|
|
"error": f"OpenStreetMap temporarily unavailable: please try again later.",
|
|
"results": [],
|
|
}
|
|
except ValueError as e:
|
|
logger.error(f"Invalid JSON response from Overpass: {e}")
|
|
return {"error": "Invalid response from OpenStreetMap.", "results": []}
|
|
|
|
origin = (float(lat), float(lon))
|
|
locations = self.parse_overpass_response(data, request, origin)
|
|
|
|
logger.info(f"Overpass returned {len(locations)} results")
|
|
return {"error": None, "results": locations}
|
|
|
|
def query_google_nearby(self, lat, lon, radius, category, request):
|
|
"""
|
|
Query Google Places API (New) for nearby places.
|
|
Enhanced with comprehensive field masks and better error handling.
|
|
"""
|
|
api_key = self._get_google_api_key(request)
|
|
|
|
url = "https://places.googleapis.com/v1/places:searchNearby"
|
|
|
|
# Comprehensive field mask to get all useful information
|
|
headers = {
|
|
"Content-Type": "application/json",
|
|
"X-Goog-Api-Key": api_key,
|
|
"X-Goog-FieldMask": (
|
|
"places.id,"
|
|
"places.displayName,"
|
|
"places.formattedAddress,"
|
|
"places.shortFormattedAddress,"
|
|
"places.location,"
|
|
"places.types,"
|
|
"places.rating,"
|
|
"places.userRatingCount,"
|
|
"places.businessStatus,"
|
|
"places.priceLevel,"
|
|
"places.websiteUri,"
|
|
"places.googleMapsUri,"
|
|
"places.nationalPhoneNumber,"
|
|
"places.internationalPhoneNumber,"
|
|
"places.editorialSummary,"
|
|
"places.photos,"
|
|
"places.currentOpeningHours,"
|
|
"places.regularOpeningHours"
|
|
),
|
|
}
|
|
|
|
# Map categories to place types - use multiple types for better coverage
|
|
type_mapping = {
|
|
"lodging": [
|
|
"lodging",
|
|
"hotel",
|
|
"hostel",
|
|
"resort_hotel",
|
|
"extended_stay_hotel",
|
|
],
|
|
"food": [
|
|
"restaurant",
|
|
"cafe",
|
|
"bar",
|
|
"bakery",
|
|
"meal_takeaway",
|
|
"meal_delivery",
|
|
],
|
|
"tourism": [
|
|
"tourist_attraction",
|
|
"museum",
|
|
"art_gallery",
|
|
"aquarium",
|
|
"zoo",
|
|
"amusement_park",
|
|
"park",
|
|
"natural_feature",
|
|
],
|
|
}
|
|
|
|
payload = {
|
|
"includedTypes": type_mapping.get(category, ["tourist_attraction"]),
|
|
"maxResultCount": 20,
|
|
"rankPreference": "DISTANCE", # Sort by distance first
|
|
"locationRestriction": {
|
|
"circle": {
|
|
"center": {"latitude": float(lat), "longitude": float(lon)},
|
|
"radius": float(radius),
|
|
}
|
|
},
|
|
}
|
|
|
|
try:
|
|
response = requests.post(url, json=payload, headers=headers, timeout=15)
|
|
response.raise_for_status()
|
|
data = response.json()
|
|
|
|
places = data.get("places", [])
|
|
origin = (float(lat), float(lon))
|
|
locations = self.parse_google_places(places, origin)
|
|
|
|
logger.info(
|
|
f"Google Places returned {len(locations)} quality results for category '{category}'"
|
|
)
|
|
|
|
return Response(self._prepare_final_results(locations))
|
|
|
|
except requests.exceptions.Timeout:
|
|
logger.warning("Google Places API timeout, falling back to OSM")
|
|
return self.query_overpass(lat, lon, radius, category, request)
|
|
except requests.exceptions.RequestException as e:
|
|
logger.warning(f"Google Places API error: {e}, falling back to OSM")
|
|
return self.query_overpass(lat, lon, radius, category, request)
|
|
except Exception as e:
|
|
logger.error(f"Unexpected error with Google Places API: {e}")
|
|
return self.query_overpass(lat, lon, radius, category, request)
|
|
|
|
def _prepare_final_results(self, locations):
|
|
"""
|
|
Prepare final results: sort by quality score and limit results.
|
|
"""
|
|
# Sort by quality score (highest first)
|
|
locations.sort(key=lambda x: x.get("quality_score", 0), reverse=True)
|
|
|
|
# Limit to MAX_RESULTS
|
|
locations = locations[: self.MAX_RESULTS]
|
|
|
|
return locations
|
|
|
|
def _deduplicate_results(self, google_results, osm_results):
|
|
"""
|
|
Deduplicate results from both sources based on name and proximity.
|
|
Prioritize Google results when duplicates are found.
|
|
"""
|
|
from difflib import SequenceMatcher
|
|
|
|
def is_similar(name1, name2, threshold=0.85):
|
|
"""Check if two names are similar using fuzzy matching."""
|
|
return (
|
|
SequenceMatcher(None, name1.lower(), name2.lower()).ratio() > threshold
|
|
)
|
|
|
|
def is_nearby(loc1, loc2, max_distance_m=50):
|
|
"""Check if two locations are within max_distance_m meters."""
|
|
dist = geodesic(
|
|
(loc1["latitude"], loc1["longitude"]),
|
|
(loc2["latitude"], loc2["longitude"]),
|
|
).meters
|
|
return dist < max_distance_m
|
|
|
|
# Start with all Google results (higher quality)
|
|
deduplicated = list(google_results)
|
|
|
|
# Add OSM results that don't match Google results
|
|
for osm_loc in osm_results:
|
|
is_duplicate = False
|
|
for google_loc in google_results:
|
|
if is_similar(osm_loc["name"], google_loc["name"]) and is_nearby(
|
|
osm_loc, google_loc
|
|
):
|
|
is_duplicate = True
|
|
break
|
|
|
|
if not is_duplicate:
|
|
deduplicated.append(osm_loc)
|
|
|
|
return deduplicated
|
|
|
|
@action(detail=False, methods=["get"])
|
|
def query(self, request):
|
|
"""
|
|
Query both Google Places and OSM for recommendations.
|
|
Returns unified, high-quality results sorted by quality score.
|
|
|
|
Query Parameters:
|
|
- lat (required): Latitude
|
|
- lon (required): Longitude
|
|
- radius (optional): Search radius in meters (default: 5000, max: 50000)
|
|
- category (required): Category - 'tourism', 'food', or 'lodging'
|
|
- sources (optional): Comma-separated sources - 'google', 'osm', or 'both' (default: 'both')
|
|
"""
|
|
lat = request.query_params.get("lat")
|
|
lon = request.query_params.get("lon")
|
|
# Allow a free-text `location` parameter which will be geocoded
|
|
location_param = request.query_params.get("location")
|
|
radius = request.query_params.get("radius", "5000")
|
|
category = request.query_params.get("category")
|
|
sources = request.query_params.get("sources", "both").lower()
|
|
|
|
# If lat/lon not supplied, try geocoding the free-text location param
|
|
if (not lat or not lon) and location_param:
|
|
geocode_results = None
|
|
request_google_api_key = self._get_google_api_key(request)
|
|
# Try Google first if API key configured
|
|
if request_google_api_key:
|
|
try:
|
|
geocode_results = self._search_google_text(
|
|
location_param, request_google_api_key
|
|
)
|
|
except Exception:
|
|
logger.warning("Google geocoding failed; falling back to OSM")
|
|
geocode_results = None
|
|
|
|
# Fallback to OSM Nominatim
|
|
if not geocode_results:
|
|
try:
|
|
geocode_results = search_osm(location_param)
|
|
except Exception:
|
|
logger.warning("OSM geocoding failed")
|
|
geocode_results = None
|
|
|
|
# Validate geocode results
|
|
if isinstance(geocode_results, dict) and geocode_results.get("error"):
|
|
# Log internal geocoding error but avoid exposing sensitive details
|
|
logger.warning("Geocoding helper returned an internal error")
|
|
return Response(
|
|
{
|
|
"error": "Geocoding failed. Please try a different location or contact support."
|
|
},
|
|
status=400,
|
|
)
|
|
|
|
if not geocode_results:
|
|
return Response(
|
|
{"error": "Could not geocode provided location."}, status=400
|
|
)
|
|
|
|
# geocode_results expected to be a list of results; pick the best (first)
|
|
best = None
|
|
if isinstance(geocode_results, list) and len(geocode_results) > 0:
|
|
best = geocode_results[0]
|
|
elif isinstance(geocode_results, dict):
|
|
# Some helpers might return a dict when only one result found
|
|
best = geocode_results
|
|
|
|
if not best:
|
|
return Response({"error": "No geocoding results found."}, status=400)
|
|
|
|
try:
|
|
best_lat = best.get("lat") or best.get("latitude")
|
|
best_lon = best.get("lon") or best.get("longitude")
|
|
if best_lat is None or best_lon is None:
|
|
raise ValueError("missing_coordinates")
|
|
lat = float(best_lat)
|
|
lon = float(best_lon)
|
|
except Exception:
|
|
return Response(
|
|
{"error": "Geocoding result missing coordinates."}, status=400
|
|
)
|
|
|
|
# Replace location_param with display name when available for logging/debug
|
|
location_param = (
|
|
best.get("display_name") or best.get("name") or location_param
|
|
)
|
|
|
|
# Validation: require lat and lon at this point
|
|
if not lat or not lon:
|
|
return Response(
|
|
{
|
|
"error": "Latitude and longitude parameters are required (or provide a 'location' parameter to geocode)."
|
|
},
|
|
status=400,
|
|
)
|
|
|
|
try:
|
|
lat = float(lat)
|
|
lon = float(lon)
|
|
radius = min(float(radius), 50000) # Max 50km radius
|
|
except ValueError:
|
|
return Response(
|
|
{"error": "Invalid latitude, longitude, or radius value."}, status=400
|
|
)
|
|
|
|
valid_categories = ["lodging", "food", "tourism"]
|
|
if category not in valid_categories:
|
|
return Response(
|
|
{
|
|
"error": f"Invalid category. Valid categories: {', '.join(valid_categories)}"
|
|
},
|
|
status=400,
|
|
)
|
|
|
|
valid_sources = ["google", "osm", "both"]
|
|
if sources not in valid_sources:
|
|
return Response(
|
|
{
|
|
"error": f"Invalid sources. Valid options: {', '.join(valid_sources)}"
|
|
},
|
|
status=400,
|
|
)
|
|
|
|
api_key = self._get_google_api_key(request)
|
|
|
|
google_results = []
|
|
osm_results = []
|
|
|
|
# Query Google Places if available and requested
|
|
if api_key and sources in ["google", "both"]:
|
|
try:
|
|
url = "https://places.googleapis.com/v1/places:searchNearby"
|
|
headers = {
|
|
"Content-Type": "application/json",
|
|
"X-Goog-Api-Key": api_key,
|
|
"X-Goog-FieldMask": (
|
|
"places.id,places.displayName,places.formattedAddress,"
|
|
"places.shortFormattedAddress,places.location,places.types,"
|
|
"places.rating,places.userRatingCount,places.businessStatus,"
|
|
"places.priceLevel,places.websiteUri,places.googleMapsUri,"
|
|
"places.nationalPhoneNumber,places.internationalPhoneNumber,"
|
|
"places.editorialSummary,places.photos,"
|
|
"places.currentOpeningHours,places.regularOpeningHours"
|
|
),
|
|
}
|
|
|
|
type_mapping = {
|
|
"lodging": ["lodging", "hotel", "hostel", "resort_hotel"],
|
|
"food": ["restaurant", "cafe", "bar", "bakery"],
|
|
"tourism": [
|
|
"tourist_attraction",
|
|
"museum",
|
|
"art_gallery",
|
|
"aquarium",
|
|
"zoo",
|
|
"park",
|
|
],
|
|
}
|
|
|
|
payload = {
|
|
"includedTypes": type_mapping.get(category, ["tourist_attraction"]),
|
|
"maxResultCount": 20,
|
|
"rankPreference": "DISTANCE",
|
|
"locationRestriction": {
|
|
"circle": {
|
|
"center": {"latitude": lat, "longitude": lon},
|
|
"radius": radius,
|
|
}
|
|
},
|
|
}
|
|
|
|
response = requests.post(url, json=payload, headers=headers, timeout=15)
|
|
response.raise_for_status()
|
|
data = response.json()
|
|
places = data.get("places", [])
|
|
origin = (lat, lon)
|
|
google_results = self.parse_google_places(places, origin)
|
|
logger.info(f"Google Places: {len(google_results)} quality results")
|
|
|
|
except Exception as e:
|
|
logger.warning(f"Google Places failed: {e}")
|
|
|
|
# Query OSM if requested or as fallback
|
|
osm_error = None
|
|
if sources in ["osm", "both"] or (sources == "google" and not google_results):
|
|
osm_response = self.query_overpass(lat, lon, radius, category, request)
|
|
osm_results = osm_response.get("results", [])
|
|
osm_error = osm_response.get("error")
|
|
|
|
if osm_error:
|
|
logger.warning(f"OSM query had issues: {osm_error}")
|
|
|
|
# Combine and deduplicate if using both sources
|
|
if sources == "both" and google_results and osm_results:
|
|
all_results = self._deduplicate_results(google_results, osm_results)
|
|
else:
|
|
all_results = google_results + osm_results
|
|
|
|
# Prepare final results
|
|
final_results = self._prepare_final_results(all_results)
|
|
|
|
logger.info(f"Returning {len(final_results)} total recommendations")
|
|
|
|
# Build response with metadata
|
|
response_data = {
|
|
"count": len(final_results),
|
|
"results": final_results,
|
|
"sources_used": {
|
|
"google": len(google_results),
|
|
"osm": len(osm_results),
|
|
"total_before_dedup": len(google_results) + len(osm_results),
|
|
},
|
|
}
|
|
|
|
# Add warnings if there were errors but we still have some results
|
|
warnings = []
|
|
if osm_error and len(osm_results) == 0:
|
|
warnings.append(osm_error)
|
|
|
|
if warnings:
|
|
response_data["warnings"] = warnings
|
|
|
|
# If no results at all and user requested only OSM, return error status
|
|
if len(final_results) == 0 and sources == "osm" and osm_error:
|
|
# Log internal error notice for investigation but do not expose details to clients
|
|
logger.debug("OSM query error (internal)")
|
|
return Response(
|
|
{
|
|
"error": "OpenStreetMap service temporarily unavailable. Please try again later.",
|
|
"count": 0,
|
|
"results": [],
|
|
"sources_used": response_data["sources_used"],
|
|
},
|
|
status=503,
|
|
)
|
|
|
|
return Response(response_data)
|
|
|
|
@action(detail=False, methods=["get"], url_path="google-photo")
|
|
def google_photo(self, request):
|
|
photo_name = request.query_params.get("photo_name")
|
|
if not photo_name:
|
|
return Response(
|
|
{"error": "photo_name is required"},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
if not re.fullmatch(r"places/[A-Za-z0-9_-]+/photos/[A-Za-z0-9_-]+", photo_name):
|
|
return Response(
|
|
{
|
|
"error": "photo_name must match pattern: places/{place_id}/photos/{photo_id}"
|
|
},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
api_key = self._get_google_api_key(request)
|
|
if not api_key:
|
|
return Response(
|
|
{"error": "Google API key is not configured for this account."},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
try:
|
|
max_height = min(
|
|
max(int(request.query_params.get("max_height", "800")), 1), 1600
|
|
)
|
|
max_width = min(
|
|
max(int(request.query_params.get("max_width", "800")), 1), 1600
|
|
)
|
|
except ValueError:
|
|
return Response(
|
|
{"error": "max_height and max_width must be integers."},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
photo_url = f"https://places.googleapis.com/v1/{photo_name}/media"
|
|
try:
|
|
upstream = requests.get(
|
|
photo_url,
|
|
params={
|
|
"key": api_key,
|
|
"maxHeightPx": max_height,
|
|
"maxWidthPx": max_width,
|
|
},
|
|
timeout=15,
|
|
)
|
|
except requests.RequestException:
|
|
return Response(
|
|
{"error": "Unable to fetch Google photo right now."},
|
|
status=status.HTTP_502_BAD_GATEWAY,
|
|
)
|
|
|
|
if upstream.status_code >= 400:
|
|
return Response(
|
|
{"error": "Google photo unavailable."},
|
|
status=status.HTTP_502_BAD_GATEWAY,
|
|
)
|
|
|
|
response = Response(upstream.content, status=status.HTTP_200_OK)
|
|
response["Content-Type"] = upstream.headers.get("Content-Type", "image/jpeg")
|
|
cache_control = upstream.headers.get("Cache-Control")
|
|
if cache_control:
|
|
response["Cache-Control"] = cache_control
|
|
return response
|