sp2react 0.1.0__py3-none-any.whl

sp2react/scaffold/templates/backend/app/rules.py

@@ -0,0 +1,256 @@
+"""Spec rule engine (server side). Mirrors frontend/src/runtime/rules.ts; both are tested
+against the same vectors so the browser and the API always agree.
+"""
+from __future__ import annotations
+
+import re
+from datetime import date, datetime, timedelta
+from typing import Any, Optional
+
+REQUIRED_MESSAGE = "You can't leave this blank."
+
+
+def is_empty(v: Any) -> bool:
+    return v is None or v == "" or v == [] or (isinstance(v, dict) and v.get("id") in (None, 0, ""))
+
+
+def _scalar(v: Any, against: Any = None) -> Any:
+    """Lookup/user objects compare by title when the other side is text, by id when it is a number."""
+    if isinstance(v, dict):
+        if isinstance(against, (int, float)) and not isinstance(against, bool):
+            return v.get("id")
+        return v.get("title") if "title" in v else v.get("id")
+    return v
+
+
+def _num_or_date(v: Any) -> Any:
+    if isinstance(v, bool):
+        return v
+    if isinstance(v, (int, float)):
+        return v
+    if isinstance(v, str):
+        try:
+            return float(v.replace(",", "").replace("$", "")) if re.fullmatch(r"\s*[$]?-?[\d,]+(\.\d+)?\s*", v) else v
+        except ValueError:
+            return v
+    return v
+
+
+def _cmp(a: Any, op: str, b: Any) -> bool:
+    a, b = _num_or_date(_scalar(a, b)), _num_or_date(b)
+    if op == "eq":
+        return a == b
+    if op == "ne":
+        return a != b
+    if a is None or b is None or a == "":
+        return False
+    try:
+        if op == "gt":
+            return a > b
+        if op == "gte":
+            return a >= b
+        if op == "lt":
+            return a < b
+        if op == "lte":
+            return a <= b
+    except TypeError:
+        return False
+    raise ValueError(f"unknown operator {op}")
+
+
+def get_value(values: dict, path: str) -> Any:
+    head, _, rest = path.partition(".")
+    v = values.get(head)
+    if rest and isinstance(v, dict):
+        return v.get(rest) if rest in v else v.get(rest.lower())
+    return v
+
+
+def evaluate(cond: Optional[dict], ctx: dict) -> bool:
+    """ctx: {mode, values, original, user: {groups: [...]}}"""
+    if not cond:
+        return True
+    if "all" in cond:
+        return all(evaluate(c, ctx) for c in cond["all"])
+    if "any" in cond:
+        return any(evaluate(c, ctx) for c in cond["any"])
+    if "not" in cond:
+        return not evaluate(cond["not"], ctx)
+    if "role" in cond:
+        return cond["role"] in (ctx.get("user") or {}).get("groups", [])
+    if "mode" in cond:
+        modes = cond["mode"] if isinstance(cond["mode"], list) else [cond["mode"]]
+        return ctx.get("mode") in modes
+    if "field" in cond:
+        v = get_value(ctx.get("values") or {}, cond["field"])
+        result = True
+        for op, arg in cond.items():
+            if op == "field":
+                continue
+            if op == "empty":
+                ok = is_empty(v) == bool(arg)
+            elif op == "notEmpty":
+                ok = (not is_empty(v)) == bool(arg)
+            elif op == "changed":
+                before = get_value(ctx.get("original") or {}, cond["field"])
+                ok = (_scalar(v) != _scalar(before)) == bool(arg)
+            elif op == "in":
+                ok = _scalar(v, (arg or [None])[0]) in arg
+            elif op == "nin":
+                ok = _scalar(v, (arg or [None])[0]) not in arg
+            else:
+                ok = _cmp(v, op, arg)
+            result = result and ok
+        return result
+    raise ValueError(f"unknown condition {cond}")
+
+
+def applies(rule: dict, mode: str) -> bool:
+    return not rule.get("modes") or mode in rule["modes"]
+
+
+def rules_for(rules: list[dict], kind: str, field: Optional[str], mode: str) -> list[dict]:
+    return [r for r in rules if r["kind"] == kind and (field is None or r.get("field") == field) and applies(r, mode)]
+
+
+def field_state(field: dict, rules: list[dict], ctx: dict) -> dict:
+    name, mode = field["name"], ctx["mode"]
+    # visible rules: those for this mode must all hold; a field whose visible rules are all scoped to
+    # other modes is hidden in this one (e.g. Status shown only on edit/display)
+    all_vis = [r for r in rules if r["kind"] == "visible" and r.get("field") == name]
+    vis_rules = [r for r in all_vis if applies(r, mode)]
+    visible = all(evaluate(r.get("when"), ctx) for r in vis_rules) if vis_rules else not all_vis or not all(r.get("modes") for r in all_vis)
+    if field.get("type") == "calculated" and mode != "display":
+        visible = False
+    readonly = mode == "display" or bool(field.get("read_only")) or any(evaluate(r.get("when"), ctx) for r in rules_for(rules, "readonly", name, mode))
+    required = bool(field.get("required")) and mode != "display" and not readonly
+    req_rule = next((r for r in rules_for(rules, "required", name, mode) if evaluate(r.get("when"), ctx)), None)
+    return {"visible": visible, "readonly": readonly, "required": required or (req_rule is not None and visible),
+            "required_rule": req_rule}
+
+
+def resolve_token(token: Any, user: dict, today: Optional[date] = None) -> Any:
+    if token == "@me":
+        return {"id": user.get("id"), "login": user.get("login"), "title": user.get("title")}
+    if token == "@today":
+        return (today or date.today()).isoformat()
+    return token
+
+
+def defaults(fields: list[dict], rules: list[dict], user: dict, today: Optional[date] = None) -> dict:
+    out = {}
+    for f in fields:
+        if "default" in f:
+            out[f["name"]] = resolve_token(f["default"], user, today)
+    for r in rules_for(rules, "default", None, "new"):
+        out[r["field"]] = resolve_token(r["params"]["value"], user, today)
+    return out
+
+
+def fill_template(text: str, values: dict) -> str:
+    """'{Field}', '{Lookup.title}', '{Field|lower}', '{Field|upper}' -> values."""
+    def rep(m):
+        v = _scalar(get_value(values, m.group(1)))
+        if v is None:
+            return ""
+        if isinstance(v, float) and v.is_integer():
+            v = int(v)
+        out = str(v).lower() if isinstance(v, bool) else str(v)
+        return out.lower() if m.group(2) == "lower" else out.upper() if m.group(2) == "upper" else out
+    return re.sub(r"\{([\w.]+)(?:\|(lower|upper))?\}", rep, text or "")
+
+
+def validate(fields: list[dict], rules: list[dict], ctx: dict) -> list[dict]:
+    """-> [{field, message, presentation, rule}] in display order, schema checks first per field."""
+    errors: list[dict] = []
+    values, mode = ctx.get("values") or {}, ctx["mode"]
+    by_name = {f["name"]: f for f in fields}
+    states = {f["name"]: field_state(f, rules, ctx) for f in fields}
+
+    for f in fields:
+        st, v = states[f["name"]], values.get(f["name"])
+        if not st["visible"] or st["readonly"]:
+            continue
+        if f.get("required") and is_empty(v):
+            errors.append({"field": f["name"], "message": REQUIRED_MESSAGE, "presentation": "inline", "rule": "schema"})
+            continue
+        if is_empty(v):
+            continue
+        if f.get("max_length") and isinstance(v, str) and len(v) > f["max_length"]:
+            errors.append({"field": f["name"], "message": f"The value of this field may not contain more than {f['max_length']} characters.",
+                           "presentation": "inline", "rule": "schema"})
+        if f.get("type") in ("number", "currency"):
+            n = _num_or_date(v)
+            if not isinstance(n, (int, float)):
+                errors.append({"field": f["name"], "message": "The value of this field must be a number.", "presentation": "inline", "rule": "schema"})
+            else:
+                if "min" in f and n < f["min"]:
+                    errors.append({"field": f["name"], "message": f"The value of this field must be greater than or equal to {f['min']:g}.", "presentation": "inline", "rule": "schema"})
+                if "max" in f and n > f["max"]:
+                    errors.append({"field": f["name"], "message": f"The value of this field must be less than or equal to {f['max']:g}.", "presentation": "inline", "rule": "schema"})
+        if f.get("type") == "choice" and f.get("choices") and not f.get("fill_in") and v not in f["choices"]:
+            errors.append({"field": f["name"], "message": "Select a valid value.", "presentation": "inline", "rule": "schema"})
+
+    for r in rules:
+        if not applies(r, mode) or mode == "display":
+            continue
+        fname = r.get("field")
+        st = states.get(fname) if fname else None
+        if st and (not st["visible"] or st["readonly"]) and r["kind"] not in ("lock_item",):
+            continue
+        if r.get("when") and not evaluate(r["when"], ctx):
+            continue
+        k, v, p = r["kind"], values.get(fname) if fname else None, r.get("params") or {}
+        failed = False
+        if k == "required":
+            failed = is_empty(v)
+        elif k == "compare":
+            other = values.get(p["other"])
+            if is_empty(v) or is_empty(other):
+                failed = False
+            else:
+                failed = not _cmp(v, p["op"], _scalar(other))
+        elif k == "length":
+            failed = not (p.get("allow_empty") and is_empty(v)) and not _cmp(len(str(v or "")), p["op"], p["value"])
+        elif k == "range":
+            failed = not is_empty(v) and not _cmp(v, p["op"], p["value"])
+        elif k == "pattern":
+            failed = not is_empty(v) and not re.fullmatch(p["regex"], str(v))
+        if failed:
+            errors.append({"field": fname, "message": fill_template(r.get("message") or REQUIRED_MESSAGE, values),
+                           "presentation": r.get("presentation", "inline"), "rule": r["id"]})
+    # one error per field (the first), like SharePoint shows one message under a control
+    seen, out = set(), []
+    for e in errors:
+        key = (e["field"], e["presentation"]) if e["field"] else (e["rule"],)
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(e)
+    return out
+
+
+def lock(rules: list[dict], ctx: dict) -> Optional[dict]:
+    for r in rules_for(rules, "lock_item", None, ctx["mode"]):
+        if evaluate(r.get("when"), ctx):
+            return r
+    return None
+
+
+def set_on_save(rules: list[dict], ctx: dict) -> dict:
+    return {r["field"]: resolve_token(r["params"]["value"], ctx.get("user") or {}) for r in rules_for(rules, "set_on_save", None, ctx["mode"])
+            if evaluate(r.get("when"), ctx)}
+
+
+def banners(rules: list[dict], ctx: dict) -> list[dict]:
+    return [r for r in rules_for(rules, "banner", None, ctx["mode"]) if evaluate(r.get("when"), ctx)]
+
+
+def clear_hidden(fields: list[dict], rules: list[dict], ctx: dict) -> dict:
+    """Fields hidden by a visible rule with params.clear lose their value (legacy: hide row + .val(""))."""
+    out = {}
+    for f in fields:
+        clears = [r for r in rules if r["kind"] == "visible" and r.get("field") == f["name"] and (r.get("params") or {}).get("clear")]
+        if clears and ctx["mode"] != "display" and not field_state(f, rules, ctx)["visible"] and not is_empty((ctx.get("values") or {}).get(f["name"])):
+            out[f["name"]] = None
+    return out

