Upload 11 files

app/feedback.py

@@ -1,15 +1,31 @@
 import csv
 import os
-from datetime import datetime
+from datetime import datetime, timezone
 
+from .google_oauth import GoogleAuthRequiredError, append_feedback_to_sheet, load_credentials
 from .memory import salvar_memoria_negativa
-
-
-BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-# Usa volume persistente do Fly.io montado em /data
-# Garante que feedback não seja perdido após deploy/restart
-LOGS_DIR = os.getenv("LOGS_DIR", "/data/logs")
-FEEDBACK_FILE = os.path.join(LOGS_DIR, "feedback.csv")
+
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+LOGS_DIR = os.getenv("LOGS_DIR", "/data/logs")
+FEEDBACK_FILE = os.path.join(LOGS_DIR, "feedback.csv")
+FEEDBACK_HEADERS = [
+    "timestamp",
+    "query",
+    "product_id",
+    "product_name",
+    "rating",
+    "is_helpful",
+    "note",
+    "categoria_inferida",
+    "feedback",
+    "motivo",
+    "score_final",
+    "score_semantico",
+    "bonus_lexical",
+    "penalidade_feedback",
+    "user_message",
+]
 
 
 def garantir_pasta_logs():
@@ -22,38 +38,111 @@ def inicializar_arquivo_feedback():
     if not os.path.exists(FEEDBACK_FILE):
         with open(FEEDBACK_FILE, mode="w", newline="", encoding="utf-8") as f:
             writer = csv.writer(f)
-            writer.writerow([
-                "timestamp",
-                "query",
-                "product_id",
-                "product_name",
-                "rating",
-                "is_helpful"
-            ])
+            writer.writerow(FEEDBACK_HEADERS)
+
+
+def google_sheets_habilitado():
+    return load_credentials() is not None and bool(os.getenv("GOOGLE_SPREADSHEET_ID", "").strip())
 
 
-def salvar_feedback(query, product_id, product_name, rating=None, is_helpful=None):
-    inicializar_arquivo_feedback()
+def _append_feedback_csv(row):
+    inicializar_arquivo_feedback()
 
     with open(FEEDBACK_FILE, mode="a", newline="", encoding="utf-8") as f:
         writer = csv.writer(f)
-        writer.writerow([
-            datetime.now().isoformat(),
-            query,
-            product_id,
-            product_name,
-            rating if rating is not None else "",
-            is_helpful if is_helpful is not None else ""
-        ])
-
-    # Regra simples para criar memória negativa
+        writer.writerow([row.get(header, "") for header in FEEDBACK_HEADERS])
+
+
+def _build_feedback_payload(
+    query,
+    product_id,
+    product_name,
+    rating=None,
+    is_helpful=None,
+    note=None,
+    categoria_inferida=None,
+    feedback=None,
+    motivo=None,
+    score_final=None,
+    score_semantico=None,
+    bonus_lexical=None,
+    penalidade_feedback=None,
+    user_message=None,
+):
+    return {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "query": query,
+        "product_id": product_id,
+        "product_name": product_name,
+        "rating": rating if rating is not None else "",
+        "is_helpful": is_helpful if is_helpful is not None else "",
+        "note": note or "",
+        "categoria_inferida": categoria_inferida or "",
+        "feedback": feedback or "",
+        "motivo": motivo or "",
+        "score_final": score_final if score_final is not None else "",
+        "score_semantico": score_semantico if score_semantico is not None else "",
+        "bonus_lexical": bonus_lexical if bonus_lexical is not None else "",
+        "penalidade_feedback": penalidade_feedback if penalidade_feedback is not None else "",
+        "user_message": user_message or "",
+    }
+
+
+def salvar_feedback(
+    query,
+    product_id,
+    product_name,
+    rating=None,
+    is_helpful=None,
+    note=None,
+    categoria_inferida=None,
+    feedback=None,
+    motivo=None,
+    score_final=None,
+    score_semantico=None,
+    bonus_lexical=None,
+    penalidade_feedback=None,
+    user_message=None,
+):
+    row = _build_feedback_payload(
+        query=query,
+        product_id=product_id,
+        product_name=product_name,
+        rating=rating,
+        is_helpful=is_helpful,
+        note=note,
+        categoria_inferida=categoria_inferida,
+        feedback=feedback,
+        motivo=motivo,
+        score_final=score_final,
+        score_semantico=score_semantico,
+        bonus_lexical=bonus_lexical,
+        penalidade_feedback=penalidade_feedback,
+        user_message=user_message,
+    )
+
+    _append_feedback_csv(row)
+    saved_google_sheets = False
+    warning = None
+
+    try:
+        append_feedback_to_sheet(row)
+        saved_google_sheets = True
+    except GoogleAuthRequiredError:
+        warning = "Feedback salvo localmente, mas nao enviado ao Google Sheets. Acesse /auth/google para autorizar."
+    except Exception as exc:
+        warning = (
+            "Feedback salvo localmente, mas nao enviado ao Google Sheets. "
+            f"Erro de sincronizacao: {exc}"
+        )
+
     if rating is not None and rating <= 2:
         salvar_memoria_negativa(
             query=query,
             product_id=product_id,
             product_name=product_name,
             rating=rating,
-            motivo="rating_baixo"
+            motivo="rating_baixo",
         )
 
     if is_helpful is False:
