195 lines
11 KiB
Python
195 lines
11 KiB
Python
"""PC-side user OAuth and calendar operations. Tokens are DPAPI-protected only here."""
|
|
import hashlib
|
|
import json
|
|
import secrets
|
|
import ssl
|
|
import time
|
|
from datetime import datetime, timedelta, timezone
|
|
from pathlib import Path
|
|
from urllib.parse import quote, urlsplit
|
|
|
|
import httpx
|
|
from .crypto import canonical, load_private, sign
|
|
from .windows_keys import protect, unprotect
|
|
from .process_lock import DeviceProcessLock
|
|
|
|
|
|
class WorkError(RuntimeError):
|
|
pass
|
|
|
|
|
|
class AuthorizationRequired(WorkError):
|
|
def __init__(self, url):
|
|
self.url = url
|
|
super().__init__("需要本人Work授权,请打开授权链接,完成后重新发起原任务;尚未执行平台写操作。")
|
|
|
|
|
|
def atomic_secret(path, data):
|
|
temp = path.with_suffix(".tmp")
|
|
temp.write_bytes(protect(json.dumps(data, ensure_ascii=False).encode()))
|
|
temp.replace(path)
|
|
|
|
|
|
class WorkClient:
|
|
def __init__(self, directory, url="https://10.77.76.13", *, transport=None):
|
|
self.directory = Path(directory)
|
|
self.config = json.loads((self.directory / "device.json").read_text(encoding="utf-8-sig"))
|
|
if not self.config.get("owner"):
|
|
raise WorkError("请先绑定本人Work身份。")
|
|
context = ssl.create_default_context(cafile=str(self.directory / "server.pem"))
|
|
self.http = httpx.Client(base_url=url.rstrip("/"), verify=context, trust_env=False,
|
|
timeout=25, follow_redirects=False, transport=transport)
|
|
self.owner = self.config["owner"]
|
|
self.path = self.directory / "work-user-tokens.dpapi"
|
|
self.pending = self.directory / "work-oauth-pending.dpapi"
|
|
|
|
def close(self):
|
|
self.http.close()
|
|
|
|
def read(self, path):
|
|
return json.loads(unprotect(path.read_bytes()))
|
|
|
|
def proof(self, purpose, payload):
|
|
return sign({"host_id": self.config["host_id"], "purpose": purpose, "ts": int(time.time()),
|
|
"nonce": secrets.token_hex(16), "payload_hash": hashlib.sha256(canonical(payload)).hexdigest()},
|
|
load_private(self.directory / "device.key"))
|
|
|
|
def authorize(self):
|
|
if self.pending.exists():
|
|
data = self.read(self.pending)
|
|
if data.get("owner") == self.owner and data["deadline"] > time.time():
|
|
from .notification_client import notify_authorization
|
|
notify_authorization(self, data)
|
|
return data["authorization_url"]
|
|
response = self.http.post("/oauth/start", json={"host_id": self.config["host_id"],
|
|
"proof": self.proof("work-oauth-v1", {})})
|
|
if response.status_code != 201:
|
|
raise WorkError("授权事务创建失败(HTTP " + str(response.status_code) + "),请检查ECS平台配置。")
|
|
data = response.json()
|
|
if urlsplit(data["authorization_url"]).scheme != "https":
|
|
raise WorkError("授权地址必须使用HTTPS。")
|
|
data.update(owner=self.owner, deadline=time.time() + data["expires_in"])
|
|
atomic_secret(self.pending, data)
|
|
from .notification_client import notify_authorization
|
|
notify_authorization(self, data)
|
|
return data["authorization_url"]
|
|
|
|
def save_tokens(self, data):
|
|
if data.get("open_id") != self.owner or not data.get("user_access_token"):
|
|
raise WorkError("授权账号与本机Work绑定账号不一致,请使用本人账号重新授权。")
|
|
now = time.time()
|
|
data = {**data, "expires_at": now + int(data["expires_in"]),
|
|
"refresh_expires_at": now + int(data.get("refresh_expires_in", 0)), "needs_authorization": False}
|
|
atomic_secret(self.path, data)
|
|
return data
|
|
|
|
def access_token(self):
|
|
# Shared across GUI and Agent calls; never rotate the same token concurrently.
|
|
with DeviceProcessLock(self.directory / "work-token-lock"):
|
|
if self.path.exists():
|
|
data = self.read(self.path)
|
|
if data.get("open_id") == self.owner and not data.get("needs_authorization"):
|
|
if data["expires_at"] > time.time() + 120:
|
|
return data["user_access_token"]
|
|
if data.get("refresh_token") and data.get("refresh_expires_at", 0) > time.time():
|
|
# Mark before network; ambiguous failure must not reuse a rotating refresh token.
|
|
atomic_secret(self.path, {**data, "needs_authorization": True})
|
|
try:
|
|
response = self.http.post("/oauth/refresh", json={"refresh_token": data["refresh_token"]})
|
|
if response.status_code != 200:
|
|
raise WorkError("刷新失败")
|
|
data = self.save_tokens(response.json())
|
|
return data["user_access_token"]
|
|
except (httpx.HTTPError, ValueError, WorkError):
|
|
raise AuthorizationRequired(self.authorize()) from None
|
|
if self.pending.exists():
|
|
pending = self.read(self.pending)
|
|
if pending.get("owner") == self.owner and pending["deadline"] > time.time():
|
|
response = self.http.get("/oauth/claim", params={"state": pending["state"]},
|
|
headers={"X-OAuth-Claim-Secret": pending["claim_secret"]})
|
|
if response.status_code == 200:
|
|
data = self.save_tokens(response.json())
|
|
self.pending.unlink(missing_ok=True)
|
|
return data["user_access_token"]
|
|
if response.status_code not in {202}:
|
|
self.pending.unlink(missing_ok=True)
|
|
raise AuthorizationRequired(self.authorize())
|
|
|
|
def status(self):
|
|
try:
|
|
token = self.access_token()
|
|
return {"authorized": True, "owner": self.owner, "message": "本人用户授权可用;令牌未输出。",
|
|
"local_time": datetime.now(timezone(timedelta(hours=8))).isoformat()}
|
|
except AuthorizationRequired as error:
|
|
return {"authorized": False, "authorization_url": error.url, "message": str(error)}
|
|
|
|
def api(self, method, path, params=None, body=None, operation_id=""):
|
|
token = self.access_token()
|
|
payload = {"method": method, "path": path, "params": params or {}, "body": body or {},
|
|
"operation_id": operation_id, "token_hash": hashlib.sha256(token.encode()).hexdigest()}
|
|
proof = self.proof("work-api-v1", payload)
|
|
wire = {k: v for k, v in payload.items() if k != "token_hash"}
|
|
response = self.http.post("/work/api", headers={"Authorization": "Bearer " + token},
|
|
json={**wire, "host_id": self.config["host_id"], "proof": proof})
|
|
if response.status_code == 401:
|
|
# Do not repeat a business write automatically, even when auth fails.
|
|
if self.path.exists():
|
|
data = self.read(self.path)
|
|
data["expires_at"] = 0
|
|
atomic_secret(self.path, data)
|
|
raise WorkError("用户令牌已失效。本次未重试,请检查授权后再核对操作状态。")
|
|
if response.status_code != 200:
|
|
raise WorkError("平台代理失败(HTTP " + str(response.status_code) + ");未重试。")
|
|
return response.json()
|
|
|
|
def primary_calendar(self):
|
|
result = self.api("POST", "/open-apis/calendar/v4/calendars/primary", {"user_id_type": "open_id"})
|
|
if result.get("status") != "completed":
|
|
return result
|
|
calendars = result.get("data", {}).get("calendars", [])
|
|
own = [c["calendar"] for c in calendars if c.get("user_id") == self.owner and c.get("calendar")]
|
|
if not own and len(calendars) == 1 and not calendars[0].get("user_id") and calendars[0].get("calendar"):
|
|
own = [calendars[0]["calendar"]]
|
|
if len(own) != 1:
|
|
raise WorkError("没有唯一确定的本人主日历,请先查询日历列表并明确选择。")
|
|
return {"status": "completed", "calendar": own[0]}
|
|
|
|
def create_event(self, summary, start_iso, end_iso, attendee_open_ids, operation_id, description="", calendar_id=""):
|
|
import re
|
|
if not re.fullmatch(r"[A-Za-z0-9_-]{8,80}", operation_id):
|
|
raise WorkError("创建日程需8到80位稳定operation_id,重试不得换ID。")
|
|
if not summary.strip() or len(summary) > 1000:
|
|
raise WorkError("日程主题不能为空或超过1000字符。")
|
|
start, end = datetime.fromisoformat(start_iso), datetime.fromisoformat(end_iso)
|
|
if start.tzinfo is None or end.tzinfo is None or end <= start:
|
|
raise WorkError("起止时间必须包含时区且结束晚于开始;不要猜测时区或时长。")
|
|
if any(not isinstance(x, str) or not x.startswith("ou_") for x in attendee_open_ids):
|
|
raise WorkError("参会人必须为当前应用身份域的open_id,请先搜索并确认,不能把姓名/工号直接当ID。")
|
|
if not calendar_id:
|
|
primary = self.primary_calendar()
|
|
if primary.get("status") != "completed":
|
|
return primary
|
|
calendar_id = primary["calendar"]["calendar_id"]
|
|
path = "/open-apis/calendar/v4/calendars/" + quote(calendar_id, safe="") + "/events"
|
|
body = {"summary": summary, "description": description, "need_notification": True,
|
|
"start_time": {"timestamp": str(int(start.timestamp())), "timezone": "Asia/Shanghai"},
|
|
"end_time": {"timestamp": str(int(end.timestamp())), "timezone": "Asia/Shanghai"}}
|
|
result = self.api("POST", path, {"user_id_type": "open_id"}, body, operation_id)
|
|
event = result.get("data", {}).get("event", {})
|
|
if result.get("status") == "duplicate" and result.get("previous_status") == "completed":
|
|
event = {"event_id": result.get("event_id"), "app_link": result.get("app_link")}
|
|
elif result.get("status") != "completed":
|
|
return result
|
|
if not event.get("event_id"):
|
|
raise WorkError("平台未返回event_id,不能认定创建成功或继续邀请。")
|
|
ids = sorted(set([self.owner] + list(attendee_open_ids)))
|
|
invite = self.api("POST", path + "/" + quote(event["event_id"], safe="") + "/attendees",
|
|
{"user_id_type": "open_id"},
|
|
{"attendees": [{"type": "user", "user_id": x} for x in ids], "need_notification": True},
|
|
operation_id + "_attendees")
|
|
invited = invite.get("status") == "completed" or (invite.get("status") == "duplicate" and invite.get("previous_status") == "completed")
|
|
return {"status": "completed" if invited else "partial", "event_created": True,
|
|
"calendar_id": calendar_id, "event_id": event["event_id"], "app_link": event.get("app_link"),
|
|
"attendees_invited": invited, "invite_result": invite,
|
|
"message": "日程已创建并提交参会人邀请;不代表对方已接受。" if invited else "日程已创建,但邀请未完成;保留原操作ID和event_id处理,勿重新创建日程。"}
|