joungmin/tasteby
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add admin features, responsive UI, user reviews, visit stats, and channel-colored markers

Browse Source 
- Admin: video management with Google Maps match status, manual restaurant mapping, restaurant remap on name change
- Admin: user management tab with favorites/reviews detail
- Admin: channel deletion fix for IDs with slashes
- Frontend: responsive mobile layout (map top, list bottom, 2-row header)
- Frontend: channel-colored map markers with legend
- Frontend: my reviews list, favorites toggle, visit counter overlay
- Frontend: force light mode for dark theme devices
- Backend: visit tracking (site_visits table), user reviews endpoint
- Backend: bulk transcript/extract streaming, geocode key fixes
- Nginx config for production deployment

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
joungmin
2026-03-07 14:52:20 +09:00
parent 36bec10bd0
commit 3694730501
27 changed files with 4346 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
backend/core/restaurant.py
View File

@@ -9,6 +9,16 @@ import oracledb
from core.db import conn
def _truncate_bytes(val: str | None, max_bytes: int) -> str | None:
"""Truncate a string to fit within max_bytes when encoded as UTF-8."""
if not val:
return val
encoded = val.encode("utf-8")
if len(encoded) <= max_bytes:
return val
return encoded[:max_bytes].decode("utf-8", errors="ignore").rstrip()
def find_by_name(name: str) -> dict | None:
"""Find a restaurant by exact name match."""
sql = "SELECT id, name, address, region, latitude, longitude FROM restaurants WHERE name = :n"
@@ -33,8 +43,19 @@ def upsert(
cuisine_type: str | None = None,
price_range: str | None = None,
google_place_id: str | None = None,
phone: str | None = None,
website: str | None = None,
business_status: str | None = None,
rating: float | None = None,
rating_count: int | None = None,
) -> str:
"""Insert or update a restaurant. Returns row id."""
# Truncate fields to fit DB column byte limits (VARCHAR2 is byte-based)
price_range = _truncate_bytes(price_range, 50)
cuisine_type = _truncate_bytes(cuisine_type, 100)
region = _truncate_bytes(region, 100)
website = _truncate_bytes(website, 500)
existing = find_by_name(name)
if existing:
sql = """
@@ -46,6 +67,11 @@ def upsert(
cuisine_type = COALESCE(:cuisine, cuisine_type),
price_range = COALESCE(:price, price_range),
google_place_id = COALESCE(:gid, google_place_id),
phone = COALESCE(:phone, phone),
website = COALESCE(:web, website),
business_status = COALESCE(:bstatus, business_status),
rating = COALESCE(:rating, rating),
rating_count = COALESCE(:rcnt, rating_count),
updated_at = SYSTIMESTAMP
WHERE id = :id
"""
@@ -54,14 +80,18 @@ def upsert(
"addr": address, "reg": region,
"lat": latitude, "lng": longitude,
"cuisine": cuisine_type, "price": price_range,
"gid": google_place_id, "id": existing["id"],
"gid": google_place_id, "phone": phone, "web": website,
"bstatus": business_status, "rating": rating, "rcnt": rating_count,
"id": existing["id"],
})
return existing["id"]
sql = """
INSERT INTO restaurants (name, address, region, latitude, longitude,
cuisine_type, price_range, google_place_id)
VALUES (:name, :addr, :reg, :lat, :lng, :cuisine, :price, :gid)
cuisine_type, price_range, google_place_id,
phone, website, business_status, rating, rating_count)
VALUES (:name, :addr, :reg, :lat, :lng, :cuisine, :price, :gid,
:phone, :web, :bstatus, :rating, :rcnt)
RETURNING id INTO :out_id
"""
with conn() as c:
@@ -71,7 +101,9 @@ def upsert(
"name": name, "addr": address, "reg": region,
"lat": latitude, "lng": longitude,
"cuisine": cuisine_type, "price": price_range,
"gid": google_place_id, "out_id": out_id,
"gid": google_place_id, "phone": phone, "web": website,
"bstatus": business_status, "rating": rating, "rcnt": rating_count,
"out_id": out_id,
})
return out_id.getvalue()[0]
@@ -116,38 +148,83 @@ def get_all(
offset: int = 0,
cuisine: str | None = None,
region: str | None = None,
channel: str | None = None,
) -> list[dict]:
"""List restaurants with optional filters."""
conditions = ["latitude IS NOT NULL"]
conditions = [
"r.latitude IS NOT NULL",
"EXISTS (SELECT 1 FROM video_restaurants vr0 WHERE vr0.restaurant_id = r.id)",
]
params: dict = {"lim": limit, "off": offset}
if cuisine:
conditions.append("cuisine_type = :cuisine")
conditions.append("r.cuisine_type = :cuisine")
params["cuisine"] = cuisine
if region:
conditions.append("region LIKE :region")
conditions.append("r.region LIKE :region")
params["region"] = f"%{region}%"
join_clause = ""
if channel:
join_clause = """
JOIN video_restaurants vr_f ON vr_f.restaurant_id = r.id
JOIN videos v_f ON v_f.id = vr_f.video_id
JOIN channels c_f ON c_f.id = v_f.channel_id
"""
conditions.append("c_f.channel_name = :channel")
params["channel"] = channel
where = " AND ".join(conditions)
sql = f"""
SELECT id, name, address, region, latitude, longitude,
cuisine_type, price_range, google_place_id
FROM restaurants
SELECT DISTINCT r.id, r.name, r.address, r.region, r.latitude, r.longitude,
r.cuisine_type, r.price_range, r.google_place_id,
r.business_status, r.rating, r.rating_count, r.updated_at
FROM restaurants r
{join_clause}
WHERE {where}
ORDER BY updated_at DESC
ORDER BY r.updated_at DESC
OFFSET :off ROWS FETCH NEXT :lim ROWS ONLY
"""
with conn() as c:
cur = c.cursor()
cur.execute(sql, params)
cols = [d[0].lower() for d in cur.description]
return [dict(zip(cols, row)) for row in cur.fetchall()]
restaurants = [dict(zip(cols, row)) for row in cur.fetchall()]
for r in restaurants:
r.pop("updated_at", None)
if not restaurants:
return restaurants
# Attach channel names for each restaurant
ids = [r["id"] for r in restaurants]
placeholders = ", ".join(f":id{i}" for i in range(len(ids)))
ch_sql = f"""
SELECT DISTINCT vr.restaurant_id, c.channel_name
FROM video_restaurants vr
JOIN videos v ON v.id = vr.video_id
JOIN channels c ON c.id = v.channel_id
WHERE vr.restaurant_id IN ({placeholders})
"""
ch_params = {f"id{i}": rid for i, rid in enumerate(ids)}
ch_map: dict[str, list[str]] = {}
with conn() as c:
cur = c.cursor()
cur.execute(ch_sql, ch_params)
for row in cur.fetchall():
ch_map.setdefault(row[0], []).append(row[1])
for r in restaurants:
r["channels"] = ch_map.get(r["id"], [])
return restaurants
def get_by_id(restaurant_id: str) -> dict | None:
sql = """
SELECT r.id, r.name, r.address, r.region, r.latitude, r.longitude,
r.cuisine_type, r.price_range, r.phone, r.website, r.google_place_id
r.cuisine_type, r.price_range, r.phone, r.website, r.google_place_id,
r.business_status, r.rating, r.rating_count
FROM restaurants r
WHERE r.id = :id
"""
@@ -165,9 +242,11 @@ def get_video_links(restaurant_id: str) -> list[dict]:
"""Get all video appearances for a restaurant."""
sql = """
SELECT v.video_id, v.title, v.url, v.published_at,
vr.foods_mentioned, vr.evaluation, vr.guests
vr.foods_mentioned, vr.evaluation, vr.guests,
c.channel_name, c.channel_id
FROM video_restaurants vr
JOIN videos v ON v.id = vr.video_id
JOIN channels c ON c.id = v.channel_id
WHERE vr.restaurant_id = :rid
ORDER BY v.published_at DESC
"""
@@ -187,6 +266,8 @@ def get_video_links(restaurant_id: str) -> list[dict]:
"foods_mentioned": _parse_json_field(foods_raw, []),
"evaluation": _parse_json_field(eval_raw, {}),
"guests": _parse_json_field(guests_raw, []),
"channel_name": r[7],
"channel_id": r[8],
})
return results