140 lines
3.9 KiB
Python
140 lines
3.9 KiB
Python
import base64
|
|
import datetime as dt
|
|
import hashlib
|
|
import json
|
|
import re
|
|
import uuid
|
|
|
|
from app.errors import AppError, bad_request
|
|
|
|
USERNAME = re.compile(r"^[a-z0-9_]{3,32}$")
|
|
IDEMPOTENCY = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
|
|
REQUEST_ID = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
|
|
|
|
|
|
def utcnow():
|
|
return dt.datetime.now(dt.timezone.utc)
|
|
|
|
|
|
def iso(value):
|
|
if value.tzinfo is None:
|
|
value = value.replace(tzinfo=dt.timezone.utc)
|
|
value = value.astimezone(dt.timezone.utc)
|
|
return value.strftime("%Y-%m-%dT%H:%M:%S.") + f"{value.microsecond:06d}Z"
|
|
|
|
|
|
def parse_iso(value):
|
|
if not isinstance(value, str) or not value.endswith("Z"):
|
|
raise bad_request()
|
|
try:
|
|
return dt.datetime.fromisoformat(value[:-1] + "+00:00")
|
|
except ValueError as exc:
|
|
raise bad_request() from exc
|
|
|
|
|
|
def parse_uuid(value):
|
|
if not isinstance(value, str):
|
|
raise bad_request()
|
|
try:
|
|
return str(uuid.UUID(value))
|
|
except ValueError as exc:
|
|
raise bad_request() from exc
|
|
|
|
|
|
def require_text(value, minimum, maximum, allow_blank=False):
|
|
if not isinstance(value, str):
|
|
raise bad_request()
|
|
if "\x00" in value or any(ord(ch) < 32 or ord(ch) == 127 for ch in value):
|
|
raise bad_request()
|
|
if not allow_blank and not value.strip():
|
|
raise bad_request()
|
|
if not (minimum <= len(value) <= maximum):
|
|
raise bad_request()
|
|
return value
|
|
|
|
|
|
def canonical_message(text, attachment_ids):
|
|
body = {"attachment_ids": list(attachment_ids), "text": text}
|
|
raw = json.dumps(body, ensure_ascii=False, separators=(",", ":"), sort_keys=True)
|
|
return hashlib.sha256(raw.encode("utf-8")).digest()
|
|
|
|
|
|
def encode_cursor(kind, resource_id, created_at, row_id):
|
|
raw = f"{kind}|{resource_id}|{iso(created_at)}|{row_id}"
|
|
return base64.urlsafe_b64encode(raw.encode("utf-8")).decode("ascii").rstrip("=")
|
|
|
|
|
|
def decode_cursor(token, kind, resource_id):
|
|
if not isinstance(token, str) or not token:
|
|
raise bad_request()
|
|
padded = token + ("=" * (-len(token) % 4))
|
|
try:
|
|
raw = base64.urlsafe_b64decode(padded.encode("ascii")).decode("utf-8")
|
|
cursor_kind, cursor_resource, stamp, row_id = raw.split("|", 3)
|
|
created_at = parse_iso(stamp)
|
|
row_uuid = str(uuid.UUID(row_id))
|
|
except (ValueError, UnicodeError, AppError) as exc:
|
|
raise bad_request() from exc
|
|
if cursor_kind != kind or cursor_resource != resource_id:
|
|
raise bad_request()
|
|
return created_at, row_uuid
|
|
|
|
|
|
def fitted_size(width, height, box=256):
|
|
if width < 1 or height < 1:
|
|
raise ValueError("dimensions")
|
|
if width <= box and height <= box:
|
|
return width, height
|
|
if width >= height:
|
|
return box, max(1, (height * box) // width)
|
|
return max(1, (width * box) // height), box
|
|
|
|
|
|
def detect_image(data, declared):
|
|
if data.startswith(b"\x89PNG\r\n\x1a\n"):
|
|
detected = "image/png"
|
|
elif data.startswith(b"\xff\xd8\xff"):
|
|
detected = "image/jpeg"
|
|
else:
|
|
return None
|
|
if declared != detected:
|
|
return None
|
|
return detected
|
|
|
|
|
|
def media_type(header):
|
|
if not header or not isinstance(header, str):
|
|
return ""
|
|
return header.split(";", 1)[0].strip().lower()
|
|
|
|
|
|
def loads_object(raw):
|
|
try:
|
|
text = raw.decode("utf-8")
|
|
except UnicodeError as exc:
|
|
raise bad_request() from exc
|
|
|
|
def pairs(items):
|
|
obj = {}
|
|
for key, value in items:
|
|
if key in obj:
|
|
raise ValueError("duplicate")
|
|
obj[key] = value
|
|
return obj
|
|
|
|
try:
|
|
value = json.loads(text, object_pairs_hook=pairs)
|
|
except (ValueError, UnicodeError) as exc:
|
|
raise bad_request() from exc
|
|
if not isinstance(value, dict):
|
|
raise bad_request()
|
|
return value
|
|
|
|
|
|
def expect_fields(data, allowed, required):
|
|
if set(data) - set(allowed):
|
|
raise bad_request()
|
|
for key in required:
|
|
if key not in data:
|
|
raise bad_request()
|