velocity-python 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- velocity/__init__.py +1 -1
- velocity/aws/handlers/mixins/workflow_actions.py +383 -1
- velocity/db/_pgddl.py +92 -0
- velocity/db/audit.py +1 -1
- velocity/db/integrity.py +3 -3
- velocity/workflow/__init__.py +12 -1
- velocity/workflow/access.py +229 -4
- velocity/workflow/contract.py +4 -1
- velocity/workflow/engine.py +542 -4
- velocity/workflow/hooks.py +78 -1
- velocity/workflow/schema.py +8 -1
- velocity/workflow/views.py +895 -0
- {velocity_python-0.4.2.dist-info → velocity_python-0.5.1.dist-info}/METADATA +1 -1
- {velocity_python-0.4.2.dist-info → velocity_python-0.5.1.dist-info}/RECORD +18 -17
- {velocity_python-0.4.2.dist-info → velocity_python-0.5.1.dist-info}/WHEEL +0 -0
- {velocity_python-0.4.2.dist-info → velocity_python-0.5.1.dist-info}/entry_points.txt +0 -0
- {velocity_python-0.4.2.dist-info → velocity_python-0.5.1.dist-info}/licenses/LICENSE +0 -0
- {velocity_python-0.4.2.dist-info → velocity_python-0.5.1.dist-info}/top_level.txt +0 -0
velocity/__init__.py
CHANGED
|
@@ -11,6 +11,14 @@ in ``client_actions`` (``client_actions = MINE | WORKFLOW_ACTIONS``)::
|
|
|
11
11
|
workflow-claim {docket, position, release?} -> {ok, docket}
|
|
12
12
|
workflow-notices {unread_only?, cursor?, limit?} -> {unread, rows, cursor?}
|
|
13
13
|
workflow-notice-ack {notice} | {all: true} -> {ok, unread}
|
|
14
|
+
workflow-board {route, station, entity?, cursor?, limit?}
|
|
15
|
+
-> Board
|
|
16
|
+
workflow-assign {docket, position, to, comment?, request_key}
|
|
17
|
+
-> {ok, docket}
|
|
18
|
+
workflow-prioritize {docket, priority, request_key} -> {ok, docket}
|
|
19
|
+
workflow-handover {to, stations?, route?} -> {ok, moved, kept}
|
|
20
|
+
workflow-flow {route?, entity?} -> {flows, as_of}
|
|
21
|
+
workflow-graph {docket, depth?} -> Graph
|
|
14
22
|
|
|
15
23
|
and :class:`WorkflowQueueMixin` to its queue handler (never reachable over
|
|
16
24
|
HTTP): ``workflow-program`` (a program station's job), ``workflow-drain``
|
|
@@ -27,7 +35,19 @@ records it before it happens, and the engine then acts with ``override``.
|
|
|
27
35
|
**Refusals** are ``{ok: false, reasons: [Reason]}`` with HTTP 403 (not
|
|
28
36
|
yours) or 409 (the docket's state or a guard said no), or 400 for a
|
|
29
37
|
malformed request. A docket the person may not see is refused exactly like
|
|
30
|
-
one that does not exist
|
|
38
|
+
one that does not exist; so is a board or a flow of a route or station that
|
|
39
|
+
does not exist.
|
|
40
|
+
|
|
41
|
+
**Boards, flows and graphs** (:mod:`velocity.workflow.views`): a board opens
|
|
42
|
+
for whoever sits at or oversees the station (``workflow.board``), a flow for
|
|
43
|
+
whoever owns the route or leads a station on it, or holds
|
|
44
|
+
``workflow.flow.view`` (``workflow.flow``; counts only over the entities
|
|
45
|
+
:func:`velocity.workflow.access.flow_scope` gives), a graph for whoever may
|
|
46
|
+
see its root docket. Assigning and prioritizing need ``workflow.docket.view``
|
|
47
|
+
and ``workflow.docket.assign`` / ``workflow.docket.prioritize`` (a route
|
|
48
|
+
owner, the station's lead, or ``workflow.position.assign`` for the docket's
|
|
49
|
+
entity); a hand-over moves only the caller's own positions, to a receiver
|
|
50
|
+
seated at their stations.
|
|
31
51
|
"""
|
|
32
52
|
|
|
33
53
|
from __future__ import annotations
|
|
@@ -46,6 +66,12 @@ CONFLICT = 409
|
|
|
46
66
|
BAD_REQUEST = 400
|
|
47
67
|
|
|
48
68
|
|
|
69
|
+
def _now():
|
|
70
|
+
import datetime
|
|
71
|
+
|
|
72
|
+
return datetime.datetime.now(datetime.timezone.utc)
|
|
73
|
+
|
|
74
|
+
|
|
49
75
|
def _workflow():
|
|
50
76
|
# imported lazily: velocity.workflow pulls in the rules package
|
|
51
77
|
from velocity import workflow
|
|
@@ -71,6 +97,7 @@ class WorkflowMixin:
|
|
|
71
97
|
"""See the module docstring."""
|
|
72
98
|
|
|
73
99
|
workflow_tray_limit = 50
|
|
100
|
+
workflow_board_limit = 50
|
|
74
101
|
|
|
75
102
|
# ── seams ──────────────────────────────────────────────────────────────
|
|
76
103
|
|
|
@@ -120,6 +147,63 @@ class WorkflowMixin:
|
|
|
120
147
|
except AccessError:
|
|
121
148
|
raise AccessError(authz.REFUSED) from None
|
|
122
149
|
|
|
150
|
+
def _wf_require_seat(self, tx, context, action, resource):
|
|
151
|
+
"""``authz.require`` on a station- or route-scoped action, refused
|
|
152
|
+
with the same sentence as every other workflow refusal."""
|
|
153
|
+
try:
|
|
154
|
+
return authz.require(self, tx, context, action, resource)
|
|
155
|
+
except AccessError:
|
|
156
|
+
raise AccessError(authz.REFUSED) from None
|
|
157
|
+
|
|
158
|
+
def _wf_route(self, tx, code, entity, seats):
|
|
159
|
+
"""The route a board or a flow draws (a missing one is refused like
|
|
160
|
+
one the person may not open)."""
|
|
161
|
+
wf = _workflow()
|
|
162
|
+
try:
|
|
163
|
+
return wf.views.route_for(tx, code, entity=entity, seats=seats)
|
|
164
|
+
except wf.WorkflowError:
|
|
165
|
+
raise AccessError(authz.REFUSED) from None
|
|
166
|
+
|
|
167
|
+
def _wf_entity(self, payload, seats):
|
|
168
|
+
"""The payload's ``entity``: only one the person has seats in (any
|
|
169
|
+
other is refused like a board or flow not theirs, so another
|
|
170
|
+
entity's routes and people are never read)."""
|
|
171
|
+
entity = (payload or {}).get("entity")
|
|
172
|
+
if entity is None:
|
|
173
|
+
return None
|
|
174
|
+
if isinstance(entity, bool) or not isinstance(entity, (str, int)):
|
|
175
|
+
raise _Refusal(
|
|
176
|
+
BAD_REQUEST, [{"code": "entity", "text": "entity must be an id."}]
|
|
177
|
+
)
|
|
178
|
+
entity = str(entity)
|
|
179
|
+
if entity == "" or not seats.in_entity(entity):
|
|
180
|
+
raise AccessError(authz.REFUSED)
|
|
181
|
+
return entity
|
|
182
|
+
|
|
183
|
+
def _wf_request_key(self, payload):
|
|
184
|
+
request_key = (payload or {}).get("request_key")
|
|
185
|
+
if not isinstance(request_key, str) or not request_key.strip():
|
|
186
|
+
raise _Refusal(
|
|
187
|
+
BAD_REQUEST,
|
|
188
|
+
[{"code": "request_key", "text": "A request key is required."}],
|
|
189
|
+
)
|
|
190
|
+
return request_key
|
|
191
|
+
|
|
192
|
+
def _wf_can_board(self, context, route, seats):
|
|
193
|
+
wf = _workflow()
|
|
194
|
+
|
|
195
|
+
def can_board(station):
|
|
196
|
+
relations = wf.access.station_relations(seats, route, station)
|
|
197
|
+
decision = authz.decide(
|
|
198
|
+
self,
|
|
199
|
+
wf.access.BOARD,
|
|
200
|
+
wf.access.station_resource(route, station, relations),
|
|
201
|
+
context,
|
|
202
|
+
)
|
|
203
|
+
return decision.allowed and not decision.audit
|
|
204
|
+
|
|
205
|
+
return can_board
|
|
206
|
+
|
|
123
207
|
def _wf_masquerading(self, principal) -> bool:
|
|
124
208
|
return principal.real_user is not None
|
|
125
209
|
|
|
@@ -408,6 +492,304 @@ class WorkflowMixin:
|
|
|
408
492
|
|
|
409
493
|
self._wf_guarded(tx, context, work)
|
|
410
494
|
|
|
495
|
+
# ── boards, flows, graphs ──────────────────────────────────────────────
|
|
496
|
+
|
|
497
|
+
def OnActionWorkflowBoard(self, tx, context):
|
|
498
|
+
wf = _workflow()
|
|
499
|
+
payload = context.payload() or {}
|
|
500
|
+
principal = self._wf_principal(context)
|
|
501
|
+
seats = self._wf_seats(tx, context, principal)
|
|
502
|
+
|
|
503
|
+
def work():
|
|
504
|
+
entity = self._wf_entity(payload, seats)
|
|
505
|
+
route = self._wf_route(tx, payload.get("route"), entity, seats)
|
|
506
|
+
try:
|
|
507
|
+
station = route.station(str(payload.get("station") or ""))
|
|
508
|
+
except wf.WorkflowError:
|
|
509
|
+
raise AccessError(authz.REFUSED) from None
|
|
510
|
+
relations = wf.access.station_relations(seats, route, station, entity)
|
|
511
|
+
self._wf_require_seat(
|
|
512
|
+
tx,
|
|
513
|
+
context,
|
|
514
|
+
wf.access.BOARD,
|
|
515
|
+
wf.access.station_resource(route, station, relations),
|
|
516
|
+
)
|
|
517
|
+
# what the board offers (display only: every write is decided
|
|
518
|
+
# per docket); nothing is offered under masquerade
|
|
519
|
+
writes = not self._wf_masquerading(principal)
|
|
520
|
+
assigns = writes and (
|
|
521
|
+
wf.access.OVERSEES in relations
|
|
522
|
+
or principal.holds_anywhere(wf.access.POSITION_ASSIGN)
|
|
523
|
+
)
|
|
524
|
+
viewer = wf.contract.Viewer(
|
|
525
|
+
seats=seats,
|
|
526
|
+
principal=principal,
|
|
527
|
+
view_decider=self._wf_decider(context),
|
|
528
|
+
)
|
|
529
|
+
body = wf.views.board(
|
|
530
|
+
tx,
|
|
531
|
+
viewer,
|
|
532
|
+
route,
|
|
533
|
+
station,
|
|
534
|
+
entity=entity,
|
|
535
|
+
cursor=payload.get("cursor"),
|
|
536
|
+
limit=payload.get("limit") or self.workflow_board_limit,
|
|
537
|
+
can={
|
|
538
|
+
"assign": assigns,
|
|
539
|
+
"prioritize": assigns,
|
|
540
|
+
"handover": writes and wf.access.SEATED in relations,
|
|
541
|
+
# the docket's can.flag, less what masquerade forbids
|
|
542
|
+
"flag": writes and bool(seats.person),
|
|
543
|
+
},
|
|
544
|
+
)
|
|
545
|
+
context.response().set_body(body)
|
|
546
|
+
|
|
547
|
+
self._wf_guarded(tx, context, work)
|
|
548
|
+
|
|
549
|
+
def OnActionWorkflowFlow(self, tx, context):
|
|
550
|
+
wf = _workflow()
|
|
551
|
+
payload = context.payload() or {}
|
|
552
|
+
principal = self._wf_principal(context)
|
|
553
|
+
seats = self._wf_seats(tx, context, principal)
|
|
554
|
+
viewer = wf.contract.Viewer(
|
|
555
|
+
seats=seats, principal=principal, view_decider=self._wf_decider(context)
|
|
556
|
+
)
|
|
557
|
+
|
|
558
|
+
def one(route, entity, required):
|
|
559
|
+
relations = wf.access.route_relations(seats, route, entity)
|
|
560
|
+
resource = wf.access.route_resource(route, relations)
|
|
561
|
+
if required:
|
|
562
|
+
self._wf_require_seat(tx, context, wf.access.FLOW, resource)
|
|
563
|
+
else:
|
|
564
|
+
decision = authz.decide(self, wf.access.FLOW, resource, context)
|
|
565
|
+
if not decision.allowed or decision.audit:
|
|
566
|
+
return None
|
|
567
|
+
scope = wf.access.flow_scope(seats, principal, route)
|
|
568
|
+
if entity is not None:
|
|
569
|
+
scope = scope.narrowed(entity)
|
|
570
|
+
if scope.empty:
|
|
571
|
+
# nothing this viewer may count: no flow (not a zeroed one)
|
|
572
|
+
if required:
|
|
573
|
+
raise AccessError(authz.REFUSED)
|
|
574
|
+
return None
|
|
575
|
+
return wf.views.flow(
|
|
576
|
+
tx,
|
|
577
|
+
viewer,
|
|
578
|
+
route,
|
|
579
|
+
scope,
|
|
580
|
+
can_board=self._wf_can_board(context, route, seats),
|
|
581
|
+
)
|
|
582
|
+
|
|
583
|
+
def work():
|
|
584
|
+
entity = self._wf_entity(payload, seats)
|
|
585
|
+
truncated = False
|
|
586
|
+
if payload.get("route") is not None:
|
|
587
|
+
route = self._wf_route(tx, payload.get("route"), entity, seats)
|
|
588
|
+
flows = [one(route, entity, True)]
|
|
589
|
+
else:
|
|
590
|
+
codes, truncated = wf.views.flow_route_codes(tx, seats, principal)
|
|
591
|
+
flows = []
|
|
592
|
+
for code in codes:
|
|
593
|
+
try:
|
|
594
|
+
route = wf.views.route_for(tx, code, entity=entity, seats=seats)
|
|
595
|
+
except wf.WorkflowError:
|
|
596
|
+
continue
|
|
597
|
+
found = one(route, entity, False)
|
|
598
|
+
if found is not None:
|
|
599
|
+
flows.append(found)
|
|
600
|
+
# nothing to show is an empty Business view (it names no route)
|
|
601
|
+
flows.sort(
|
|
602
|
+
key=lambda f: (f["route"]["label"].lower(), f["route"]["code"])
|
|
603
|
+
)
|
|
604
|
+
body = {"flows": flows, "as_of": wf.contract.iso(_now())}
|
|
605
|
+
if truncated:
|
|
606
|
+
body["truncated"] = True
|
|
607
|
+
context.response().set_body(body)
|
|
608
|
+
|
|
609
|
+
self._wf_guarded(tx, context, work)
|
|
610
|
+
|
|
611
|
+
def OnActionWorkflowGraph(self, tx, context):
|
|
612
|
+
wf = _workflow()
|
|
613
|
+
payload = context.payload() or {}
|
|
614
|
+
principal = self._wf_principal(context)
|
|
615
|
+
seats = self._wf_seats(tx, context, principal)
|
|
616
|
+
|
|
617
|
+
def work():
|
|
618
|
+
docket, route = self._wf_docket(tx, payload)
|
|
619
|
+
relations = wf.access.view_relations(tx, docket, route, seats)
|
|
620
|
+
self._wf_require(tx, context, wf.access.VIEW, docket, relations)
|
|
621
|
+
viewer = wf.contract.Viewer(
|
|
622
|
+
seats=seats,
|
|
623
|
+
principal=principal,
|
|
624
|
+
view_decider=self._wf_decider(context),
|
|
625
|
+
)
|
|
626
|
+
body = wf.views.graph(
|
|
627
|
+
tx, viewer, docket["sys_id"], depth=payload.get("depth")
|
|
628
|
+
)
|
|
629
|
+
context.response().set_body(body)
|
|
630
|
+
|
|
631
|
+
self._wf_guarded(tx, context, work)
|
|
632
|
+
|
|
633
|
+
# ── leading a station ──────────────────────────────────────────────────
|
|
634
|
+
|
|
635
|
+
def _wf_lead_write(self, tx, context, payload, principal, seats, kind, write):
|
|
636
|
+
"""The shared path of assign and prioritize: the docket must be
|
|
637
|
+
visible; a retry of the person's own request answers with the
|
|
638
|
+
docket; then ``kind``'s authz action decides on the lead relations
|
|
639
|
+
(``position``: the target position, or None for the docket)."""
|
|
640
|
+
wf = _workflow()
|
|
641
|
+
docket, route = self._wf_docket(tx, payload)
|
|
642
|
+
position = None
|
|
643
|
+
if kind == "assign":
|
|
644
|
+
try:
|
|
645
|
+
position = wf.engine._position(tx, payload.get("position"))
|
|
646
|
+
except wf.WorkflowError:
|
|
647
|
+
raise AccessError(authz.REFUSED) from None
|
|
648
|
+
if position["docket_id"] != docket["sys_id"]:
|
|
649
|
+
raise AccessError(authz.REFUSED)
|
|
650
|
+
relations = wf.access.view_relations(tx, docket, route, seats)
|
|
651
|
+
self._wf_require(tx, context, wf.access.VIEW, docket, relations)
|
|
652
|
+
request_key = payload.get("request_key")
|
|
653
|
+
actor = wf.engine.Actor.person(seats)
|
|
654
|
+
if isinstance(request_key, str) and wf.engine.already_marked(
|
|
655
|
+
tx, kind, docket["sys_id"], actor, request_key
|
|
656
|
+
):
|
|
657
|
+
body = self._wf_docket_body(tx, context, docket["sys_id"], principal, seats)
|
|
658
|
+
context.response().set_body({"ok": True, "docket": body})
|
|
659
|
+
return
|
|
660
|
+
action = wf.access.ASSIGN if kind == "assign" else wf.access.PRIORITIZE
|
|
661
|
+
lead = wf.access.lead_relations(tx, docket, route, seats, position)
|
|
662
|
+
self._wf_require(tx, context, action, docket, lead)
|
|
663
|
+
request_key = self._wf_request_key(payload)
|
|
664
|
+
write(docket, position, actor, request_key)
|
|
665
|
+
self._wf_after_change(tx, context, docket["sys_id"])
|
|
666
|
+
body = self._wf_docket_body(tx, context, docket["sys_id"], principal, seats)
|
|
667
|
+
context.response().set_body({"ok": True, "docket": body})
|
|
668
|
+
|
|
669
|
+
def OnActionWorkflowAssign(self, tx, context):
|
|
670
|
+
wf = _workflow()
|
|
671
|
+
payload = context.payload() or {}
|
|
672
|
+
principal = self._wf_principal(context)
|
|
673
|
+
seats = self._wf_seats(tx, context, principal)
|
|
674
|
+
|
|
675
|
+
def write(docket, position, actor, request_key):
|
|
676
|
+
to = payload.get("to")
|
|
677
|
+
if not isinstance(to, dict):
|
|
678
|
+
raise _Refusal(
|
|
679
|
+
BAD_REQUEST,
|
|
680
|
+
[{"code": "to", "text": "Say whom to assign it to."}],
|
|
681
|
+
)
|
|
682
|
+
comment = payload.get("comment")
|
|
683
|
+
if comment is not None and not isinstance(comment, str):
|
|
684
|
+
raise _Refusal(
|
|
685
|
+
BAD_REQUEST, [{"code": "comment", "text": "comment must be text."}]
|
|
686
|
+
)
|
|
687
|
+
person = to.get("id")
|
|
688
|
+
if to.get("kind") == "person" and (
|
|
689
|
+
isinstance(person, bool) or not isinstance(person, (str, int))
|
|
690
|
+
):
|
|
691
|
+
raise _Refusal(
|
|
692
|
+
BAD_REQUEST,
|
|
693
|
+
[{"code": "to", "text": "Say whom to assign it to."}],
|
|
694
|
+
)
|
|
695
|
+
wf.engine.assign(
|
|
696
|
+
tx,
|
|
697
|
+
docket["sys_id"],
|
|
698
|
+
position["sys_id"],
|
|
699
|
+
{"kind": to.get("kind"), "id": None if person is None else str(person)},
|
|
700
|
+
actor,
|
|
701
|
+
request_key=request_key,
|
|
702
|
+
comment=comment,
|
|
703
|
+
)
|
|
704
|
+
|
|
705
|
+
self._wf_guarded(
|
|
706
|
+
tx,
|
|
707
|
+
context,
|
|
708
|
+
lambda: self._wf_lead_write(
|
|
709
|
+
tx, context, payload, principal, seats, "assign", write
|
|
710
|
+
),
|
|
711
|
+
)
|
|
712
|
+
|
|
713
|
+
def OnActionWorkflowPrioritize(self, tx, context):
|
|
714
|
+
wf = _workflow()
|
|
715
|
+
payload = context.payload() or {}
|
|
716
|
+
principal = self._wf_principal(context)
|
|
717
|
+
seats = self._wf_seats(tx, context, principal)
|
|
718
|
+
|
|
719
|
+
def write(docket, position, actor, request_key):
|
|
720
|
+
wf.engine.prioritize(
|
|
721
|
+
tx,
|
|
722
|
+
docket["sys_id"],
|
|
723
|
+
payload.get("priority"),
|
|
724
|
+
actor,
|
|
725
|
+
request_key=request_key,
|
|
726
|
+
)
|
|
727
|
+
|
|
728
|
+
self._wf_guarded(
|
|
729
|
+
tx,
|
|
730
|
+
context,
|
|
731
|
+
lambda: self._wf_lead_write(
|
|
732
|
+
tx, context, payload, principal, seats, "prioritize", write
|
|
733
|
+
),
|
|
734
|
+
)
|
|
735
|
+
|
|
736
|
+
def OnActionWorkflowHandover(self, tx, context):
|
|
737
|
+
wf = _workflow()
|
|
738
|
+
payload = context.payload() or {}
|
|
739
|
+
principal = self._wf_principal(context)
|
|
740
|
+
seats = self._wf_seats(tx, context, principal)
|
|
741
|
+
|
|
742
|
+
def bad(code, text):
|
|
743
|
+
return _Refusal(BAD_REQUEST, [{"code": code, "text": text}])
|
|
744
|
+
|
|
745
|
+
def work():
|
|
746
|
+
authz.require(self, tx, context, wf.access.HANDOVER)
|
|
747
|
+
to = payload.get("to")
|
|
748
|
+
if isinstance(to, bool) or not isinstance(to, (str, int)):
|
|
749
|
+
raise bad("to", "Say whom to hand over to.")
|
|
750
|
+
to = str(to).strip()
|
|
751
|
+
stations = payload.get("stations")
|
|
752
|
+
if stations is not None:
|
|
753
|
+
if not isinstance(stations, list) or not all(
|
|
754
|
+
isinstance(s, str) and wf.hooks.CODE.match(s) for s in stations
|
|
755
|
+
):
|
|
756
|
+
raise bad("stations", "stations must be station codes.")
|
|
757
|
+
route = payload.get("route")
|
|
758
|
+
if route is not None and not (
|
|
759
|
+
isinstance(route, str) and wf.hooks.CODE.match(route)
|
|
760
|
+
):
|
|
761
|
+
raise bad("route", "route must be a route code.")
|
|
762
|
+
if wf.hooks.hook("person_seats") is None:
|
|
763
|
+
raise wf.WorkflowError(
|
|
764
|
+
"Hand-overs need register_person_seats (the receiver's seats)."
|
|
765
|
+
)
|
|
766
|
+
receiver = wf.hooks.person_seats(tx, to) if to else None
|
|
767
|
+
if receiver is None or receiver.person != to:
|
|
768
|
+
raise _Refusal(
|
|
769
|
+
CONFLICT,
|
|
770
|
+
[{"code": "not_seated", "text": "They do not sit there."}],
|
|
771
|
+
)
|
|
772
|
+
row_id = wf.engine.handover(
|
|
773
|
+
tx,
|
|
774
|
+
seats.person,
|
|
775
|
+
to,
|
|
776
|
+
to_seats=receiver,
|
|
777
|
+
stations=stations or None,
|
|
778
|
+
route=route,
|
|
779
|
+
seated_only=True,
|
|
780
|
+
by=wf.engine.Actor.person(seats),
|
|
781
|
+
)
|
|
782
|
+
row = tx.table(wf.schema.HANDOVER).find({"sys_id": row_id})
|
|
783
|
+
context.response().set_body(
|
|
784
|
+
{
|
|
785
|
+
"ok": True,
|
|
786
|
+
"moved": int(row.get("moved") or 0),
|
|
787
|
+
"kept": int(row.get("kept") or 0),
|
|
788
|
+
}
|
|
789
|
+
)
|
|
790
|
+
|
|
791
|
+
self._wf_guarded(tx, context, work)
|
|
792
|
+
|
|
411
793
|
# ── notices ────────────────────────────────────────────────────────────
|
|
412
794
|
|
|
413
795
|
def OnActionWorkflowNotices(self, tx, context):
|
velocity/db/_pgddl.py
CHANGED
|
@@ -141,12 +141,104 @@ def execute_all(tx, statements: Iterable[str]) -> None:
|
|
|
141
141
|
tx.execute(statement)
|
|
142
142
|
|
|
143
143
|
|
|
144
|
+
# A trigger velocity installed carries this comment: a digest of the CREATE
|
|
145
|
+
# statement that made it, so a re-run can tell an unchanged trigger.
|
|
146
|
+
TRIGGER_COMMENT_PREFIX = "velocity:"
|
|
147
|
+
_DROP_TRIGGER = "DROP TRIGGER IF EXISTS "
|
|
148
|
+
_CREATE_TRIGGERS = ("CREATE TRIGGER ", "CREATE CONSTRAINT TRIGGER ")
|
|
149
|
+
_TRIGGER_STATE_SQL = (
|
|
150
|
+
"SELECT t.tgenabled::text AS enabled, d.description "
|
|
151
|
+
"FROM pg_catalog.pg_trigger t "
|
|
152
|
+
"LEFT JOIN pg_catalog.pg_description d ON d.objoid = t.oid "
|
|
153
|
+
"AND d.classoid = 'pg_catalog.pg_trigger'::regclass "
|
|
154
|
+
"WHERE t.tgrelid = pg_catalog.to_regclass(%s) AND t.tgname = %s "
|
|
155
|
+
"AND NOT t.tgisinternal"
|
|
156
|
+
)
|
|
157
|
+
|
|
158
|
+
|
|
159
|
+
def is_trigger_bookkeeping(sql: str) -> bool:
|
|
160
|
+
"""Whether ``sql`` is :func:`execute_ddl`'s own (the installed-trigger
|
|
161
|
+
probe or the fingerprint comment), not one of the caller's statements."""
|
|
162
|
+
return sql == _TRIGGER_STATE_SQL or sql.startswith("COMMENT ON TRIGGER ")
|
|
163
|
+
|
|
164
|
+
|
|
165
|
+
def trigger_fingerprint(create_sql: str) -> str:
|
|
166
|
+
"""The comment an installed trigger carries for ``create_sql``."""
|
|
167
|
+
digest = hashlib.sha256(create_sql.encode("utf-8")).hexdigest()[:32]
|
|
168
|
+
return TRIGGER_COMMENT_PREFIX + digest
|
|
169
|
+
|
|
170
|
+
|
|
171
|
+
def _trigger_pair(drop_sql: str, create_sql: str):
|
|
172
|
+
"""``(quoted name, quoted table)`` of a ``DROP TRIGGER IF EXISTS`` that
|
|
173
|
+
the matching ``CREATE TRIGGER`` re-makes, else ``None``."""
|
|
174
|
+
create = next((p for p in _CREATE_TRIGGERS if create_sql.startswith(p)), None)
|
|
175
|
+
if not drop_sql.startswith(_DROP_TRIGGER) or create is None:
|
|
176
|
+
return None
|
|
177
|
+
name, sep, target = drop_sql[len(_DROP_TRIGGER) :].partition(" ON ")
|
|
178
|
+
if not sep or not create_sql[len(create) :].startswith(name + " "):
|
|
179
|
+
return None
|
|
180
|
+
if f" ON {target} " not in create_sql:
|
|
181
|
+
return None
|
|
182
|
+
return name, target
|
|
183
|
+
|
|
184
|
+
|
|
185
|
+
def _unquote(quoted: str) -> str:
|
|
186
|
+
return quoted[1:-1].replace('""', '"') if quoted.startswith('"') else quoted
|
|
187
|
+
|
|
188
|
+
|
|
189
|
+
def trigger_unchanged(tx, name: str, target: str, create_sql: str) -> bool:
|
|
190
|
+
"""Whether the trigger ``name`` (quoted) on ``target`` (quoted table) is
|
|
191
|
+
enabled for ordinary sessions and was made by exactly ``create_sql``."""
|
|
192
|
+
rows = tx.execute(_TRIGGER_STATE_SQL, (target, _unquote(name))).all()
|
|
193
|
+
return (
|
|
194
|
+
bool(rows)
|
|
195
|
+
and rows[0].get("enabled") in ("O", "A")
|
|
196
|
+
and (rows[0].get("description") == trigger_fingerprint(create_sql))
|
|
197
|
+
)
|
|
198
|
+
|
|
199
|
+
|
|
200
|
+
def execute_ddl(tx, statements: Iterable[str]) -> None:
|
|
201
|
+
""":func:`execute_all`, except that a ``DROP TRIGGER IF EXISTS`` followed
|
|
202
|
+
by the ``CREATE TRIGGER`` that re-makes it is skipped when the installed
|
|
203
|
+
trigger is enabled and carries that statement's fingerprint, and a
|
|
204
|
+
trigger it does make is marked with one. ``DROP TRIGGER`` takes an
|
|
205
|
+
ACCESS EXCLUSIVE lock, so re-making unchanged triggers on every schema
|
|
206
|
+
lane run blocks (and can deadlock with) a live database's readers."""
|
|
207
|
+
statements = list(statements)
|
|
208
|
+
i = 0
|
|
209
|
+
while i < len(statements):
|
|
210
|
+
statement = statements[i]
|
|
211
|
+
pair = (
|
|
212
|
+
_trigger_pair(statement, statements[i + 1])
|
|
213
|
+
if i + 1 < len(statements)
|
|
214
|
+
else None
|
|
215
|
+
)
|
|
216
|
+
if pair is None:
|
|
217
|
+
tx.execute(statement)
|
|
218
|
+
i += 1
|
|
219
|
+
continue
|
|
220
|
+
name, target = pair
|
|
221
|
+
create_sql = statements[i + 1]
|
|
222
|
+
if not trigger_unchanged(tx, name, target, create_sql):
|
|
223
|
+
tx.execute(statement)
|
|
224
|
+
tx.execute(create_sql)
|
|
225
|
+
tx.execute(
|
|
226
|
+
f"COMMENT ON TRIGGER {name} ON {target} IS "
|
|
227
|
+
f"{quote_literal(trigger_fingerprint(create_sql))}"
|
|
228
|
+
)
|
|
229
|
+
i += 2
|
|
230
|
+
|
|
231
|
+
|
|
144
232
|
__all__ = [
|
|
145
233
|
"DDL_LOCK_KEY",
|
|
146
234
|
"DEFAULT_SCHEMA",
|
|
147
235
|
"FUNCTION_SEARCH_PATH",
|
|
148
236
|
"bounded_name",
|
|
149
237
|
"execute_all",
|
|
238
|
+
"execute_ddl",
|
|
239
|
+
"is_trigger_bookkeeping",
|
|
240
|
+
"trigger_fingerprint",
|
|
241
|
+
"trigger_unchanged",
|
|
150
242
|
"function_schema",
|
|
151
243
|
"identifier",
|
|
152
244
|
"identifiers",
|
velocity/db/audit.py
CHANGED
|
@@ -567,7 +567,7 @@ def require_audit(
|
|
|
567
567
|
if ensure_table:
|
|
568
568
|
ensure_audit_log(tx, audit_table, on_existing_conflicts="ignore")
|
|
569
569
|
_assert_owned(tx, "audit table", _pgddl.quote_table(audit_table, "audit table"))
|
|
570
|
-
_pgddl.
|
|
570
|
+
_pgddl.execute_ddl(tx, statements)
|
|
571
571
|
_assert_owned(
|
|
572
572
|
tx, "audit capture function", f"{fn_schema}.{FUNCTION_NAME}()", function=True
|
|
573
573
|
)
|
velocity/db/integrity.py
CHANGED
|
@@ -202,7 +202,7 @@ def require_append_only(
|
|
|
202
202
|
_pgddl.require_postgres(tx, "require_append_only")
|
|
203
203
|
statements = row_lock_sql(table, mutable_columns=mutable_columns)
|
|
204
204
|
tx.advisory_lock(DDL_LOCK_KEY)
|
|
205
|
-
_pgddl.
|
|
205
|
+
_pgddl.execute_ddl(tx, statements)
|
|
206
206
|
|
|
207
207
|
|
|
208
208
|
def require_posted_lock(
|
|
@@ -231,7 +231,7 @@ def require_posted_lock(
|
|
|
231
231
|
)
|
|
232
232
|
_assert_column_exists(tx, table, posted_column)
|
|
233
233
|
tx.advisory_lock(DDL_LOCK_KEY)
|
|
234
|
-
_pgddl.
|
|
234
|
+
_pgddl.execute_ddl(tx, statements)
|
|
235
235
|
|
|
236
236
|
|
|
237
237
|
def drop_row_lock(tx, table: str) -> None:
|
|
@@ -736,7 +736,7 @@ def require_period_lock(
|
|
|
736
736
|
time_zone=time_zone,
|
|
737
737
|
)
|
|
738
738
|
tx.advisory_lock(DDL_LOCK_KEY)
|
|
739
|
-
_pgddl.
|
|
739
|
+
_pgddl.execute_ddl(tx, statements)
|
|
740
740
|
|
|
741
741
|
|
|
742
742
|
def drop_period_lock(tx, table: str) -> None:
|
velocity/workflow/__init__.py
CHANGED
|
@@ -15,7 +15,9 @@ leaves the transaction. The handler actions live in
|
|
|
15
15
|
An application supplies, in code: :func:`register_subject`,
|
|
16
16
|
:func:`register_program`, :func:`register_sheet`, :func:`register_seats`
|
|
17
17
|
(and optionally :func:`register_recipients`, :func:`register_contact`,
|
|
18
|
-
:func:`register_person_label
|
|
18
|
+
:func:`register_person_label`, :func:`register_station_people`,
|
|
19
|
+
:func:`register_time_zone`). :mod:`.views` draws the Station Board, the
|
|
20
|
+
Flow map and the Dependency view. Nothing here names a business. See
|
|
19
21
|
docs/workflow.md.
|
|
20
22
|
"""
|
|
21
23
|
|
|
@@ -29,6 +31,7 @@ from . import (
|
|
|
29
31
|
outbox,
|
|
30
32
|
points,
|
|
31
33
|
schema,
|
|
34
|
+
views,
|
|
32
35
|
) # noqa: F401
|
|
33
36
|
from .contract import Viewer, build_docket, tray # noqa: F401
|
|
34
37
|
from .definitions import ( # noqa: F401
|
|
@@ -54,6 +57,7 @@ from .engine import ( # noqa: F401
|
|
|
54
57
|
act,
|
|
55
58
|
actions_for,
|
|
56
59
|
advance,
|
|
60
|
+
assign,
|
|
57
61
|
check_possession,
|
|
58
62
|
claim,
|
|
59
63
|
clear_flag,
|
|
@@ -63,6 +67,7 @@ from .engine import ( # noqa: F401
|
|
|
63
67
|
link,
|
|
64
68
|
open_docket,
|
|
65
69
|
place_hold,
|
|
70
|
+
prioritize,
|
|
66
71
|
release_hold,
|
|
67
72
|
resume_wait,
|
|
68
73
|
run_program,
|
|
@@ -91,7 +96,9 @@ from .hooks import ( # noqa: F401
|
|
|
91
96
|
register_recipients,
|
|
92
97
|
register_seats,
|
|
93
98
|
register_sheet,
|
|
99
|
+
register_station_people,
|
|
94
100
|
register_subject,
|
|
101
|
+
register_time_zone,
|
|
95
102
|
)
|
|
96
103
|
from .notices import Channel, EmailChannel, register_channel # noqa: F401
|
|
97
104
|
from .schema import ensure_schema # noqa: F401
|
|
@@ -120,6 +127,7 @@ __all__ = [
|
|
|
120
127
|
"act",
|
|
121
128
|
"actions_for",
|
|
122
129
|
"advance",
|
|
130
|
+
"assign",
|
|
123
131
|
"build_docket",
|
|
124
132
|
"check_possession",
|
|
125
133
|
"claim",
|
|
@@ -134,6 +142,7 @@ __all__ = [
|
|
|
134
142
|
"load_route_version",
|
|
135
143
|
"open_docket",
|
|
136
144
|
"place_hold",
|
|
145
|
+
"prioritize",
|
|
137
146
|
"publish",
|
|
138
147
|
"register_calendar",
|
|
139
148
|
"register_channel",
|
|
@@ -145,7 +154,9 @@ __all__ = [
|
|
|
145
154
|
"register_recipients",
|
|
146
155
|
"register_seats",
|
|
147
156
|
"register_sheet",
|
|
157
|
+
"register_station_people",
|
|
148
158
|
"register_subject",
|
|
159
|
+
"register_time_zone",
|
|
149
160
|
"release_hold",
|
|
150
161
|
"resume_wait",
|
|
151
162
|
"retire",
|