@@ -62,14 +151,18 @@ def salvar_feedback(query, product_id, product_name, rating=None, is_helpful=Non
             product_id=product_id,
             product_name=product_name,
             rating=rating if rating is not None else "",
-            motivo="nao_foi_util"
+            motivo="nao_foi_util",
         )
 
-    return {
-        "status": "ok",
-        "message": "Feedback salvo com sucesso."
-    }
-
-
-def caminho_feedback():
-    return FEEDBACK_FILE
+    response = {
+        "ok": True,
+        "saved_local": True,
+        "saved_google_sheets": saved_google_sheets,
+    }
+    if warning:
+        response["warning"] = warning
+    return response
+
+
+def caminho_feedback():
+    return FEEDBACK_FILE

app/google_oauth.py

@@ -0,0 +1,144 @@
+import json
+import os
+from pathlib import Path
+
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import Flow
+from googleapiclient.discovery import build
+
+SCOPES = [
+    "https://www.googleapis.com/auth/spreadsheets",
+    "https://www.googleapis.com/auth/drive.file",
+]
+TOKEN_FILENAME = "google_token.json"
+DATA_DIR = Path("/data")
+
+
+class GoogleOAuthError(RuntimeError):
+    pass
+
+
+class GoogleAuthRequiredError(GoogleOAuthError):
+    pass
+
+
+def get_token_path():
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    return DATA_DIR / TOKEN_FILENAME
+
+
+def _client_config():
+    client_id = os.environ.get("GOOGLE_CLIENT_ID", "").strip()
+    client_secret = os.environ.get("GOOGLE_CLIENT_SECRET", "").strip()
+    redirect_uri = os.environ.get("GOOGLE_REDIRECT_URI", "").strip()
+
+    missing = [
+        name
+        for name, value in {
+            "GOOGLE_CLIENT_ID": client_id,
+            "GOOGLE_CLIENT_SECRET": client_secret,
+            "GOOGLE_REDIRECT_URI": redirect_uri,
+        }.items()
+        if not value
+    ]
+    if missing:
+        raise GoogleOAuthError("Variaveis OAuth ausentes: " + ", ".join(missing))
+
+    return {
+        "web": {
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+            "token_uri": "https://oauth2.googleapis.com/token",
+            "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+            "redirect_uris": [redirect_uri],
+        }
+    }
+
+
+def build_flow(state=None):
+    redirect_uri = os.environ.get("GOOGLE_REDIRECT_URI", "").strip()
+    flow = Flow.from_client_config(_client_config(), scopes=SCOPES, state=state)
+    flow.redirect_uri = redirect_uri
+    return flow
+
+
+def get_authorization_url():
+    flow = build_flow()
+    authorization_url, state = flow.authorization_url(
+        access_type="offline",
+        prompt="consent",
+        include_granted_scopes="true",
+    )
+    return authorization_url, state
+
+
+def save_credentials(credentials):
+    token_path = get_token_path()
+    token_path.write_text(credentials.to_json(), encoding="utf-8")
+
+
+def load_credentials():
+    token_path = get_token_path()
+    if not token_path.exists():
+        return None
+
+    try:
+        payload = json.loads(token_path.read_text(encoding="utf-8"))
+        credentials = Credentials.from_authorized_user_info(payload, SCOPES)
+    except Exception:
+        return None
+
+    if credentials.expired and credentials.refresh_token:
+        try:
+            credentials.refresh(Request())
+            save_credentials(credentials)
+        except Exception:
+            return None
+
+    if not credentials.valid:
+        return None
+
+    return credentials
+
+
+def get_sheets_service():
+    credentials = load_credentials()
+    if credentials is None:
+        raise GoogleAuthRequiredError(
+            "Google Sheets nao autorizado. Acesse /auth/google primeiro."
+        )
+
+    return build("sheets", "v4", credentials=credentials, cache_discovery=False)
+
+
+def append_feedback_to_sheet(feedback_data):
+    spreadsheet_id = os.environ.get("GOOGLE_SPREADSHEET_ID", "").strip()
+    if not spreadsheet_id:
+        raise GoogleOAuthError("GOOGLE_SPREADSHEET_ID nao configurado.")
+
+    service = get_sheets_service()
+    fields = [
+        "timestamp",
+        "query",
+        "product_id",
+        "product_name",
+        "categoria_inferida",
+        "feedback",
+        "motivo",
+        "score_final",
+        "score_semantico",
+        "bonus_lexical",
+        "penalidade_feedback",
+        "user_message",
+    ]
+    row = [[str(feedback_data.get(field, "") or "") for field in fields]]
+
+    return service.spreadsheets().values().append(
+        spreadsheetId=spreadsheet_id,
+        range="Feedback!A:Z",
+        valueInputOption="USER_ENTERED",
+        insertDataOption="INSERT_ROWS",
+        body={"values": row},
+    ).execute()