sp2react/scaffold/templates/backend/app/sp_repo.py

@@ -0,0 +1,159 @@
+"""Optional data source: keep the data in SharePoint and use this API as a backend-for-frontend.
+
+Select with DATA_SOURCE=sharepoint. Same interface as SqliteRepo, so the rules engine and routes
+do not change. Auth for the service account: SP_AUTH=ntlm|cookie|bearer with SP_USERNAME/SP_PASSWORD,
+SP_COOKIE or SP_TOKEN. Writes use the request digest from /_api/contextinfo.
+"""
+from __future__ import annotations
+
+import base64
+import os
+from typing import Any, Optional
+
+import requests
+
+from .store import Conflict, Specs
+
+
+class SharePointRepo:
+    def __init__(self, specs: Specs):
+        self.specs = specs
+        self.site = os.environ["SP_SITE_URL"].rstrip("/")
+        self.s = requests.Session()
+        self.s.headers.update({"Accept": "application/json;odata=verbose"})
+        self.s.verify = os.environ.get("SP_VERIFY_SSL", "true").lower() not in ("0", "false", "no")
+        mode = os.environ.get("SP_AUTH", "ntlm")
+        if mode == "ntlm":
+            from requests_ntlm import HttpNtlmAuth  # type: ignore
+            self.s.auth = HttpNtlmAuth(os.environ["SP_USERNAME"], os.environ["SP_PASSWORD"])
+        elif mode == "cookie":
+            self.s.headers["Cookie"] = os.environ["SP_COOKIE"]
+        elif mode == "bearer":
+            self.s.headers["Authorization"] = "Bearer " + os.environ["SP_TOKEN"]
+        self.users: list[dict] = []
+
+    # -------------------------------------------------------------- helpers
+    def _title(self, list_name: str) -> str:
+        return self.specs.lists[list_name]["title"].replace("'", "''")
+
+    def _url(self, list_name: str, suffix: str = "") -> str:
+        return f"{self.site}/_api/web/lists/getbytitle('{self._title(list_name)}')/items{suffix}"
+
+    def _digest(self) -> str:
+        r = self.s.post(f"{self.site}/_api/contextinfo")
+        r.raise_for_status()
+        return r.json()["d"]["GetContextWebInformation"]["FormDigestValue"]
+
+    def _fields(self, list_name: str) -> dict[str, dict]:
+        return {f["name"]: f for f in self.specs.lists[list_name]["fields"]}
+
+    def _query(self, list_name: str) -> dict:
+        sel, exp = ["*", "Author/Id", "Author/Title", "Author/Name", "Editor/Id", "Editor/Title", "Editor/Name", "AttachmentFiles"], ["Author", "Editor", "AttachmentFiles"]
+        for f in self._fields(list_name).values():
+            if f["type"] == "lookup":
+                sel += [f"{f['name']}/Id", f"{f['name']}/{f['lookup'].get('field', 'Title')}"]
+                exp.append(f["name"])
+            if f["type"] == "user":
+                sel += [f"{f['name']}/Id", f"{f['name']}/Title", f"{f['name']}/Name"]
+                exp.append(f["name"])
+        return {"$select": ",".join(sel), "$expand": ",".join(exp)}
+
+    @staticmethod
+    def _user(u: Any) -> Optional[dict]:
+        if not u or not isinstance(u, dict) or "Id" not in u:
+            return None
+        return {"id": u["Id"], "login": (u.get("Name") or "").split("|")[-1], "title": u.get("Title")}
+
+    def _to_item(self, list_name: str, d: dict) -> dict:
+        item: dict = {"ID": d["Id"]}
+        for name, f in self._fields(list_name).items():
+            v = d.get(name)
+            if f["type"] == "lookup":
+                col = f["lookup"].get("field", "Title")
+                conv = lambda x: {"id": x["Id"], "title": x.get(col)} if x and x.get("Id") else None
+                item[name] = [conv(x) for x in v.get("results", [])] if isinstance(v, dict) and "results" in v else conv(v)
+            elif f["type"] == "user":
+                item[name] = [self._user(x) for x in v.get("results", [])] if isinstance(v, dict) and "results" in v else self._user(v)
+            elif f["type"] == "date" and v:
+                item[name] = v[:10]
+            else:
+                item[name] = v
+        etag = d.get("__metadata", {}).get("etag", '"1"')
+        item.update({"Created": d.get("Created"), "Modified": d.get("Modified"), "Author": self._user(d.get("Author")),
+                     "Editor": self._user(d.get("Editor")), "_etag": etag, "_version": etag.strip('"') + ".0",
+                     "Attachments": [a["FileName"] for a in (d.get("AttachmentFiles") or {}).get("results", [])]})
+        return item
+
+    def _payload(self, list_name: str, values: dict) -> dict:
+        out: dict = {}
+        for name, v in values.items():
+            f = self._fields(list_name).get(name)
+            if not f:
+                continue
+            if f["type"] in ("lookup", "user"):
+                if isinstance(v, list):
+                    out[f"{name}Id"] = {"results": [x.get("id") if isinstance(x, dict) else x for x in v]}
+                else:
+                    out[f"{name}Id"] = v.get("id") if isinstance(v, dict) else v
+            else:
+                out[name] = v
+        return out
+
+    # ----------------------------------------------------------------- API
+    def user(self, uid):
+        return None
+
+    def user_by_login(self, login: str):
+        r = self.s.get(f"{self.site}/_api/web/siteusers", params={"$filter": f"substringof('{login}',LoginName)"})
+        r.raise_for_status()
+        res = r.json()["d"]["results"]
+        if not res:
+            return None
+        u = res[0]
+        g = self.s.get(f"{self.site}/_api/web/getuserbyid({u['Id']})/groups").json()["d"]["results"]
+        return {"id": u["Id"], "login": login, "title": u["Title"], "email": u.get("Email"), "groups": [x["Title"] for x in g]}
+
+    def all(self, list_name: str) -> list[dict]:
+        r = self.s.get(self._url(list_name), params={**self._query(list_name), "$top": "5000"})
+        r.raise_for_status()
+        return [self._to_item(list_name, d) for d in r.json()["d"]["results"]]
+
+    def get(self, list_name: str, iid: int) -> Optional[dict]:
+        r = self.s.get(self._url(list_name, f"({iid})"), params=self._query(list_name))
+        if r.status_code == 404:
+            return None
+        r.raise_for_status()
+        return self._to_item(list_name, r.json()["d"])
+
+    def create(self, list_name: str, values: dict, user: dict) -> dict:
+        body = {"__metadata": {"type": f"SP.Data.{self.specs.lists[list_name].get('entity', list_name + 'List')}Item"}, **self._payload(list_name, values)}
+        r = self.s.post(self._url(list_name), json=body, headers={"X-RequestDigest": self._digest(), "Content-Type": "application/json;odata=verbose"})
+        r.raise_for_status()
+        return self.get(list_name, r.json()["d"]["Id"])
+
+    def update(self, list_name: str, iid: int, values: dict, user: dict, etag: Optional[str] = None) -> dict:
+        body = {"__metadata": {"type": f"SP.Data.{self.specs.lists[list_name].get('entity', list_name + 'List')}Item"}, **self._payload(list_name, values)}
+        r = self.s.post(self._url(list_name, f"({iid})"), json=body, headers={
+            "X-RequestDigest": self._digest(), "Content-Type": "application/json;odata=verbose",
+            "X-HTTP-Method": "MERGE", "IF-MATCH": etag or "*"})
+        if r.status_code == 412:
+            raise Conflict()
+        r.raise_for_status()
+        return self.get(list_name, iid)
+
+    def delete(self, list_name: str, iid: int) -> None:
+        r = self.s.post(self._url(list_name, f"({iid})"), headers={"X-RequestDigest": self._digest(), "X-HTTP-Method": "DELETE", "IF-MATCH": "*"})
+        r.raise_for_status()
+
+    def add_attachment(self, list_name: str, iid: int, name: str, content_b64: str) -> None:
+        r = self.s.post(self._url(list_name, f"({iid})/AttachmentFiles/add(FileName='{name}')"), data=base64.b64decode(content_b64),
+                        headers={"X-RequestDigest": self._digest()})
+        r.raise_for_status()
+
+    def attachment(self, list_name: str, iid: int, name: str) -> Optional[bytes]:
+        r = self.s.get(self._url(list_name, f"({iid})/AttachmentFiles('{name}')/$value"))
+        return r.content if r.ok else None
+
+    def delete_attachment(self, list_name: str, iid: int, name: str) -> None:
+        r = self.s.post(self._url(list_name, f"({iid})/AttachmentFiles('{name}')"), headers={"X-RequestDigest": self._digest(), "X-HTTP-Method": "DELETE"})
+        r.raise_for_status()