343 lines
14 KiB
Python
Executable file
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
|