app/main.py

@@ -1,186 +1,238 @@
-import os
-import threading
-from pathlib import Path
-
-from fastapi import FastAPI, Response
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse, RedirectResponse
-from pydantic import BaseModel
-from typing import Optional
-
-from .agent import ShoppingAgent
-from .feedback import caminho_feedback, salvar_feedback
-from .logger import salvar_log_busca
-from .memory import caminho_memoria_negativa
-
-EMBEDDING_PROVIDER = os.getenv("EMBEDDING_PROVIDER", "transformers").strip().lower()
-HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "Ana2012/bertimbau-buscador").strip()
-
-
-
-def _env_flag(name, default="true"):
-    return os.getenv(name, default).strip().lower() in {"1", "true", "yes", "on"}
-
-
-PRELOAD_AGENT = _env_flag("PRELOAD_AGENT", "true")
-LOGS_DIR = os.getenv("LOGS_DIR", "/data/logs")
-DATA_DIR = "/data"
-
-app = FastAPI(title="TCC2 Agent API")
-
-app.add_middleware(
-    CORSMiddleware,
-    # Libera temporariamente a comunicacao entre frontend na Cloudflare e backend no Fly.io.
-    allow_origins=["*"],
-    allow_credentials=False,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-agent = None
-agent_lock = threading.Lock()
-
-
-def get_agent():
-    global agent
-    if agent is None:
-        with agent_lock:
-            if agent is None:
-                agent = ShoppingAgent()
-    return agent
-
-
-@app.on_event("startup")
-def preload_agent():
-    if PRELOAD_AGENT:
-        get_agent()
-
-
-class ChatRequest(BaseModel):
-    query: Optional[str] = None
-    message: Optional[str] = None
-    top_k: int = 5
-
-
-class FeedbackRequest(BaseModel):
-    query: str
-    product_id: str
-    product_name: str
-    rating: Optional[int] = None
-    is_helpful: Optional[bool] = None
-
-
-@app.get("/health")
-def health():
-    runtime = get_agent().runtime_info() if agent is not None else None
-    return {
-        "status": "ok",
-        "agent_ready": agent is not None,
-        "embedding_provider": EMBEDDING_PROVIDER,
-        "model_repo": HF_MODEL_REPO,
-        "preload_agent": PRELOAD_AGENT,
-        "runtime": runtime,
-    }
-
-
-@app.get("/", include_in_schema=False)
-def root():
-    return RedirectResponse(url="/docs")
-
-
-@app.get("/favicon.ico", include_in_schema=False)
-def favicon():
-    return Response(status_code=204)
-
-
-@app.get("/debug/files")
-def debug_files():
-    data_path = Path(DATA_DIR)
-    logs_path = Path(LOGS_DIR)
-    feedback_path = Path(caminho_feedback())
-    memory_path = Path(caminho_memoria_negativa())
-
-    return {
-        "data_exists": data_path.exists(),
-        "logs_exists": logs_path.exists(),
-        "feedback_exists": feedback_path.exists(),
-        "negative_memory_exists": memory_path.exists(),
-        "data_files": sorted(p.name for p in data_path.iterdir()) if data_path.exists() else [],
-        "logs_files": sorted(p.name for p in logs_path.iterdir()) if logs_path.exists() else [],
-        "feedback_file": str(feedback_path),
-        "negative_memory_file": str(memory_path),
-    }
-
-
-@app.get("/debug/feedback")
-def debug_feedback():
-    feedback_path = Path(caminho_feedback())
-    if not feedback_path.exists():
-        return {"error": "arquivo nao existe"}
-
-    return {"conteudo": feedback_path.read_text(encoding="utf-8")}
-
-
-@app.get("/download/feedback")
-def download_feedback():
-    feedback_path = caminho_feedback()
-    if not os.path.exists(feedback_path):
-        return {"error": "arquivo nao existe"}
-
-    return FileResponse(feedback_path, filename="feedback.csv")
-
-
-@app.get("/debug/memory")
-def debug_memory():
-    memory_path = Path(caminho_memoria_negativa())
-    if not memory_path.exists():
-        return {"status": "missing", "file": str(memory_path)}
-
-    return {
-        "status": "ok",
-        "file": str(memory_path),
-        "content": memory_path.read_text(encoding="utf-8"),
-    }
-
-
-@app.post("/chat")
-def chat(request: ChatRequest):
-    texto = request.query or request.message
-
-    if not texto:
-        return {"error": "query ou message deve ser informado"}
-
-    resultado = get_agent().responder(texto, top_k=request.top_k)
-    salvar_log_busca(resultado)
-    return resultado
-
-
-@app.post("/feedback")
-def feedback(request: FeedbackRequest):
-    feedback_file = caminho_feedback()
-    print(
-        "Salvando feedback:",
-        {
-            "query": request.query,
-            "product_id": request.product_id,
-            "feedback_file": feedback_file,
-            "logs_dir_exists": os.path.exists(LOGS_DIR),
-        },
-    )
-
-    try:
-        return salvar_feedback(
-            query=request.query,
-            product_id=request.product_id,
-            product_name=request.product_name,
-            rating=request.rating,
-            is_helpful=request.is_helpful
-        )
-    except Exception as exc:
-        return {
-            "status": "error",
-            "message": "Erro ao salvar feedback.",
-            "detail": str(exc),
-            "feedback_file": feedback_file,
-            "logs_dir_exists": os.path.exists(LOGS_DIR),
-        }
+import os
+import threading
+from pathlib import Path
+from typing import Optional
+
+from fastapi import FastAPI, Query, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, HTMLResponse, RedirectResponse
+from pydantic import BaseModel
+
+from .agent import ShoppingAgent
+from .feedback import caminho_feedback, google_sheets_habilitado, salvar_feedback
+from .google_oauth import build_flow, get_authorization_url, load_credentials, save_credentials
+from .logger import salvar_log_busca
+from .memory import caminho_memoria_negativa
+
+EMBEDDING_PROVIDER = os.getenv("EMBEDDING_PROVIDER", "transformers").strip().lower()
+HF_MODEL_REPO = os.getenv("HF_MODEL_REPO", "Ana2012/bertimbau-buscador").strip()
+
+
+def _env_flag(name, default="true"):
+    return os.getenv(name, default).strip().lower() in {"1", "true", "yes", "on"}
+
+
+PRELOAD_AGENT = _env_flag("PRELOAD_AGENT", "true")
+LOGS_DIR = os.getenv("LOGS_DIR", "/data/logs")
+DATA_DIR = "/data"
+
+app = FastAPI(title="TCC2 Agent API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+agent = None
+agent_lock = threading.Lock()
+
+
+def get_agent():
+    global agent
+    if agent is None:
+        with agent_lock:
+            if agent is None:
+                agent = ShoppingAgent()
+    return agent
+
+
+@app.on_event("startup")
+def preload_agent():
+    if PRELOAD_AGENT:
+        get_agent()
+
+
+class ChatRequest(BaseModel):
+    query: Optional[str] = None
+    message: Optional[str] = None
+    top_k: int = 5
+
+
+class FeedbackRequest(BaseModel):
+    query: str
+    product_id: str
+    product_name: str
+    rating: Optional[int] = None
+    is_helpful: Optional[bool] = None
+    note: Optional[str] = None
+    categoria_inferida: Optional[str] = None
+    feedback: Optional[str] = None
+    motivo: Optional[str] = None
+    score_final: Optional[float] = None
+    score_semantico: Optional[float] = None
+    bonus_lexical: Optional[float] = None
+    penalidade_feedback: Optional[float] = None
+    user_message: Optional[str] = None
+
+
+@app.get("/health")
+def health():
+    runtime = get_agent().runtime_info() if agent is not None else None
+    return {
+        "status": "ok",
+        "agent_ready": agent is not None,
+        "embedding_provider": EMBEDDING_PROVIDER,
+        "model_repo": HF_MODEL_REPO,
+        "preload_agent": PRELOAD_AGENT,
+        "runtime": runtime,
+        "feedback_storage": "google_sheets" if google_sheets_habilitado() else "csv",
+    }
+
+
+@app.get("/", include_in_schema=False)
+def root():
+    return RedirectResponse(url="/docs")
+
+
+@app.get("/favicon.ico", include_in_schema=False)
+def favicon():
+    return Response(status_code=204)
+
+
+@app.get("/auth/google")
+def auth_google():
+    authorization_url, _state = get_authorization_url()
+    return RedirectResponse(url=authorization_url)
+
+
+@app.get("/oauth2callback")
+def oauth2callback(code: str = Query(...)):
+    flow = build_flow()
+    flow.fetch_token(code=code)
+    save_credentials(flow.credentials)
+    return HTMLResponse(
+        "<h3>Autorizacao concluida. O backend ja pode salvar feedbacks no Google Sheets.</h3>"
+    )
+
+
+@app.get("/auth/status")
+def auth_status():
+    credentials = load_credentials()
+    connected = credentials is not None and credentials.valid
+    return {
+        "google_sheets_connected": connected,
+        "message": (
+            "Google Sheets autorizado e pronto para uso."
+            if connected
+            else "Google Sheets ainda nao autorizado. Acesse /auth/google para conectar."
+        ),
+    }
+
+
+@app.get("/debug/files")
+def debug_files():
+    data_path = Path(DATA_DIR)
+    logs_path = Path(LOGS_DIR)
+    feedback_path = Path(caminho_feedback())
+    memory_path = Path(caminho_memoria_negativa())
+
+    return {
+        "data_exists": data_path.exists(),
+        "logs_exists": logs_path.exists(),
+        "feedback_exists": feedback_path.exists(),
+        "negative_memory_exists": memory_path.exists(),
+        "data_files": sorted(p.name for p in data_path.iterdir()) if data_path.exists() else [],
+        "logs_files": sorted(p.name for p in logs_path.iterdir()) if logs_path.exists() else [],
+        "feedback_file": str(feedback_path),
+        "negative_memory_file": str(memory_path),
+        "feedback_storage": "google_sheets" if google_sheets_habilitado() else "csv",
+    }
+
+
+@app.get("/debug/feedback")
+def debug_feedback():
+    feedback_path = Path(caminho_feedback())
+    if not feedback_path.exists():
+        return {"error": "arquivo nao existe"}
+
+    return {"conteudo": feedback_path.read_text(encoding="utf-8")}
+
+
+@app.get("/download/feedback")
+def download_feedback():
+    feedback_path = caminho_feedback()
+    if not os.path.exists(feedback_path):
+        return {"error": "arquivo nao existe"}
+
+    return FileResponse(feedback_path, filename="feedback.csv")
+
+
+@app.get("/debug/memory")
+def debug_memory():
+    memory_path = Path(caminho_memoria_negativa())
+    if not memory_path.exists():
+        return {"status": "missing", "file": str(memory_path)}
+
+    return {
+        "status": "ok",
+        "file": str(memory_path),
+        "content": memory_path.read_text(encoding="utf-8"),
+    }
+
+
+@app.post("/chat")
+def chat(request: ChatRequest):
+    texto = request.query or request.message
+
+    if not texto:
+        return {"error": "query ou message deve ser informado"}
+
+    resultado = get_agent().responder(texto, top_k=request.top_k)
+    salvar_log_busca(resultado)
+    return resultado
+
+
+@app.post("/feedback")
+def feedback(request: FeedbackRequest):
+    feedback_file = caminho_feedback()
+    print(
+        "Salvando feedback:",
+        {
+            "query": request.query,
+            "product_id": request.product_id,
+            "feedback_file": feedback_file,
+            "logs_dir_exists": os.path.exists(LOGS_DIR),
+            "google_sheets_enabled": google_sheets_habilitado(),
+        },
+    )
+
+    try:
+        return salvar_feedback(
+            query=request.query,
+            product_id=request.product_id,
+            product_name=request.product_name,
+            rating=request.rating,
+            is_helpful=request.is_helpful,
+            note=request.note,
+            categoria_inferida=request.categoria_inferida,
+            feedback=request.feedback,
+            motivo=request.motivo,
+            score_final=request.score_final,
+            score_semantico=request.score_semantico,
+            bonus_lexical=request.bonus_lexical,
+            penalidade_feedback=request.penalidade_feedback,
+            user_message=request.user_message,
+        )
+    except Exception as exc:
+        return {
+            "ok": False,
+            "saved_local": False,
+            "saved_google_sheets": False,
+            "detail": str(exc),
+            "feedback_file": feedback_file,
+            "logs_dir_exists": os.path.exists(LOGS_DIR),
+            "google_sheets_enabled": google_sheets_habilitado(),
+        }