parastoo-dashboards/parastoo_dashboard/sync_server.py

549 lines
24 KiB
Python

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Parastoo Dashboard — Jira & Google Sheet Sync API
Writes ONLY Parastoo's own tasks (Jira: parastoosamaavt / Sheet tab: Parastoo|Graphic).
Uses Composio REST API directly (no heavy binary, no extra deps).
"""
import json, os, sys, time, subprocess, urllib.request, urllib.parse, urllib.error, uuid
from datetime import datetime, timezone, timedelta
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import team_hours_lib as TH
JIRA_URL = os.environ.get("JIRA_URL", "https://jira.ekeepa-dev.ir")
JIRA_PAT = os.environ.get("JIRA_PAT", "")
JIRA_USER = os.environ.get("JIRA_USER", "parastoosamaavt")
JIRA_PROJECT = os.environ.get("JIRA_PROJECT", "EMO")
SHEET_ID = os.environ.get("SHEET_ID", "1a5IDPDSBsLZgF2pnB8GjkjATfCNEzvo_M1cxsm08eFo")
SHEET_TAB = os.environ.get("SHEET_TAB", "Parastoo|Graphic")
# Binary lives at $HOME/.composio/composio; it must run with cwd=$HOME
COMPOSIO_BIN = os.environ.get("COMPOSIO_BIN", os.path.expanduser("~/.composio/composio"))
COMPOSIO_CWD = os.environ.get("COMPOSIO_CWD", os.path.expanduser("~"))
# The Google Sheets connected account that has WRITE access to the Parastoo tab
COMPOSIO_SHEETS_ACCOUNT = os.environ.get("COMPOSIO_SHEETS_ACCOUNT", "googlesheets_binary-adieu")
TEHRAN = timezone(timedelta(hours=3, minutes=30))
CAT_FA = {
'instagram': 'اینستاگرام', 'messenger': 'تلگرام و بله', 'linkedin': 'لینکدین و آپارات',
'design': 'طراحی گرافیک', 'video': 'تدوین ویدیو و AI', 'calendar': 'تقویم محتوایی',
'campaign': 'کمپین و گیمیفیکیشن', 'influencer': 'اینفلوئنسر مارکتینگ',
'analytics': 'تحلیل داده و گزارش', 'meeting': 'جلسات و هماهنگی', 'other': 'سایر'
}
def to_jalali(gy, gm, gd):
g_d_m = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]
jy = 979 if gy > 1600 else 0
gy2 = gy - 621 if gy > 1600 else gy
gy3 = gy2 + 1 if gm > 2 else gy2
days = (365 * gy2 + (gy3 + 3) // 4 - (gy3 + 99) // 100 + (gy3 + 399) // 400
- 80 + gd + g_d_m[gm - 1])
jy += 33 * (days // 12053); days %= 12053
jy += 4 * (days // 1461); days %= 1461
if days > 365:
jy += (days - 1) // 365; days = (days - 1) % 365
jm = 1 + days // 31 if days < 186 else 7 + (days - 186) // 30
jd = 1 + (days % 31 if days < 186 else (days - 186) % 30)
return jy, jm, jd
def sheet_date(s):
"""ISO -> D/M/YYYY (Google Sheets interprets M/D/YYYY for en locale; use D/M for fa)."""
try:
y, m, d = (int(x) for x in str(s).split("-"))
return f"{d}/{m}/{y}"
except Exception:
return str(s or "")
def sheet_week(s):
try:
y, m, d = (int(x) for x in str(s).split("-"))
return str(to_jalali(y, m, d)[1])
except Exception:
return ""
def iso_week(s):
try:
from datetime import date
y, m, d = (int(x) for x in str(s).split("-"))
return date(y, m, d).isocalendar()[1]
except Exception:
return 0
# ---------------- Jira ----------------
def jira(method, path, data=None):
body = json.dumps(data).encode() if data is not None else None
req = urllib.request.Request(JIRA_URL + path, data=body, method=method, headers={
"Authorization": f"Bearer {JIRA_PAT}", "Content-Type": "application/json"})
try:
with urllib.request.urlopen(req, timeout=30) as r:
c = r.read().decode()
return json.loads(c) if c else {}
except urllib.error.HTTPError as e:
raise RuntimeError(f"Jira {e.code}: {e.read().decode()[:200]}")
def jira_create(summary, desc, hours):
p = {"fields": {"project": {"key": JIRA_PROJECT}, "summary": summary[:250],
"description": desc or summary, "issuetype": {"name": "Task"},
"assignee": {"name": JIRA_USER}}}
key = jira("POST", "/rest/api/2/issue", p).get("key")
if key and hours and float(hours) > 0:
try:
jira("POST", f"/rest/api/2/issue/{key}/worklog",
{"timeSpent": f"{float(hours)}h", "comment": "ثبت خودکار از داشبورد پرستو"})
except Exception as e:
print("worklog warn:", e, file=sys.stderr)
return key
def jira_comment(key, text):
try:
jira("POST", f"/rest/api/2/issue/{key}/comment", {"body": text})
return True
except Exception:
return False
def jira_close(key):
tr = jira("GET", f"/rest/api/2/issue/{key}/transitions").get("transitions", [])
for t in tr:
nm = (t["name"] + " " + t.get("to", {}).get("name", "")).lower()
if any(s in nm for s in ["done", "closed", "resolved", "بسته", "دان"]):
jira("POST", f"/rest/api/2/issue/{key}/transitions", {"transition": {"id": t["id"]}})
return t.get("to", {}).get("name", t["name"])
return None
def jira_ping():
"""Lightweight reachability check: does the Jira API respond with a valid auth?"""
try:
q = urllib.parse.urlencode({"jql": "project = " + JIRA_PROJECT, "maxResults": 1,
"fields": "summary"})
d = jira("GET", f"/rest/api/2/search?{q}")
return d.get("total") is not None
except Exception:
return False
def jira_list(maxr=60):
q = urllib.parse.urlencode({"jql": f'assignee = "{JIRA_USER}" ORDER BY updated DESC',
"maxResults": maxr, "fields": "summary,status,priority,updated"})
out = []
for i in jira("GET", f"/rest/api/2/search?{q}").get("issues", []):
f = i["fields"]
out.append({"key": i["key"], "summary": f.get("summary"),
"status": (f.get("status") or {}).get("name"),
"priority": (f.get("priority") or {}).get("name"),
"updated": (f.get("updated") or "")[:10]})
return out
# ---------------- Composio (Google Sheets) ----------------
def composio_execute(slug, arguments):
"""Run a Composio tool through the authenticated CLI (session-based auth)."""
env = dict(os.environ)
env["HOME"] = COMPOSIO_CWD
env["PATH"] = os.path.dirname(COMPOSIO_BIN) + ":" + env.get("PATH", "")
cmd = [COMPOSIO_BIN, "execute", slug, "-d", json.dumps(arguments)]
if slug.startswith("GOOGLESHEETS") and COMPOSIO_SHEETS_ACCOUNT:
cmd += ["--account", COMPOSIO_SHEETS_ACCOUNT]
out, stderr, rc = "", "", 0
for attempt in range(2):
r = subprocess.run(cmd, capture_output=True, text=True, timeout=150, env=env, cwd=COMPOSIO_CWD)
out, stderr, rc = (r.stdout or "").strip(), (r.stderr or ""), r.returncode
if out:
break
time.sleep(1.5)
if not out:
raise RuntimeError(f"Composio empty output after retry (exit {rc}): {stderr[:200]}")
j = json.loads(out)
if not j.get("successful", True):
raise RuntimeError(f"Composio: {str(j.get('error'))[:250]}")
return j.get("data", j)
def sheet_rows():
d = composio_execute("GOOGLESHEETS_VALUES_GET",
{"spreadsheet_id": SHEET_ID, "range": f"'{SHEET_TAB}'!A1:N2000"})
return d.get("values", []) if isinstance(d, dict) else []
def sheet_append(rows):
"""Append rows to the sheet.
Uses an explicit UPDATE at `last_data_row + 1` rather than the APPEND endpoint.
Reason: the sheet carries `-` formulas in column H far below the real data, and Google's
APPEND treats those as part of the table, so it jumps ~40 rows past the last real entry.
Writing directly keeps tasks contiguous with existing data.
The range MUST span the same number of columns as the widest row, otherwise values drift
into adjacent columns. Columns A..L = 12.
"""
if not rows:
return None
width = max((len(r) for r in rows), default=12)
last_col = "ABCDEFGHIJKLMNOP"[:max(width, 10)][-1] # last COLUMN LETTER, not the slice
start = sheet_last_data_row() + 1
end = start + len(rows) - 1
rng = f"'{SHEET_TAB}'!A{start}:{last_col}{end}"
return composio_execute("GOOGLESHEETS_VALUES_UPDATE", {
"spreadsheet_id": SHEET_ID, "range": rng,
"value_input_option": "USER_ENTERED", "values": rows})
def sheet_last_data_row():
"""Highest row index with an owner/task value. Bounded windows keep it to <=3 calls."""
last = 1
windows = [(650, 100), (750, 100), (850, 100)]
for start, size in windows:
try:
d = composio_execute("GOOGLESHEETS_VALUES_GET",
{"spreadsheet_id": SHEET_ID,
"range": f"'{SHEET_TAB}'!A{start}:J{start + size - 1}"})
except Exception:
continue
vals = d.get("values", []) if isinstance(d, dict) else []
for i, row in enumerate(vals):
if len(row) > 3 and (str(row[2]).strip() or str(row[1]).strip()):
last = max(last, start + i)
return last
# ---------------- HTTP ----------------
# ---------------- SERVER-SIDE TASK STORE ----------------
# Lets the assistant (this chat / cron) push tasks that the dashboard merges into localStorage.
STORE_PATH = os.environ.get("TASK_STORE", "/tmp/parastoo_store/tasks.json")
def load_store():
try:
with open(STORE_PATH, encoding="utf-8") as fh:
data = json.load(fh)
return data if isinstance(data, list) else []
except Exception:
return []
def save_store(store):
try:
os.makedirs(os.path.dirname(STORE_PATH), exist_ok=True)
tmp = STORE_PATH + ".tmp"
with open(tmp, "w", encoding="utf-8") as fh:
json.dump(store, fh, ensure_ascii=False, indent=1)
os.replace(tmp, STORE_PATH)
except Exception as exc:
print("store save failed:", str(exc)[:150], flush=True)
def build_sheet_rows(tasks):
"""Convert task dicts into sheet rows (A..L) matching the Parastoo|Graphic layout."""
rows = []
for t in tasks:
if t.get("demo") or not str(t.get("title") or "").strip():
continue
est, act = t.get("est") or 0, t.get("act") or 0
try:
estf, actf = float(est or 0), float(act or 0)
except Exception:
estf, actf = 0.0, 0.0
e_status = "UnderEstimate" if estf > actf else ("OverEstimate" if estf < actf else "-")
rows.append([
"", "", t.get("title", ""), "پرستو", sheet_date(t.get("date")),
str(est or ""), str(act or ""),
{"done": "Done", "prog": "NotDone"}.get(t.get("status"), "NotDone"),
e_status, sheet_week(t.get("date")),
(t.get("note") or "") + (f" [{t.get('jira')}]" if t.get("jira") else "")
+ (" [لحظه‌ای]" if t.get("adhoc") else ""),
])
return rows
def sheet_tasks_today(target_date=None):
"""Read the Parastoo sheet, propagate inherited dates, return today's tasks.
The sheet uses an 'inherited date' pattern: only the first row of each day
has a date in column D; subsequent rows of the same day leave D empty."""
from datetime import datetime, timedelta
if target_date is None:
target_date = datetime.now(TEHRAN).strftime("%Y-%m-%d")
# Normalize target to multiple formats for matching
parts = target_date.split("-")
ty, tm, td = int(parts[0]), int(parts[1]), int(parts[2])
patterns = [
f"{tm}/{td}/{ty}", # 9/22/2026
f"{td}/{tm}/{ty}", # 22/9/2026
f"{ty}-{tm:02d}-{td:02d}", # 2026-09-22
f"{tm:02d}/{td:02d}/{ty}", # 09/22/2026
]
# Read from row 650 onward (last ~200 rows of data)
all_rows = []
for start in range(650, 900, 100):
try:
d = composio_execute("GOOGLESHEETS_VALUES_GET", {
"spreadsheet_id": SHEET_ID,
"range": f"\'{SHEET_TAB}\'!A{start}:N{start+99}"})
vals = (d or {}).get("values") or []
all_rows.extend([(start + i, r) for i, r in enumerate(vals)])
if len(vals) < 100:
break
except:
break
# Propagate dates: column D (index 3) carries the date
current_date = ""
dated_rows = []
for idx, row in all_rows:
cells = row + [""] * (14 - len(row))
raw_date = str(cells[3]).strip()
if raw_date and any(c.isdigit() for c in raw_date):
current_date = raw_date
task = str(cells[1]).strip()
actual = str(cells[5]).strip()
status = str(cells[6]).strip()
if task:
dated_rows.append({
"row": idx, "date": current_date, "task": task,
"owner": str(cells[2]).strip() or "پرستو",
"estimate": str(cells[4]).strip(),
"actual": actual,
"status": status,
"estimation_status": str(cells[7]).strip(),
"note": str(cells[9]).strip() if len(cells) > 9 else "",
"clock_in": str(cells[10]).strip() if len(cells) > 10 else "",
})
# Filter to today
today_tasks = [r for r in dated_rows if any(p in r["date"] for p in patterns)]
return {"ok": True, "date": target_date, "count": len(today_tasks),
"tasks": today_tasks, "total_scanned": len(dated_rows)}
class H(BaseHTTPRequestHandler):
def _send(self, obj, code=200):
b = json.dumps(obj, ensure_ascii=False).encode()
self.send_response(code)
for k, v in [("Content-Type", "application/json; charset=utf-8"),
("Content-Length", str(len(b))),
("Access-Control-Allow-Origin", "*"),
("Access-Control-Allow-Headers", "Content-Type"),
("Access-Control-Allow-Methods", "GET,POST,OPTIONS")]:
self.send_header(k, v)
self.end_headers()
self.wfile.write(b)
def do_OPTIONS(self):
self._send({})
def do_GET(self):
try:
if self.path.startswith("/api/jira/list"):
try:
self._send({"ok": True, "issues": jira_list()})
except Exception as e:
self._send({"ok": False, "error": str(e)[:200], "jira": False})
elif self.path.startswith("/api/sheet/today"):
try:
import urllib.parse as _up
qs = _up.parse_qs(_up.urlparse(self.path).query)
dt = qs.get("date", [None])[0]
self._send(sheet_tasks_today(dt))
except Exception as e:
self._send({"ok": False, "error": str(e)[:300]}, 500)
elif self.path.startswith("/api/jira/health"):
try:
self._send({"ok": True, "jira": bool(JIRA_PAT),
"reachable": jira_ping()})
except Exception as e:
self._send({"ok": True, "jira": bool(JIRA_PAT),
"reachable": False, "error": str(e)[:150]})
elif self.path.startswith("/api/team/hours"):
days = 120
try:
qp = urllib.parse.parse_qs(self.path.split("?", 1)[1])
days = max(1, min(int(qp.get("days", ["120"])[0]), 365))
except Exception:
pass
self._send(TH.sheet_team_cached(composio_execute, days, sheet_id=SHEET_ID))
elif self.path.startswith("/api/tasks/list"):
st = load_store()
dateq = None
try:
qp = urllib.parse.parse_qs(self.path.split("?", 1)[1])
dateq = qp.get("date", [None])[0]
except Exception:
pass
if dateq:
st = [t for t in st if t.get("date") == dateq]
self._send({"ok": True, "count": len(st), "tasks": st,
"at": datetime.now(TEHRAN).isoformat()})
elif self.path.startswith("/api/sheet/info"):
self._send({"ok": True, "lastDataRow": sheet_last_data_row(),
"tail": sheet_rows()[-4:]})
elif self.path.startswith("/health"):
self._send({"ok": True, "service": "parastoo-sync",
"jira": bool(JIRA_PAT), "composio": os.path.exists(COMPOSIO_BIN),
"time": datetime.now(TEHRAN).isoformat()})
else:
self._send({"ok": False, "error": "not found"}, 404)
except Exception as e:
self._send({"ok": False, "error": str(e)[:300]}, 500)
def do_POST(self):
try:
ln = int(self.headers.get("Content-Length", 0))
body = json.loads(self.rfile.read(ln).decode() or "{}")
except Exception:
body = {}
if self.path.startswith("/api/jira/push"):
created, closed, failed = [], [], []
for t in body.get("tasks", [])[:40]:
try:
if t.get("jira"):
st = jira_close(t["jira"]) if t.get("status") == "done" else None
jira_comment(t["jira"], f"به‌روزرسانی از داشبورد پرستو — {t.get('status')} "
f"({t.get('act') or 0} ساعت)")
closed.append({"key": t["jira"], "status": st, "existing": True})
continue
desc = (f"دسته: {CAT_FA.get(t.get('cat'), t.get('cat'))}\n"
f"تاریخ: {t.get('date')}\n"
f"برآورد: {t.get('est') or 0} ساعت\nواقعی: {t.get('act') or 0} ساعت\n"
f"نوع: {'لحظه‌ای' if t.get('adhoc') else 'برنامه‌ریزی‌شده'}\n"
f"یادداشت: {t.get('note') or '—'}")
created.append({"key": jira_create(t.get("title", "Untitled"), desc, t.get("act")),
"clientId": t.get("id")})
except Exception as e:
failed.append({"title": t.get("title"), "error": str(e)[:180]})
self._send({"ok": True, "created": created, "closed": closed, "failed": failed,
"at": datetime.now(TEHRAN).isoformat()})
elif self.path.startswith("/api/sheet/push"):
rows = []
skipped = 0
for t in body.get("tasks", [])[:100]:
# Guard: never write demo/sample rows or title-less rows into the real sheet
if t.get("demo") or not str(t.get("title") or "").strip():
skipped += 1
continue
est = t.get("est") or 0
act = t.get("act") or 0
try:
estf, actf = float(est or 0), float(act or 0)
except Exception:
estf, actf = 0.0, 0.0
if estf > actf:
e_status = "UnderEstimate"
elif estf < actf:
e_status = "OverEstimate"
else:
e_status = "-"
# columns: J(marker) A(day) B(Task) C(Owner) D(Start Date) E(Est h)
# F(Actual) G(Final Status) H(Estimation Status) I(Week) J(Note)
rows.append([
"", "", t.get("title", ""), "پرستو", sheet_date(t.get("date")),
str(est or ""), str(act or ""),
{"done": "Done", "prog": "NotDone"}.get(t.get("status"), "NotDone"),
e_status, sheet_week(t.get("date")),
(t.get("note") or "") + (f" [{t.get('jira')}]" if t.get("jira") else "")
+ (" [لحظه‌ای]" if t.get("adhoc") else "")
])
try:
last = sheet_last_data_row()
r = sheet_append(rows)
self._send({"ok": True, "appended": len(rows), "skipped": skipped, "afterRow": last,
"updatedRange": (r or {}).get("updates", {}).get("updatedRange") if isinstance(r, dict) else None,
"at": datetime.now(TEHRAN).isoformat()})
except Exception as e:
self._send({"ok": False, "error": str(e)[:300]}, 500)
elif self.path.startswith("/api/sheet/append-row"):
try:
self._send({"ok": True, "result": sheet_append([body.get("row", [])])})
except Exception as e:
self._send({"ok": False, "error": str(e)[:300]}, 500)
elif self.path.startswith("/api/tasks/add"):
# Server-side task store: lets the assistant (from chat/cron) push tasks that the
# dashboard then merges into its localStorage. Writes to the sheet too.
try:
incoming = body.get("tasks") or ([body] if body.get("title") else [])
store = load_store()
added, wrote_sheet = [], []
for t in incoming[:60]:
title = str(t.get("title") or "").strip()
if not title:
continue
rec = {
"id": t.get("id") or ("s" + uuid.uuid4().hex[:10]),
"title": title,
"cat": t.get("cat") or "other",
"date": t.get("date") or datetime.now(TEHRAN).strftime("%Y-%m-%d"),
"est": float(t.get("est") or 0),
"act": float(t.get("act") or 0),
"status": t.get("status") or "todo",
"prio": t.get("prio") or "medium",
"adhoc": bool(t.get("adhoc")),
"note": t.get("note") or "",
"source": t.get("source") or "assistant",
"created": datetime.now(TEHRAN).isoformat(),
"synced_jira": False, "synced_sheet": False,
}
store.append(rec)
added.append(rec)
if not t.get("skip_sheet"):
wrote_sheet.append(rec)
if wrote_sheet:
rows = build_sheet_rows(wrote_sheet)
try:
sheet_append(rows)
for r in wrote_sheet:
r["synced_sheet"] = True
except Exception as she:
print("sheet write failed:", str(she)[:150], flush=True)
save_store(store)
self._send({"ok": True, "added": len(added),
"sheetWritten": len(wrote_sheet),
"tasks": added, "at": datetime.now(TEHRAN).isoformat()})
except Exception as e:
self._send({"ok": False, "error": str(e)[:300]}, 500)
elif self.path.startswith("/api/tasks/ack"):
# Dashboard calls this once it has merged server tasks into localStorage.
try:
ids = set(body.get("ids") or [])
store = [t for t in load_store() if t.get("id") not in ids]
save_store(store)
self._send({"ok": True, "remaining": len(store)})
except Exception as e:
self._send({"ok": False, "error": str(e)[:300]}, 500)
else:
self._send({"ok": False, "error": "not found"}, 404)
def log_message(self, *a):
pass
def _prewarm():
"""Warm the team-hours cache in the background so the first user request is instant."""
import time as _t
_t.sleep(3)
try:
TH.sheet_team_cached(composio_execute, 120, sheet_id=SHEET_ID)
print("team-hours cache prewarmed", flush=True)
except Exception as exc:
print("prewarm failed:", str(exc)[:120], flush=True)
if __name__ == "__main__":
port = int(os.environ.get("PORT", "8095"))
print(f"parastoo-sync on :{port} | jira={'yes' if JIRA_PAT else 'NO'} "
f"composio={'yes' if os.path.exists(COMPOSIO_BIN) else 'NO'}", flush=True)
import threading as _th
_th.Thread(target=_prewarm, daemon=True).start()
ThreadingHTTPServer(("0.0.0.0", port), H).serve_forever()