Spaces:
Sleeping
Sleeping
Download app.py from fmgprog/processador_back: direct link, hf CLI and curl.
- Browser
- Download file 6.03 kB
-
https://huggingface.co/spaces/fmgprog/processador_back/resolve/main/app.py
- Command line
-
hf download hf://spaces/fmgprog/processador_back/app.py
-
curl -L -o app.py https://huggingface.co/spaces/fmgprog/processador_back/resolve/main/app.py
6.03 kB
| from flask import Flask, request, jsonify, abort | |
| from flask_cors import CORS | |
| from supabase_client import supabase | |
| import uuid | |
| import secrets | |
| from datetime import datetime, timedelta | |
| import pytz | |
| import os | |
| from jose import jwt | |
| import requests | |
| from functools import wraps | |
| SUPABASE_URL = os.environ["SUPABASE_URL"] | |
| app = Flask(__name__) | |
| CORS(app) | |
| def require_role(role): | |
| def decorator(f): | |
| def decorated(*args, **kwargs): | |
| if not hasattr(request, "user"): | |
| return jsonify({"error": "Usuário não autenticado"}), 401 | |
| user_role = request.user.get("role") | |
| if user_role != role: | |
| return jsonify({"error": "Permissão negada"}), 403 | |
| return f(*args, **kwargs) | |
| return decorated | |
| return decorator | |
| def login_required(f): | |
| def decorated(*args, **kwargs): | |
| auth_header = request.headers.get("Authorization") | |
| if not auth_header: | |
| return jsonify({"error": "Token de usuário ausente"}), 401 | |
| try: | |
| token = auth_header.split(" ")[1] | |
| # valida JWT | |
| user = supabase.auth.get_user(token) | |
| user_id = user.user.id | |
| # busca dados do usuário na tabela users | |
| result = supabase.table("users") \ | |
| .select("id, nome, role") \ | |
| .eq("id", user_id) \ | |
| .single() \ | |
| .execute() | |
| if not result.data: | |
| return jsonify({"error": "Usuário não registrado"}), 403 | |
| # anexamos ao request | |
| request.user = result.data | |
| except Exception as e: | |
| print("Erro auth:", e) | |
| return jsonify({"error": "Token inválido"}), 401 | |
| return f(*args, **kwargs) | |
| return decorated | |
| def auditoria(processo_id,result,reason): | |
| ip = request.headers.get("X-Forwarded-For", request.remote_addr) | |
| user_agent = request.headers.get("User-Agent") | |
| supabase.table("acessos").insert({ | |
| "processo_id": processo_id, | |
| "ip": ip, | |
| "user_agent": user_agent, | |
| "success": result, | |
| "reason": reason | |
| }).execute() | |
| def criar_processo(): | |
| tz = pytz.timezone("America/Sao_Paulo") | |
| payload = request.get_json() | |
| tipo = payload.get("viewType") | |
| data = payload.get("data") | |
| nome_arquivo = payload.get("nome_arquivo") | |
| token = secrets.token_urlsafe(16) | |
| expires_at = datetime.now(tz) + timedelta(hours=48) # Expira em 48 horas | |
| if not payload: | |
| abort(400, "JSON inválido") | |
| if tipo not in ["homologacao", "classificacao"]: | |
| abort(400, "Tipo inválido") | |
| if not isinstance(data, list): | |
| abort(400, "Payload inválido") | |
| result = supabase.table("processos").insert({ | |
| "tipo": tipo, | |
| "edital": nome_arquivo, | |
| "payload": data, | |
| "token": token, | |
| "expires_at": expires_at.isoformat() | |
| }).execute() | |
| processo_id = result.data[0]["id"] | |
| return jsonify({ | |
| "id": processo_id, | |
| "token": token | |
| }) | |
| def obter_processo(processo_id): | |
| result = supabase.table("processos") \ | |
| .select("tipo, edital, payload, decisions, token, created_at, expires_at, last_mod") \ | |
| .eq("id", processo_id) \ | |
| .single() \ | |
| .execute() | |
| processo = result.data | |
| now = datetime.now(pytz.timezone("America/Sao_Paulo")) | |
| token = request.args.get("t") | |
| if not token: | |
| msg = "Token ausente" | |
| auditoria(processo_id,False,msg) | |
| abort(403, msg) | |
| if not result.data: | |
| msg = "Dados Inválidos" | |
| auditoria(processo_id,False,msg) | |
| abort(404, msg) | |
| if processo["token"] != token: | |
| msg = "Token inválido" | |
| auditoria(processo_id,False,msg) | |
| abort(403, msg) | |
| if processo["expires_at"] and now > datetime.fromisoformat(processo["expires_at"]): | |
| msg = "Link expirado" | |
| auditoria(processo_id,False,msg) | |
| abort(410, msg) | |
| msg = "Dados do processo carregados com sucesso" | |
| auditoria(processo_id,True,msg) | |
| return jsonify({ | |
| "tipo": processo["tipo"], | |
| "edital": processo["edital"], | |
| "payload": processo["payload"], | |
| "decisions": processo["decisions"], | |
| }) | |
| def listar_processos(): | |
| result = supabase.table("processos") \ | |
| .select(""" | |
| id, | |
| tipo, | |
| edital, | |
| token, | |
| created_at, | |
| expires_at, | |
| last_mod, | |
| acessos:acessos(count) | |
| """) \ | |
| .order("created_at", desc=True) \ | |
| .execute() | |
| return jsonify(result.data) | |
| def revogar_processo(processo_id): | |
| token = request.headers.get("X-Admin-Token") | |
| if token != os.environ.get("ADMIN_TOKEN"): | |
| abort(403) | |
| supabase.table("processos") \ | |
| .update({"expires_at": datetime.now(pytz.timezone("America/Sao_Paulo")).isoformat()}) \ | |
| .eq("id", processo_id) \ | |
| .execute() | |
| return jsonify({"ok": True}) | |
| def me(): | |
| auth_header = request.headers.get("Authorization") | |
| if not auth_header: | |
| return jsonify({"error": "Sem token"}), 401 | |
| token = auth_header.split(" ")[1] | |
| try: | |
| user = supabase.auth.get_user(token) | |
| except Exception as e: | |
| print("Erro token:", e) | |
| return jsonify({"error": "Token inválido"}), 401 | |
| user_id = user.user.id | |
| result = supabase.table("users") \ | |
| .select("id, nome, role") \ | |
| .eq("id", user_id) \ | |
| .single() \ | |
| .execute() | |
| return jsonify(result.data) | |
| if __name__ == "__main__": | |
| app.run(host="0.0.0.0", port=7860) |