ehsan-dashboards/dashboards/executive/api_server.py

343 lines
14 KiB
Python
Executable file

#!/usr/bin/env python3
import os
import json
import sqlite3
import time
import secrets
from http.server import HTTPServer, BaseHTTPRequestHandler
from socketserver import ThreadingMixIn
from urllib.parse import urlparse, parse_qs
from datetime import datetime, timezone, timedelta
PORT = 8098
DB_PATH = "/data/dashboards/ekeepa/executive/executive.db"
# Fallback local path if running outside server
if not os.path.exists("/data/dashboards/ekeepa/executive"):
DB_PATH = "/workspace/ekeepa/executive/dashboards/executive.db"
IRAN_TZ = timezone(timedelta(hours=3, minutes=30))
class ThreadingHTTPServer(ThreadingMixIn, HTTPServer):
daemon_threads = True
def get_db():
conn = sqlite3.connect(DB_PATH, timeout=10.0)
conn.row_factory = sqlite3.Row
return conn
# Server-Side Session Storage (Token -> User info)
SESSIONS = {}
# Active SSE client queues
SSE_CLIENTS = []
def broadcast_sse(event_data):
msg = f"data: {json.dumps(event_data, ensure_ascii=False)}\n\n"
dead = []
for q in SSE_CLIENTS:
try:
q.write(msg.encode('utf-8'))
q.flush()
except Exception:
dead.append(q)
for d in dead:
if d in SSE_CLIENTS:
SSE_CLIENTS.remove(d)
class ExecutiveAPIHandler(BaseHTTPRequestHandler):
def _send_headers(self, status=200, content_type="application/json"):
self.send_response(status)
self.send_header('Content-Type', content_type)
self.send_header('Access-Control-Allow-Origin', '*')
self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
self.send_header('Access-Control-Allow-Headers', 'Content-Type, Authorization')
self.send_header('Cache-Control', 'no-cache, no-store, must-revalidate')
self.end_headers()
def do_OPTIONS(self):
self._send_headers(204)
def _get_auth_user(self):
auth_header = self.headers.get('Authorization', '')
if auth_header.startswith('Bearer '):
token = auth_header.split(' ', 1)[1].strip()
return SESSIONS.get(token)
return None
def do_GET(self):
url = urlparse(self.path)
path = url.path.rstrip('/')
if path.startswith('/executive/api'):
path = path[len('/executive/api'):]
if not path:
path = '/'
# Real-time Server-Sent Events (SSE)
if path == '/events':
self.send_response(200)
self.send_header('Content-Type', 'text/event-stream')
self.send_header('Cache-Control', 'no-cache')
self.send_header('Connection', 'keep-alive')
self.send_header('Access-Control-Allow-Origin', '*')
self.end_headers()
SSE_CLIENTS.append(self.wfile)
try:
while True:
time.sleep(15)
self.wfile.write(b": keepalive\n\n")
self.wfile.flush()
except Exception:
if self.wfile in SSE_CLIENTS:
SSE_CLIENTS.remove(self.wfile)
return
# Fetch All Data directly from SQLite
if path in ('/state', '/'):
conn = get_db()
c = conn.cursor()
# Fetch tasks grouped by status
tasks_rows = c.execute("SELECT * FROM tasks ORDER BY priority DESC, created_at DESC").fetchall()
tasks = [dict(r) for r in tasks_rows]
# Fetch meetings with server-calculated status
meetings_rows = c.execute("SELECT * FROM meetings ORDER BY start_time ASC").fetchall()
now_iran = datetime.now(IRAN_TZ)
meetings = []
for r in meetings_rows:
m = dict(r)
# Compute is_past / is_live / is_future based on actual clock
try:
start_dt = datetime.fromisoformat(m['start_time']).replace(tzinfo=IRAN_TZ)
end_dt = datetime.fromisoformat(m['end_time']).replace(tzinfo=IRAN_TZ)
if now_iran > end_dt:
m['computed_status'] = 'past'
elif start_dt <= now_iran <= end_dt:
m['computed_status'] = 'live'
else:
m['computed_status'] = 'upcoming'
except Exception:
m['computed_status'] = 'upcoming'
meetings.append(m)
conn.close()
response_data = {
"tasks": tasks,
"meetings": meetings,
"server_time_iran": now_iran.strftime("%Y-%m-%d %H:%M:%S"),
"counts": {
"todo": len([t for t in tasks if t['status'] == 'todo']),
"in_progress": len([t for t in tasks if t['status'] == 'in_progress']),
"blocked": len([t for t in tasks if t['status'] == 'blocked']),
"done": len([t for t in tasks if t['status'] == 'done'])
}
}
self._send_headers(200)
self.wfile.write(json.dumps(response_data, ensure_ascii=False).encode('utf-8'))
return
if path == '/briefing':
conn = get_db()
c = conn.cursor()
crisis_cnt = c.execute("SELECT count(*) FROM tasks WHERE priority='crisis' AND status != 'done'").fetchone()[0]
blocked_cnt = c.execute("SELECT count(*) FROM tasks WHERE status='blocked'").fetchone()[0]
now_str = datetime.now(IRAN_TZ).strftime("%Y-%m-%d")
today_meetings = c.execute("SELECT count(*) FROM meetings WHERE start_time LIKE ?", (f"{now_str}%",)).fetchone()[0]
conn.close()
brief = {
"date": datetime.now(IRAN_TZ).strftime("%Y/%m/%d"),
"summary": f"امروز {today_meetings} رویداد در تقویم دارید. {crisis_cnt} اقدام با اولویت بحران و {blocked_cnt} تسک متوقف‌شده نیازمند تعیین تکلیف هستند.",
"today_meetings": today_meetings,
"crisis_tasks": crisis_cnt,
"blocked_tasks": blocked_cnt
}
self._send_headers(200)
self.wfile.write(json.dumps(brief, ensure_ascii=False).encode('utf-8'))
return
self._send_headers(404)
self.wfile.write(json.dumps({"error": "Endpoint not found"}).encode('utf-8'))
def do_POST(self):
url = urlparse(self.path)
path = url.path.rstrip('/')
if path.startswith('/executive/api'):
path = path[len('/executive/api'):]
if not path:
path = '/'
content_length = int(self.headers.get('Content-Length', 0))
post_data = self.rfile.read(content_length)
try:
payload = json.loads(post_data.decode('utf-8')) if post_data else {}
except Exception:
payload = {}
# 1. Real Server Authentication
if path == '/auth':
pin = payload.get('pin', '').strip()
# Valid Executive PINs
if pin == "Hf@43117700":
token = "sec_tk_hamed_" + secrets.token_hex(16)
SESSIONS[token] = {"role": "ceo", "name": "حامد فلاحی"}
self._send_headers(200)
self.wfile.write(json.dumps({
"success": True,
"token": token,
"role": "ceo",
"name": "حامد فلاحی"
}).encode('utf-8'))
return
elif pin == "Mo@43117700":
token = "sec_tk_ea_" + secrets.token_hex(16)
SESSIONS[token] = {"role": "ea", "name": "محدثه معصومی"}
self._send_headers(200)
self.wfile.write(json.dumps({
"success": True,
"token": token,
"role": "ea",
"name": "محدثه معصومی"
}).encode('utf-8'))
return
else:
self._send_headers(401)
self.wfile.write(json.dumps({"success": False, "error": "کلید دسترسی نامعتبر است."}).encode('utf-8'))
return
# 2. Strict Kanban State Updates in Database
if path == '/tasks':
action = payload.get('action')
conn = get_db()
c = conn.cursor()
if action == 'update_status':
task_id = payload.get('id')
new_status = payload.get('status')
blocked_reason = payload.get('blocked_reason')
c.execute("""
UPDATE tasks
SET status = ?, blocked_reason = ?, updated_at = CURRENT_TIMESTAMP
WHERE id = ?
""", (new_status, blocked_reason, task_id))
conn.commit()
updated_task = dict(c.execute("SELECT * FROM tasks WHERE id = ?", (task_id,)).fetchone() or {})
conn.close()
# Notify all connected clients via SSE
broadcast_sse({"type": "task_updated", "task": updated_task})
self._send_headers(200)
self.wfile.write(json.dumps({"success": True, "task": updated_task}).encode('utf-8'))
return
if action == 'create':
task_data = payload.get('task', {})
new_id = f"t_{int(time.time()*1000)}"
c.execute("""
INSERT INTO tasks (id, title, description, owner, department, priority, status, blocked_reason, deadline)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
""", (
new_id,
task_data.get('title', 'اقدام جدید'),
task_data.get('description', ''),
task_data.get('owner', 'حامد فلاحی'),
task_data.get('department', 'عملیات'),
task_data.get('priority', 'medium'),
task_data.get('status', 'todo'),
task_data.get('blocked_reason'),
task_data.get('deadline', 'امروز')
))
conn.commit()
created = dict(c.execute("SELECT * FROM tasks WHERE id = ?", (new_id,)).fetchone())
conn.close()
broadcast_sse({"type": "task_created", "task": created})
if created.get('priority') == 'crisis':
broadcast_sse({"type": "crisis_alert", "task": created})
self._send_headers(201)
self.wfile.write(json.dumps({"success": True, "task": created}).encode('utf-8'))
return
conn.close()
self._send_headers(400)
self.wfile.write(json.dumps({"error": "Unknown task action"}).encode('utf-8'))
return
# 3. Real NLP Brain Dump Processor
if path == '/smart-parse':
text = payload.get('text', '').strip()
if not text:
self._send_headers(400)
self.wfile.write(json.dumps({"error": "Text is required"}).encode('utf-8'))
return
import re
# NLP Entity Extraction Logic
owner = 'حامد فلاحی' if ('حامد' in text or '#حامد' in text) else 'محدثه معصومی'
priority = 'medium'
if 'بحران' in text or '!بحران' in text:
priority = 'crisis'
elif 'فوری' in text or '!فوری' in text:
priority = 'urgent'
elif 'بالا' in text:
priority = 'high'
deadline = 'امروز'
if 'فردا' in text:
deadline = 'فردا'
elif 'هفته' in text:
deadline = 'این هفته'
# Clean task title
title = re.sub(r'[#!][^\s]+', '', text).strip()
if not title:
title = text
conn = get_db()
c = conn.cursor()
new_id = f"t_{int(time.time()*1000)}"
c.execute("""
INSERT INTO tasks (id, title, description, owner, department, priority, status, deadline)
VALUES (?, ?, ?, ?, 'هوشمند', ?, 'todo', ?)
""", (new_id, title, f"ثبت‌شده از پردازش زبان طبیعی: {text}", owner, priority, deadline))
c.execute("""
INSERT INTO braindump (id, raw_text, parsed_json, status)
VALUES (?, ?, ?, 'processed')
""", (new_id, text, json.dumps({"owner": owner, "priority": priority, "deadline": deadline}, ensure_ascii=False)))
conn.commit()
created = dict(c.execute("SELECT * FROM tasks WHERE id = ?", (new_id,)).fetchone())
conn.close()
broadcast_sse({"type": "task_created", "task": created})
if priority == 'crisis':
broadcast_sse({"type": "crisis_alert", "task": created})
self._send_headers(201)
self.wfile.write(json.dumps({
"success": True,
"parsed": {
"title": title,
"owner": owner,
"priority": priority,
"deadline": deadline
},
"task": created
}, ensure_ascii=False).encode('utf-8'))
return
self._send_headers(404)
self.wfile.write(json.dumps({"error": "Endpoint not found"}).encode('utf-8'))
if __name__ == '__main__':
server = ThreadingHTTPServer(('0.0.0.0', PORT), ExecutiveAPIHandler)
print(f"Starting SQLite-Powered Executive Cockpit API Server on port {PORT}...")
try:
server.serve_forever()
except KeyboardInterrupt:
pass