Upload 10 files

README.md

@@ -1,13 +1,110 @@
+# LINE Webhook → HuggingFace Sentiment Server
+
+รับ message event จาก LINE Official Account → วิเคราะห์ sentiment → ส่งต่อให้ Lovable AI Dashboard
+
 ---
-title: Line Webhook
-emoji: 📊
-colorFrom: indigo
-colorTo: yellow
-sdk: gradio
-sdk_version: 6.19.0
-python_version: '3.13'
-app_file: app.py
-pinned: false
+
+## Architecture
+
+```
+LINE OA  →  Webhook Server  →  HuggingFace Inference API
+                ↓                        ↓
+           PostgreSQL  ←─────── sentiment result
+                ↓
+            Redis Pub/Sub
+                ↓
+         Lovable AI Dashboard (real-time)
+```
+
+---
+
+## Quick Start
+
+### 1. Clone & ติดตั้ง
+
+```bash
+git clone <repo>
+cd line-webhook
+cp .env.example .env      # แก้ไขค่าใน .env
+```
+
+### 2. ใส่ค่าใน .env
+
+```env
+LINE_CHANNEL_SECRET=<จาก LINE Developers Console>
+LINE_CHANNEL_ACCESS_TOKEN=<จาก LINE Developers Console>
+HF_API_TOKEN=<จาก huggingface.co/settings/tokens>
+```
+
+### 3. รันด้วย Docker Compose
+
+```bash
+docker compose up -d
+```
+
+Server พร้อมที่ `http://localhost:8000`
+
+### 4. รัน Local (ไม่ใช้ Docker)
+
+```bash
+python -m venv venv
+source venv/bin/activate        # Windows: venv\Scripts\activate
+pip install -r requirements.txt
+uvicorn app.main:app --reload
+```
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## ตั้งค่า LINE Webhook URL
+
+1. ไปที่ [LINE Developers Console](https://developers.line.biz/console/)
+2. เลือก Channel → **Messaging API**
+3. ตั้ง Webhook URL เป็น:
+   ```
+   https://your-domain.com/webhook
+   ```
+   > ใช้ **ngrok** สำหรับ local dev:
+   > ```bash
+   > ngrok http 8000
+   > ```
+   > แล้วใช้ URL ที่ ngrok ให้ เช่น `https://abc123.ngrok.io/webhook`
+4. เปิด **Use webhook** → Verify
+
+---
+
+## API Endpoints
+
+| Method | Path | คำอธิบาย |
+|--------|------|-----------|
+| `POST` | `/webhook` | รับ event จาก LINE (signature verified) |
+| `GET` | `/health` | Health check |
+| `GET` | `/api/conversations` | ดึง conversation list พร้อม sentiment |
+| `GET` | `/api/sentiment-summary` | สรุป sentiment ภาพรวม 7 วัน |
+
+---
+
+## HuggingFace Model
+
+แนะนำใช้ model เหล่านี้ (ตั้งใน `HF_MODEL_NAME`):
+
+| Model | ภาษา | ความแม่นยำ |
+|-------|-------|-----------|
+| `cardiffnlp/twitter-xlm-roberta-base-sentiment` | Multilingual (ไทยได้) | ดี |
+| `airesearch/wangchanberta-base-att-spm-uncased` | ไทยเป็นหลัก | ดีมากสำหรับไทย |
+
+---
+
+## Alert System
+
+เมื่อ negative score ≥ `NEGATIVE_ALERT_THRESHOLD` (default 0.80):
+- Push event ไปที่ Redis channel `sentiment:alert_live`
+- Lovable Dashboard รับ alert แสดง notification ทันที
+
+---
+
+## รัน Tests
+
+```bash
+pip install pytest pytest-asyncio
+pytest tests/ -v
+```

config.py

@@ -0,0 +1,29 @@
+"""
+Configuration — อ่านค่าจาก Environment Variables (.env)
+"""
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
+
+    # LINE
+    LINE_CHANNEL_SECRET: str
+    LINE_CHANNEL_ACCESS_TOKEN: str
+
+    # HuggingFace
+    HF_API_TOKEN: str
+    HF_MODEL_NAME: str = "cardiffnlp/twitter-xlm-roberta-base-sentiment"
+
+    # Database
+    DATABASE_URL: str = "postgresql://user:password@localhost:5432/sentiment_db"
+
+    # Redis
+    REDIS_URL: str = "redis://localhost:6379"
+
+    # Alert threshold — negative score ≥ ค่านี้จะ trigger alert
+    NEGATIVE_ALERT_THRESHOLD: float = 0.80
+
+
+settings = Settings()

database.py

@@ -0,0 +1,155 @@
+"""
+Database Layer — PostgreSQL (asyncpg)
+──────────────────────────────────────
+เก็บ conversation history และ sentiment results
+"""
+
+import logging
+import asyncpg
+from datetime import datetime, timezone
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+CREATE_TABLE_SQL = """
+CREATE TABLE IF NOT EXISTS conversations (
+    id            SERIAL PRIMARY KEY,
+    conv_id       TEXT        NOT NULL UNIQUE,
+    user_id       TEXT        NOT NULL,
+    message       TEXT        NOT NULL,
+    source_type   TEXT        DEFAULT 'user',
+    timestamp     BIGINT      NOT NULL,          -- LINE timestamp (ms)
+    created_at    TIMESTAMPTZ DEFAULT NOW(),
+
+    -- Sentiment fields (nullable ก่อน analyze เสร็จ)
+    sentiment_label  TEXT,                        -- positive | neutral | negative
+    sentiment_score  FLOAT,                       -- confidence score 0–1
+    raw_scores       JSONB                         -- {"positive": 0.8, ...}
+);
+
+CREATE INDEX IF NOT EXISTS idx_conv_user     ON conversations(user_id);
+CREATE INDEX IF NOT EXISTS idx_conv_created  ON conversations(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_conv_sentiment ON conversations(sentiment_label);
+"""
+
+
+class Database:
+    def __init__(self):
+        self._pool: asyncpg.Pool | None = None
+
+    async def connect(self):
+        self._pool = await asyncpg.create_pool(
+            dsn=settings.DATABASE_URL,
+            min_size=2,
+            max_size=10,
+        )
+        logger.info("✅ Database pool created")
+
+    async def disconnect(self):
+        if self._pool:
+            await self._pool.close()
+
+    async def _pool_ok(self) -> asyncpg.Pool:
+        if not self._pool:
+            await self.connect()
+        return self._pool
+
+    # ── Write ──────────────────────────────────────────────────────────────────
+
+    async def save_conversation(
+        self,
+        conv_id: str,
+        user_id: str,
+        message: str,
+        timestamp: int,
+        source_type: str = "user",
+    ) -> dict:
+        pool = await self._pool_ok()
+        async with pool.acquire() as conn:
+            row = await conn.fetchrow(
+                """
+                INSERT INTO conversations (conv_id, user_id, message, source_type, timestamp)
+                VALUES ($1, $2, $3, $4, $5)
+                ON CONFLICT (conv_id) DO NOTHING
+                RETURNING *
+                """,
+                conv_id, user_id, message, source_type, timestamp,
+            )
+        return dict(row) if row else {}
+
+    async def update_sentiment(
+        self,
+        conv_id: str,
+        label: str,
+        score: float,
+        raw_scores: dict,
+    ) -> None:
+        import json
+        pool = await self._pool_ok()
+        async with pool.acquire() as conn:
+            await conn.execute(
+                """
+                UPDATE conversations
+                SET sentiment_label = $1,
+                    sentiment_score = $2,
+                    raw_scores      = $3
+                WHERE conv_id = $4
+                """,
+                label, score, json.dumps(raw_scores), conv_id,
+            )
+
+    # ── Read ───────────────────────────────────────────────────────────────────
+
+    async def get_conversations(self, limit: int = 50, offset: int = 0) -> list[dict]:
+        pool = await self._pool_ok()
+        async with pool.acquire() as conn:
+            rows = await conn.fetch(
+                """
+                SELECT conv_id, user_id, message, sentiment_label,
+                       sentiment_score, raw_scores, created_at
+                FROM conversations
+                ORDER BY created_at DESC
+                LIMIT $1 OFFSET $2
+                """,
+                limit, offset,
+            )
+        return [dict(r) for r in rows]
+
+    async def get_sentiment_summary(self) -> dict:
+        """สรุปยอดรวม sentiment สำหรับ stat cards"""
+        pool = await self._pool_ok()
+        async with pool.acquire() as conn:
+            rows = await conn.fetch(
+                """
+                SELECT
+                    COUNT(*) FILTER (WHERE sentiment_label = 'positive') AS positive,
+                    COUNT(*) FILTER (WHERE sentiment_label = 'neutral')  AS neutral,
+                    COUNT(*) FILTER (WHERE sentiment_label = 'negative') AS negative,
+                    COUNT(*) AS total
+                FROM conversations
+                WHERE created_at >= NOW() - INTERVAL '7 days'
+                """
+            )
+        row = dict(rows[0])
+        total = row["total"] or 1  # ป้องกัน div/0
+        return {
+            "positive": {"count": row["positive"], "pct": round(row["positive"] / total * 100, 1)},
+            "neutral":  {"count": row["neutral"],  "pct": round(row["neutral"]  / total * 100, 1)},
+            "negative": {"count": row["negative"], "pct": round(row["negative"] / total * 100, 1)},
+            "total":    row["total"],
+            "period":   "last 7 days",
+        }
+
+
+async def init_db():
+    """สร้าง table ถ้ายังไม่มี (รันตอน startup)"""
+    pool = await asyncpg.create_pool(dsn=settings.DATABASE_URL)
+    async with pool.acquire() as conn:
+        await conn.execute(CREATE_TABLE_SQL)
+    await pool.close()
+    logger.info("✅ Database initialized")
+
+
+# Singleton
+db = Database()

docker-compose.yml

@@ -0,0 +1,49 @@
+version: "3.9"
+
+services:
+
+  # ── Webhook Server ────────────────────────────────────────────────────────────
+  webhook:
+    build: .
+    ports:
+      - "8000:8000"
+    env_file: .env
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    volumes:
+      - ./app:/app/app          # hot-reload ใน dev mode
+    command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
+
+  # ── PostgreSQL ────────────────────────────────────────────────────────────────
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: user
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: sentiment_db
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U user -d sentiment_db"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  # ── Redis ─────────────────────────────────────────────────────────────────────
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+
+volumes:
+  postgres_data:

main.py

@@ -0,0 +1,188 @@
+"""
+LINE Official Account Webhook Server
+────────────────────────────────────
+รับ event จาก LINE → ตรวจสอบ signature → ส่งต่อไปยัง HuggingFace Sentiment API
+"""
+
+import hashlib
+import hmac
+import base64
+import logging
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Request, HTTPException, BackgroundTasks
+from fastapi.responses import JSONResponse
+
+from app.config import settings
+from app.models import LineWebhookPayload
+from app.queue import message_queue
+from app.sentiment import analyze_sentiment
+from app.database import db, init_db
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Startup / Shutdown events"""
+    logger.info("🚀 Starting LINE Webhook Server...")
+    await init_db()
+    yield
+    logger.info("🛑 Shutting down...")
+
+
+app = FastAPI(
+    title="LINE Webhook Sentiment Server",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+
+# ─── Signature Verification ────────────────────────────────────────────────────
+
+def verify_line_signature(body: bytes, signature: str) -> bool:
+    """
+    ตรวจสอบ X-Line-Signature header จาก LINE
+    ป้องกัน request ปลอมที่ไม่ได้มาจาก LINE Platform
+    """
+    channel_secret = settings.LINE_CHANNEL_SECRET.encode("utf-8")
+    hash_value = hmac.new(channel_secret, body, hashlib.sha256).digest()
+    expected = base64.b64encode(hash_value).decode("utf-8")
+    return hmac.compare_digest(expected, signature)
+
+
+# ─── Webhook Endpoint ──────────────────────────────────────────────────────────
+
+@app.post("/webhook")
+async def line_webhook(request: Request, background_tasks: BackgroundTasks):
+    """
+    รับ webhook events จาก LINE Platform
+
+    Flow:
+    1. ตรวจสอบ LINE Signature
+    2. Parse JSON payload
+    3. กรองเฉพาะ message events (text)
+    4. ส่งไปประมวลผล sentiment ใน background
+    """
+    # 1. ดึง raw body สำหรับตรวจสอบ signature
+    body = await request.body()
+    signature = request.headers.get("X-Line-Signature", "")
+
+    if not signature:
+        logger.warning("⚠️  Missing X-Line-Signature header")
+        raise HTTPException(status_code=400, detail="Missing signature")
+
+    if not verify_line_signature(body, signature):
+        logger.warning("⚠️  Invalid signature — request rejected")
+        raise HTTPException(status_code=403, detail="Invalid signature")
+
+    # 2. Parse payload
+    try:
+        payload = LineWebhookPayload.model_validate_json(body)
+    except Exception as e:
+        logger.error(f"❌ Failed to parse payload: {e}")
+        raise HTTPException(status_code=400, detail="Invalid payload")
+
+    # 3. Process events ใน background (ไม่ block LINE server)
+    for event in payload.events:
+        if event.type == "message" and event.message.type == "text":
+            background_tasks.add_task(process_message_event, event)
+        else:
+            logger.debug(f"Skipped event type: {event.type}")
+
+    # LINE ต้องการ HTTP 200 ทันที ไม่งั้น retry
+    return JSONResponse(content={"status": "ok"})
+
+
+# ─── Background Processing ─────────────────────────────────────────────────────
+
+async def process_message_event(event):
+    """
+    ประมวลผลแต่ละ message event:
+    1. บันทึก raw conversation ลง DB
+    2. ส่งไป HuggingFace วิเคราะห์ sentiment
+    3. อัปเดต result กลับใน DB
+    4. Push ผ่าน queue ไปยัง Dashboard
+    """
+    user_id  = event.source.userId
+    msg_text = event.message.text
+    conv_id  = event.replyToken or f"{user_id}_{event.timestamp}"
+
+    logger.info(f"📨 New message | user={user_id} | text={msg_text[:50]}...")
+
+    # Step 1 — บันทึก conversation
+    conversation = await db.save_conversation(
+        conv_id=conv_id,
+        user_id=user_id,
+        message=msg_text,
+        timestamp=event.timestamp,
+        source_type=event.source.type,
+    )
+
+    # Step 2 — วิเคราะห์ sentiment ผ่าน HuggingFace
+    sentiment_result = await analyze_sentiment(msg_text)
+    logger.info(
+        f"🧠 Sentiment | label={sentiment_result.label} "
+        f"score={sentiment_result.score:.3f}"
+    )
+
+    # Step 3 — อ���ปเดต sentiment ใน DB
+    await db.update_sentiment(
+        conv_id=conv_id,
+        label=sentiment_result.label,
+        score=sentiment_result.score,
+        raw_scores=sentiment_result.raw_scores,
+    )
+
+    # Step 4 — Push ไป queue → Dashboard รับแบบ real-time
+    await message_queue.push({
+        "conv_id":   conv_id,
+        "user_id":   user_id,
+        "message":   msg_text,
+        "sentiment": sentiment_result.label,
+        "score":     sentiment_result.score,
+        "timestamp": event.timestamp,
+    })
+
+    # Alert ถ้า negative สูงเกิน threshold
+    if (
+        sentiment_result.label == "negative"
+        and sentiment_result.score >= settings.NEGATIVE_ALERT_THRESHOLD
+    ):
+        logger.warning(
+            f"🚨 HIGH NEGATIVE ALERT | user={user_id} | score={sentiment_result.score:.3f}"
+        )
+        await message_queue.push_alert({
+            "type":    "high_negative",
+            "conv_id": conv_id,
+            "user_id": user_id,
+            "score":   sentiment_result.score,
+            "message": msg_text,
+        })
+
+
+# ─── Health & Dashboard Endpoints ─────────────────────────────────────────────
+
+@app.get("/health")
+async def health_check():
+    """Health check สำหรับ load balancer / monitoring"""
+    return {"status": "healthy", "version": app.version}
+
+
+@app.get("/api/conversations")
+async def get_conversations(limit: int = 50, offset: int = 0):
+    """
+    ดึง conversation list พร้อม sentiment สำหรับ Lovable Dashboard
+    """
+    data = await db.get_conversations(limit=limit, offset=offset)
+    return {"conversations": data, "total": len(data)}
+
+
+@app.get("/api/sentiment-summary")
+async def get_sentiment_summary():
+    """
+    สรุป sentiment ภาพรวมสำหรับ stat cards บน Dashboard
+    """
+    summary = await db.get_sentiment_summary()
+    return summary

models.py

@@ -0,0 +1,49 @@
+"""
+Pydantic models — LINE Webhook Payload
+ครอบคลุม event types ที่จำเป็นสำหรับ chat conversation
+"""
+
+from typing import Optional, Literal
+from pydantic import BaseModel
+
+
+# ─── Source ───────────────────────────────────────────────────────────────────
+
+class LineSource(BaseModel):
+    type: Literal["user", "group", "room"]
+    userId: Optional[str] = None
+    groupId: Optional[str] = None
+    roomId: Optional[str] = None
+
+
+# ─── Message ──────────────────────────────────────────────────────────────────
+
+class LineMessage(BaseModel):
+    id: str
+    type: Literal["text", "image", "sticker", "location", "audio", "video", "file"]
+    text: Optional[str] = None   # มีเฉพาะ type=text
+
+
+# ─── Events ───────────────────────────────────────────────────────────────────
+
+class LineEvent(BaseModel):
+    type: Literal["message", "follow", "unfollow", "join", "leave", "postback"]
+    timestamp: int
+    replyToken: Optional[str] = None
+    source: LineSource
+    message: Optional[LineMessage] = None
+
+
+# ─── Root Payload ─────────────────────────────────────────────────────────────
+
+class LineWebhookPayload(BaseModel):
+    destination: str        # Channel ID ปลายทาง
+    events: list[LineEvent]
+
+
+# ─── Sentiment Result ─────────────────────────────────────────────────────────
+
+class SentimentResult(BaseModel):
+    label: Literal["positive", "neutral", "negative"]
+    score: float                          # confidence ของ label หลัก (0–1)
+    raw_scores: dict[str, float]          # {"positive": 0.8, "neutral": 0.1, "negative": 0.1}

queue.py

@@ -0,0 +1,80 @@
+"""
+Message Queue — Redis
+─────────────────────
+Push sentiment results → Dashboard (Lovable AI) รับแบบ real-time
+
+ใช้ Redis List + Pub/Sub:
+  - LPUSH  sentiment:results  → queue สำหรับ polling
+  - PUBLISH sentiment:live    → pub/sub สำหรับ WebSocket / SSE
+"""
+
+import json
+import logging
+import redis.asyncio as aioredis
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+QUEUE_KEY  = "sentiment:results"
+ALERT_KEY  = "sentiment:alerts"
+PUBSUB_CH  = "sentiment:live"
+ALERT_CH   = "sentiment:alert_live"
+
+
+class MessageQueue:
+    def __init__(self):
+        self._redis: aioredis.Redis | None = None
+
+    async def _get_redis(self) -> aioredis.Redis:
+        if self._redis is None:
+            self._redis = await aioredis.from_url(
+                settings.REDIS_URL,
+                encoding="utf-8",
+                decode_responses=True,
+            )
+        return self._redis
+
+    async def push(self, data: dict) -> None:
+        """
+        Push sentiment result เข้า queue และ publish ให้ subscribers
+        """
+        try:
+            r = await self._get_redis()
+            serialized = json.dumps(data, ensure_ascii=False)
+
+            # List (Lovable polling หรือ worker ดึงไปประมวลผลต่อ)
+            await r.lpush(QUEUE_KEY, serialized)
+            await r.ltrim(QUEUE_KEY, 0, 999)  # เก็บแค่ 1,000 รายการล่าสุด
+
+            # Pub/Sub (real-time Dashboard WebSocket)
+            await r.publish(PUBSUB_CH, serialized)
+
+            logger.debug(f"✅ Queued: conv_id={data.get('conv_id')}")
+
+        except Exception as e:
+            logger.error(f"❌ Queue push failed: {e}")
+
+    async def push_alert(self, data: dict) -> None:
+        """Push high-negative alert แยก channel"""
+        try:
+            r = await self._get_redis()
+            serialized = json.dumps(data, ensure_ascii=False)
+            await r.lpush(ALERT_KEY, serialized)
+            await r.publish(ALERT_CH, serialized)
+            logger.warning(f"🚨 Alert pushed: {data}")
+        except Exception as e:
+            logger.error(f"❌ Alert push failed: {e}")
+
+    async def get_recent(self, count: int = 50) -> list[dict]:
+        """ดึง result ล่าสุดจาก queue สำหรับ initial load"""
+        try:
+            r = await self._get_redis()
+            items = await r.lrange(QUEUE_KEY, 0, count - 1)
+            return [json.loads(i) for i in items]
+        except Exception as e:
+            logger.error(f"❌ Queue read failed: {e}")
+            return []
+
+
+# Singleton instance
+message_queue = MessageQueue()

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.115.5
+uvicorn[standard]==0.32.1
+httpx==0.28.0
+pydantic==2.10.3
+pydantic-settings==2.6.1
+asyncpg==0.30.0
+redis==5.2.1
+python-dotenv==1.0.1

sentiment.py

@@ -0,0 +1,93 @@
+"""
+HuggingFace Sentiment Analysis
+─────────────────────────────
+เรียก HuggingFace Inference API เพื่อวิเคราะห์ความรู้สึกของข้อความภาษาไทย
+
+Model ที่แนะนำ:
+  - airesearch/wangchanberta-base-att-spm-uncased  (ภาษาไทย ทั่วไป)
+  - pythainlp/thai-sentiment-analysis               (ถ้ามี fine-tune)
+  - อาจใช้ multilingual model: cardiffnlp/twitter-xlm-roberta-base-sentiment
+"""
+
+import httpx
+import logging
+from app.config import settings
+from app.models import SentimentResult
+
+logger = logging.getLogger(__name__)
+
+HF_API_URL = (
+    f"https://api-inference.huggingface.co/models/{settings.HF_MODEL_NAME}"
+)
+
+# Label mapping จาก model output → ชื่อ standard
+LABEL_MAP = {
+    # WangchanBERTa / Thai models
+    "pos":      "positive",
+    "neu":      "neutral",
+    "neg":      "negative",
+    # cardiffnlp / XLM-RoBERTa
+    "positive": "positive",
+    "neutral":  "neutral",
+    "negative": "negative",
+    # LABEL_0/1/2 fallback (ขึ้นกับ model)
+    "LABEL_0":  "negative",
+    "LABEL_1":  "neutral",
+    "LABEL_2":  "positive",
+}
+
+
+async def analyze_sentiment(text: str) -> SentimentResult:
+    """
+    ส่งข้อความไปวิเคราะห์ที่ HuggingFace แล้วคืน SentimentResult
+
+    HuggingFace Inference API คืนรูปแบบ:
+    [[{"label": "pos", "score": 0.91}, {"label": "neg", "score": 0.05}, ...]]
+    """
+    headers = {"Authorization": f"Bearer {settings.HF_API_TOKEN}"}
+    payload = {"inputs": text, "options": {"wait_for_model": True}}
+
+    try:
+        async with httpx.AsyncClient(timeout=15.0) as client:
+            response = await client.post(HF_API_URL, headers=headers, json=payload)
+            response.raise_for_status()
+            data = response.json()
+
+        # Flatten nested list ที่ HF คืนมา
+        scores = data[0] if isinstance(data[0], list) else data
+
+        # แปลง label และสร้าง raw_scores dict
+        raw_scores: dict[str, float] = {}
+        for item in scores:
+            normalized = LABEL_MAP.get(item["label"], item["label"].lower())
+            raw_scores[normalized] = round(item["score"], 4)
+
+        # หา label ที่มี score สูงสุด
+        best_label = max(raw_scores, key=raw_scores.get)
+
+        return SentimentResult(
+            label=best_label,
+            score=raw_scores[best_label],
+            raw_scores=raw_scores,
+        )
+
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HuggingFace API error {e.response.status_code}: {e.response.text}")
+        return _fallback_result()
+
+    except httpx.TimeoutException:
+        logger.error("HuggingFace API timeout")
+        return _fallback_result()
+
+    except Exception as e:
+        logger.error(f"Unexpected error in sentiment analysis: {e}")
+        return _fallback_result()
+
+
+def _fallback_result() -> SentimentResult:
+    """คืน neutral เมื่อ API ล้มเหลว เพื่อไม่ให้ระบบหยุด"""
+    return SentimentResult(
+        label="neutral",
+        score=0.0,
+        raw_scores={"positive": 0.0, "neutral": 0.0, "negative": 0.0},
+    )

test_webhook.py

@@ -0,0 +1,97 @@
+"""
+Unit Tests — Webhook Server
+"""
+
+import hashlib
+import hmac
+import base64
+import pytest
+from fastapi.testclient import TestClient
+from unittest.mock import AsyncMock, patch
+
+
+# ─── Signature Helper ──────────────────────────────────────────────────────────
+
+def make_signature(body: bytes, secret: str) -> str:
+    h = hmac.new(secret.encode(), body, hashlib.sha256).digest()
+    return base64.b64encode(h).decode()
+
+
+# ─── Fixture: mock settings ───────────────────────────────────────────────────
+
+@pytest.fixture(autouse=True)
+def mock_settings(monkeypatch):
+    monkeypatch.setenv("LINE_CHANNEL_SECRET", "test_secret")
+    monkeypatch.setenv("LINE_CHANNEL_ACCESS_TOKEN", "test_token")
+    monkeypatch.setenv("HF_API_TOKEN", "hf_test")
+    monkeypatch.setenv("DATABASE_URL", "postgresql://u:p@localhost/test")
+    monkeypatch.setenv("REDIS_URL", "redis://localhost:6379")
+
+
+# ─── Tests ────────────────────────────────────────────────────────────────────
+
+class TestSignatureVerification:
+    def test_valid_signature(self):
+        from app.main import verify_line_signature
+        body = b'{"test": "data"}'
+        sig  = make_signature(body, "test_secret")
+        assert verify_line_signature(body, sig) is True
+
+    def test_invalid_signature(self):
+        from app.main import verify_line_signature
+        body = b'{"test": "data"}'
+        assert verify_line_signature(body, "wrong_sig") is False
+
+    def test_empty_signature(self):
+        from app.main import verify_line_signature
+        assert verify_line_signature(b"body", "") is False
+
+
+class TestPayloadParsing:
+    def test_parse_text_message(self):
+        from app.models import LineWebhookPayload
+        raw = """{
+            "destination": "U123",
+            "events": [{
+                "type": "message",
+                "timestamp": 1700000000000,
+                "replyToken": "token123",
+                "source": {"type": "user", "userId": "Uabc"},
+                "message": {"id": "m1", "type": "text", "text": "สวัสดีครับ"}
+            }]
+        }"""
+        payload = LineWebhookPayload.model_validate_json(raw)
+        assert len(payload.events) == 1
+        assert payload.events[0].message.text == "สวัสดีครับ"
+
+    def test_skip_non_text_event(self):
+        from app.models import LineWebhookPayload
+        raw = """{
+            "destination": "U123",
+            "events": [{
+                "type": "follow",
+                "timestamp": 1700000000000,
+                "source": {"type": "user", "userId": "Uabc"}
+            }]
+        }"""
+        payload = LineWebhookPayload.model_validate_json(raw)
+        assert payload.events[0].type == "follow"
+        assert payload.events[0].message is None
+
+
+class TestSentimentResult:
+    def test_label_mapping_positive(self):
+        from app.models import SentimentResult
+        r = SentimentResult(
+            label="positive",
+            score=0.91,
+            raw_scores={"positive": 0.91, "neutral": 0.07, "negative": 0.02},
+        )
+        assert r.label == "positive"
+        assert r.score == 0.91
+
+    def test_fallback_is_neutral(self):
+        from app.sentiment import _fallback_result
+        r = _fallback_result()
+        assert r.label == "neutral"
+        assert r.score == 0.0