velocity-python 0.5.1__py3-none-any.whl → 0.7.0__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 +524 -4
- velocity/aws/ops.py +8 -0
- velocity/workflow/__init__.py +13 -2
- velocity/workflow/access.py +304 -7
- velocity/workflow/contract.py +6 -2
- velocity/workflow/definitions.py +103 -26
- velocity/workflow/designer.py +1444 -0
- velocity/workflow/engine.py +242 -68
- velocity/workflow/hooks.py +34 -0
- velocity/workflow/operator.py +820 -0
- velocity/workflow/schema.py +22 -2
- {velocity_python-0.5.1.dist-info → velocity_python-0.7.0.dist-info}/METADATA +1 -1
- {velocity_python-0.5.1.dist-info → velocity_python-0.7.0.dist-info}/RECORD +18 -16
- {velocity_python-0.5.1.dist-info → velocity_python-0.7.0.dist-info}/WHEEL +0 -0
- {velocity_python-0.5.1.dist-info → velocity_python-0.7.0.dist-info}/entry_points.txt +0 -0
- {velocity_python-0.5.1.dist-info → velocity_python-0.7.0.dist-info}/licenses/LICENSE +0 -0
- {velocity_python-0.5.1.dist-info → velocity_python-0.7.0.dist-info}/top_level.txt +0 -0
velocity/__init__.py
CHANGED
|
@@ -19,6 +19,19 @@ in ``client_actions`` (``client_actions = MINE | WORKFLOW_ACTIONS``)::
|
|
|
19
19
|
workflow-handover {to, stations?, route?} -> {ok, moved, kept}
|
|
20
20
|
workflow-flow {route?, entity?} -> {flows, as_of}
|
|
21
21
|
workflow-graph {docket, depth?} -> Graph
|
|
22
|
+
workflow-operator {route?, entity?} -> Console
|
|
23
|
+
workflow-operator-act {docket, position, verb, comment?, request_key}
|
|
24
|
+
-> {ok, replayed?}
|
|
25
|
+
workflow-routes {} -> {routes, truncated?}
|
|
26
|
+
workflow-route {route_id} -> {version: RouteVersion}
|
|
27
|
+
workflow-route-draft {from, request_key} -> {ok, replayed, version}
|
|
28
|
+
workflow-route-edit {route_id, revision, changes} -> {ok, version}
|
|
29
|
+
workflow-route-lint {route_id} -> {lint}
|
|
30
|
+
workflow-route-simulate {route_id, sample} -> {simulation}
|
|
31
|
+
workflow-route-test {route_id} -> {tests}
|
|
32
|
+
workflow-route-publish {route_id, revision, effective_from, comment?, request_key}
|
|
33
|
+
-> {ok, replayed, in_flight, version}
|
|
34
|
+
workflow-route-archive {route_id} -> {ok, replayed, version}
|
|
22
35
|
|
|
23
36
|
and :class:`WorkflowQueueMixin` to its queue handler (never reachable over
|
|
24
37
|
HTTP): ``workflow-program`` (a program station's job), ``workflow-drain``
|
|
@@ -48,6 +61,29 @@ and ``workflow.docket.assign`` / ``workflow.docket.prioritize`` (a route
|
|
|
48
61
|
owner, the station's lead, or ``workflow.position.assign`` for the docket's
|
|
49
62
|
entity); a hand-over moves only the caller's own positions, to a receiver
|
|
50
63
|
seated at their stations.
|
|
64
|
+
|
|
65
|
+
**The Operator console** (:mod:`velocity.workflow.operator`) opens for a
|
|
66
|
+
holder of ``workflow.operate`` (anywhere) or a route owner
|
|
67
|
+
(``workflow.operator``), over the routes and entities
|
|
68
|
+
:func:`velocity.workflow.access.operator_scope` gives; its site-wide
|
|
69
|
+
sections (integrations, scheduled jobs) only with ``workflow.operate``
|
|
70
|
+
granted site-wide. ``workflow-operator-act`` retries, skips or takes over a
|
|
71
|
+
problem-tray position: the viewer must see the docket and be allowed
|
|
72
|
+
``workflow.problem.resolve`` (its problem owner, or ``workflow.operate`` for
|
|
73
|
+
its entity — recorded), and the engine's own problem action decides the rest
|
|
74
|
+
(skip and take-over only where the station is skippable).
|
|
75
|
+
|
|
76
|
+
**The Route designer** (:mod:`velocity.workflow.designer`): every action
|
|
77
|
+
names a route version (``route_id``; ``from`` for a new draft) and is
|
|
78
|
+
decided on the route (its code and entity): ``workflow.designer`` to open,
|
|
79
|
+
lint, simulate and test it (``workflow.route.design`` for the route's
|
|
80
|
+
entity, or owning the route with ``workflow.use`` there),
|
|
81
|
+
``workflow.designer.edit`` to create, edit and archive drafts (the same),
|
|
82
|
+
and ``workflow.designer.publish`` to publish (``workflow.route.publish`` for
|
|
83
|
+
the route's entity AND owning the route — by the version in force, never
|
|
84
|
+
the draft's own owner role; recorded). A version the person may not open is
|
|
85
|
+
refused exactly like one that does not exist. Masquerade forbids every
|
|
86
|
+
designer write. Simulations and tests write nothing.
|
|
51
87
|
"""
|
|
52
88
|
|
|
53
89
|
from __future__ import annotations
|
|
@@ -207,18 +243,21 @@ class WorkflowMixin:
|
|
|
207
243
|
def _wf_masquerading(self, principal) -> bool:
|
|
208
244
|
return principal.real_user is not None
|
|
209
245
|
|
|
210
|
-
def _wf_decider(self, context):
|
|
246
|
+
def _wf_decider(self, context, accept=frozenset()):
|
|
211
247
|
"""The viewer's ``may_view``: the site's authz decision on
|
|
212
248
|
``workflow.docket.view`` for one docket (a forbid rule hides it from
|
|
213
249
|
trays and links too). A privileged permit (``view_any``) is not
|
|
214
|
-
used here: listing is never a recorded use.
|
|
250
|
+
used here: listing is never a recorded use. ``accept`` names the
|
|
251
|
+
audited rules a listing may still show (never recorded here): the
|
|
252
|
+
Operator console lists its problem dockets under
|
|
253
|
+
``workflow.operator_view``."""
|
|
215
254
|
wf = _workflow()
|
|
216
255
|
|
|
217
256
|
def decide(docket, relations):
|
|
218
257
|
decision = authz.decide(
|
|
219
258
|
self, wf.access.VIEW, wf.access.resource(docket, relations), context
|
|
220
259
|
)
|
|
221
|
-
return decision.allowed and not decision.audit
|
|
260
|
+
return decision.allowed and (not decision.audit or decision.rule in accept)
|
|
222
261
|
|
|
223
262
|
return decide
|
|
224
263
|
|
|
@@ -564,7 +603,7 @@ class WorkflowMixin:
|
|
|
564
603
|
decision = authz.decide(self, wf.access.FLOW, resource, context)
|
|
565
604
|
if not decision.allowed or decision.audit:
|
|
566
605
|
return None
|
|
567
|
-
scope = wf.access.flow_scope(seats, principal, route)
|
|
606
|
+
scope = wf.access.flow_scope(seats, principal, route, tx=tx)
|
|
568
607
|
if entity is not None:
|
|
569
608
|
scope = scope.narrowed(entity)
|
|
570
609
|
if scope.empty:
|
|
@@ -790,6 +829,487 @@ class WorkflowMixin:
|
|
|
790
829
|
|
|
791
830
|
self._wf_guarded(tx, context, work)
|
|
792
831
|
|
|
832
|
+
# ── the Operator console ───────────────────────────────────────────────
|
|
833
|
+
|
|
834
|
+
def _wf_can_resolve(self, tx, context, principal, seats):
|
|
835
|
+
"""Whether ``workflow.problem.resolve`` would be allowed on a
|
|
836
|
+
problem position (display only: never recorded; nothing under
|
|
837
|
+
masquerade)."""
|
|
838
|
+
wf = _workflow()
|
|
839
|
+
masquerading = self._wf_masquerading(principal)
|
|
840
|
+
|
|
841
|
+
def can_resolve(docket, route, position, verb):
|
|
842
|
+
if masquerading:
|
|
843
|
+
return False
|
|
844
|
+
relations = wf.access.problem_relations(tx, docket, route, seats, position)
|
|
845
|
+
if not relations:
|
|
846
|
+
return False
|
|
847
|
+
decision = authz.decide(
|
|
848
|
+
self,
|
|
849
|
+
wf.access.RESOLVE,
|
|
850
|
+
wf.access.resource(docket, relations),
|
|
851
|
+
context,
|
|
852
|
+
)
|
|
853
|
+
if not decision.allowed:
|
|
854
|
+
return False
|
|
855
|
+
if verb == "take_over":
|
|
856
|
+
return authz.decide(
|
|
857
|
+
self,
|
|
858
|
+
wf.access.TAKE_OVER,
|
|
859
|
+
wf.access.resource(docket, ()),
|
|
860
|
+
context,
|
|
861
|
+
).allowed
|
|
862
|
+
return True
|
|
863
|
+
|
|
864
|
+
return can_resolve
|
|
865
|
+
|
|
866
|
+
def OnActionWorkflowOperator(self, tx, context):
|
|
867
|
+
wf = _workflow()
|
|
868
|
+
payload = context.payload() or {}
|
|
869
|
+
principal = self._wf_principal(context)
|
|
870
|
+
seats = self._wf_seats(tx, context, principal)
|
|
871
|
+
|
|
872
|
+
def work():
|
|
873
|
+
entity = self._wf_entity(payload, seats)
|
|
874
|
+
truncated = False
|
|
875
|
+
named = payload.get("route") is not None
|
|
876
|
+
if named:
|
|
877
|
+
candidates = [self._wf_route(tx, payload.get("route"), entity, seats)]
|
|
878
|
+
else:
|
|
879
|
+
codes, truncated = wf.operator.route_codes(tx, seats, principal)
|
|
880
|
+
candidates = []
|
|
881
|
+
for code in codes:
|
|
882
|
+
try:
|
|
883
|
+
candidates.append(
|
|
884
|
+
wf.views.route_for(tx, code, entity=entity, seats=seats)
|
|
885
|
+
)
|
|
886
|
+
except wf.WorkflowError:
|
|
887
|
+
continue
|
|
888
|
+
self._wf_require_seat(
|
|
889
|
+
tx,
|
|
890
|
+
context,
|
|
891
|
+
wf.access.CONSOLE,
|
|
892
|
+
wf.access.console_resource(
|
|
893
|
+
wf.access.console_relations(seats, candidates)
|
|
894
|
+
),
|
|
895
|
+
)
|
|
896
|
+
scopes = {}
|
|
897
|
+
for route in candidates:
|
|
898
|
+
scope = wf.access.operator_scope(seats, principal, route, tx=tx)
|
|
899
|
+
if entity is not None:
|
|
900
|
+
scope = scope.narrowed(entity)
|
|
901
|
+
if not scope.empty:
|
|
902
|
+
scopes[route.code] = scope
|
|
903
|
+
if named and not scopes:
|
|
904
|
+
# a route this viewer may not operate: refused like one that
|
|
905
|
+
# does not exist
|
|
906
|
+
raise AccessError(authz.REFUSED)
|
|
907
|
+
viewer = wf.contract.Viewer(
|
|
908
|
+
seats=seats,
|
|
909
|
+
principal=principal,
|
|
910
|
+
view_decider=self._wf_decider(
|
|
911
|
+
context,
|
|
912
|
+
accept=frozenset({wf.access.OPERATOR_VIEW_RULE}),
|
|
913
|
+
),
|
|
914
|
+
)
|
|
915
|
+
body = wf.operator.console(
|
|
916
|
+
tx,
|
|
917
|
+
viewer,
|
|
918
|
+
[r for r in candidates if r.code in scopes],
|
|
919
|
+
scopes,
|
|
920
|
+
site=wf.access.site_wide(principal, wf.access.OPERATE),
|
|
921
|
+
can_resolve=self._wf_can_resolve(tx, context, principal, seats),
|
|
922
|
+
)
|
|
923
|
+
if truncated:
|
|
924
|
+
body["truncated"] = True
|
|
925
|
+
context.response().set_body(body)
|
|
926
|
+
|
|
927
|
+
self._wf_guarded(tx, context, work)
|
|
928
|
+
|
|
929
|
+
def OnActionWorkflowOperatorAct(self, tx, context):
|
|
930
|
+
wf = _workflow()
|
|
931
|
+
payload = context.payload() or {}
|
|
932
|
+
principal = self._wf_principal(context)
|
|
933
|
+
seats = self._wf_seats(tx, context, principal)
|
|
934
|
+
|
|
935
|
+
def work():
|
|
936
|
+
verb = payload.get("verb")
|
|
937
|
+
if verb not in wf.engine.PROBLEM_VERBS:
|
|
938
|
+
raise _Refusal(
|
|
939
|
+
BAD_REQUEST,
|
|
940
|
+
[
|
|
941
|
+
{
|
|
942
|
+
"code": "verb",
|
|
943
|
+
"text": "verb must be retry, skip or take_over.",
|
|
944
|
+
}
|
|
945
|
+
],
|
|
946
|
+
)
|
|
947
|
+
docket, route = self._wf_docket(tx, payload)
|
|
948
|
+
try:
|
|
949
|
+
position = wf.engine._position(tx, payload.get("position"))
|
|
950
|
+
except wf.WorkflowError:
|
|
951
|
+
raise AccessError(authz.REFUSED) from None
|
|
952
|
+
if position["docket_id"] != docket["sys_id"]:
|
|
953
|
+
raise AccessError(authz.REFUSED)
|
|
954
|
+
request_key = payload.get("request_key")
|
|
955
|
+
if isinstance(request_key, str) and request_key.strip():
|
|
956
|
+
mark = wf.engine.acted_mark(
|
|
957
|
+
tx, docket["sys_id"], wf.engine.Actor.person(seats), request_key
|
|
958
|
+
)
|
|
959
|
+
if mark is not None:
|
|
960
|
+
# this person's own request again: the first answer
|
|
961
|
+
# only if it was this very action (the position has
|
|
962
|
+
# usually left the problem tray since)
|
|
963
|
+
if (
|
|
964
|
+
mark.get("action") != verb
|
|
965
|
+
or mark.get("position_id") != position["sys_id"]
|
|
966
|
+
):
|
|
967
|
+
raise _Refusal(
|
|
968
|
+
CONFLICT,
|
|
969
|
+
[
|
|
970
|
+
{
|
|
971
|
+
"code": "request_key",
|
|
972
|
+
"text": "That request key was used for "
|
|
973
|
+
"another action.",
|
|
974
|
+
}
|
|
975
|
+
],
|
|
976
|
+
)
|
|
977
|
+
# nothing under masquerade, and only for someone who may
|
|
978
|
+
# still see the docket or operate
|
|
979
|
+
if self._wf_masquerading(principal):
|
|
980
|
+
raise AccessError(authz.REFUSED)
|
|
981
|
+
seen = authz.decide(
|
|
982
|
+
self,
|
|
983
|
+
wf.access.VIEW,
|
|
984
|
+
wf.access.resource(
|
|
985
|
+
docket,
|
|
986
|
+
wf.access.view_relations(tx, docket, route, seats),
|
|
987
|
+
),
|
|
988
|
+
context,
|
|
989
|
+
).allowed
|
|
990
|
+
if not seen and not principal.holds_anywhere(wf.access.OPERATE):
|
|
991
|
+
raise AccessError(authz.REFUSED)
|
|
992
|
+
context.response().set_body({"ok": True, "replayed": True})
|
|
993
|
+
return
|
|
994
|
+
relations = wf.access.view_relations(tx, docket, route, seats)
|
|
995
|
+
self._wf_require(tx, context, wf.access.VIEW, docket, relations)
|
|
996
|
+
decision = self._wf_require(
|
|
997
|
+
tx,
|
|
998
|
+
context,
|
|
999
|
+
wf.access.RESOLVE,
|
|
1000
|
+
docket,
|
|
1001
|
+
wf.access.problem_relations(tx, docket, route, seats, position),
|
|
1002
|
+
)
|
|
1003
|
+
if verb == "take_over":
|
|
1004
|
+
# the work taken over is then theirs to do (workflow.use for
|
|
1005
|
+
# the docket's entity; a site rule may refuse it)
|
|
1006
|
+
self._wf_require(tx, context, wf.access.TAKE_OVER, docket, ())
|
|
1007
|
+
request_key = self._wf_request_key(payload)
|
|
1008
|
+
comment = payload.get("comment")
|
|
1009
|
+
if comment is not None and not isinstance(comment, str):
|
|
1010
|
+
raise _Refusal(
|
|
1011
|
+
BAD_REQUEST, [{"code": "comment", "text": "comment must be text."}]
|
|
1012
|
+
)
|
|
1013
|
+
actor = wf.engine.Actor.person(
|
|
1014
|
+
seats,
|
|
1015
|
+
operator=decision.rule == wf.access.OPERATOR_RULE,
|
|
1016
|
+
allows=self._wf_allows(tx, context),
|
|
1017
|
+
)
|
|
1018
|
+
result = wf.engine.resolve_problem(
|
|
1019
|
+
tx,
|
|
1020
|
+
docket["sys_id"],
|
|
1021
|
+
position["sys_id"],
|
|
1022
|
+
verb,
|
|
1023
|
+
actor,
|
|
1024
|
+
request_key,
|
|
1025
|
+
comment=comment,
|
|
1026
|
+
)
|
|
1027
|
+
if not result.ok:
|
|
1028
|
+
raise _Refusal(_reasons_status(result.reasons), result.reasons)
|
|
1029
|
+
self._wf_after_change(tx, context, docket["sys_id"])
|
|
1030
|
+
body = {"ok": True}
|
|
1031
|
+
if result.replayed:
|
|
1032
|
+
body["replayed"] = True
|
|
1033
|
+
context.response().set_body(body)
|
|
1034
|
+
|
|
1035
|
+
self._wf_guarded(tx, context, work)
|
|
1036
|
+
|
|
1037
|
+
# ── the Route designer ────────────────────────────────────────────────
|
|
1038
|
+
|
|
1039
|
+
def _wf_design_target(self, tx, context, payload, seats, action, key="route_id"):
|
|
1040
|
+
"""The route version ``payload[key]`` names, once ``action`` is
|
|
1041
|
+
allowed on its route: ``(row, relations)``. A missing version and one
|
|
1042
|
+
the person may not reach are refused alike."""
|
|
1043
|
+
wf = _workflow()
|
|
1044
|
+
try:
|
|
1045
|
+
row = wf.designer.route_row(tx, (payload or {}).get(key))
|
|
1046
|
+
except wf.WorkflowError:
|
|
1047
|
+
raise AccessError(authz.REFUSED) from None
|
|
1048
|
+
relations = self._wf_design_relations(tx, seats, row)
|
|
1049
|
+
self._wf_require_seat(
|
|
1050
|
+
tx,
|
|
1051
|
+
context,
|
|
1052
|
+
action,
|
|
1053
|
+
wf.access.design_resource(row["code"], row.get("entity"), relations),
|
|
1054
|
+
)
|
|
1055
|
+
return row, relations
|
|
1056
|
+
|
|
1057
|
+
def _wf_design_relations(self, tx, seats, row):
|
|
1058
|
+
wf = _workflow()
|
|
1059
|
+
owner_role = wf.designer.owner_role_of(
|
|
1060
|
+
tx, row, wf.designer.today_for(tx, row.get("entity"), _now())
|
|
1061
|
+
)
|
|
1062
|
+
return wf.access.route_owner_relations(
|
|
1063
|
+
seats, row["code"], owner_role, row.get("entity")
|
|
1064
|
+
)
|
|
1065
|
+
|
|
1066
|
+
def _wf_design_can(self, context, principal, row, relations):
|
|
1067
|
+
"""What the designer offers on ``row`` (display only: the server
|
|
1068
|
+
decides again; nothing is offered under masquerade)."""
|
|
1069
|
+
wf = _workflow()
|
|
1070
|
+
if self._wf_masquerading(principal):
|
|
1071
|
+
writes = publishes = False
|
|
1072
|
+
else:
|
|
1073
|
+
resource = wf.access.design_resource(
|
|
1074
|
+
row["code"], row.get("entity"), relations
|
|
1075
|
+
)
|
|
1076
|
+
edit = authz.decide(self, wf.access.DESIGNER_EDIT, resource, context)
|
|
1077
|
+
writes = edit.allowed and not edit.audit
|
|
1078
|
+
publishes = authz.decide(
|
|
1079
|
+
self, wf.access.DESIGNER_PUBLISH, resource, context
|
|
1080
|
+
).allowed
|
|
1081
|
+
draft = row.get("status") == wf.definitions.DRAFT
|
|
1082
|
+
return {
|
|
1083
|
+
"edit": writes and draft,
|
|
1084
|
+
"archive": writes and draft,
|
|
1085
|
+
"publish": publishes and draft,
|
|
1086
|
+
"create_draft": writes and row.get("status") != wf.definitions.ARCHIVED,
|
|
1087
|
+
"simulate": True,
|
|
1088
|
+
"test": True,
|
|
1089
|
+
}
|
|
1090
|
+
|
|
1091
|
+
def _wf_version_body(self, tx, context, principal, seats, route_id):
|
|
1092
|
+
wf = _workflow()
|
|
1093
|
+
row = wf.designer.route_row(tx, route_id)
|
|
1094
|
+
relations = self._wf_design_relations(tx, seats, row)
|
|
1095
|
+
return wf.designer.version(
|
|
1096
|
+
tx,
|
|
1097
|
+
row["sys_id"],
|
|
1098
|
+
can=self._wf_design_can(context, principal, row, relations),
|
|
1099
|
+
now=_now(),
|
|
1100
|
+
)
|
|
1101
|
+
|
|
1102
|
+
def OnActionWorkflowRoutes(self, tx, context):
|
|
1103
|
+
wf = _workflow()
|
|
1104
|
+
principal = self._wf_principal(context)
|
|
1105
|
+
seats = self._wf_seats(tx, context, principal)
|
|
1106
|
+
|
|
1107
|
+
def may_design(code, entity, owner_role):
|
|
1108
|
+
relations = wf.access.route_owner_relations(seats, code, owner_role, entity)
|
|
1109
|
+
decision = authz.decide(
|
|
1110
|
+
self,
|
|
1111
|
+
wf.access.DESIGNER,
|
|
1112
|
+
wf.access.design_resource(code, entity, relations),
|
|
1113
|
+
context,
|
|
1114
|
+
)
|
|
1115
|
+
return decision.allowed and not decision.audit
|
|
1116
|
+
|
|
1117
|
+
def work():
|
|
1118
|
+
body = wf.designer.list_routes(tx, may_design=may_design, now=_now())
|
|
1119
|
+
context.response().set_body(body)
|
|
1120
|
+
|
|
1121
|
+
self._wf_guarded(tx, context, work)
|
|
1122
|
+
|
|
1123
|
+
def OnActionWorkflowRoute(self, tx, context):
|
|
1124
|
+
wf = _workflow()
|
|
1125
|
+
payload = context.payload() or {}
|
|
1126
|
+
principal = self._wf_principal(context)
|
|
1127
|
+
seats = self._wf_seats(tx, context, principal)
|
|
1128
|
+
|
|
1129
|
+
def work():
|
|
1130
|
+
row, _relations = self._wf_design_target(
|
|
1131
|
+
tx, context, payload, seats, wf.access.DESIGNER
|
|
1132
|
+
)
|
|
1133
|
+
body = self._wf_version_body(tx, context, principal, seats, row["sys_id"])
|
|
1134
|
+
context.response().set_body({"version": body})
|
|
1135
|
+
|
|
1136
|
+
self._wf_guarded(tx, context, work)
|
|
1137
|
+
|
|
1138
|
+
def OnActionWorkflowRouteDraft(self, tx, context):
|
|
1139
|
+
wf = _workflow()
|
|
1140
|
+
payload = context.payload() or {}
|
|
1141
|
+
principal = self._wf_principal(context)
|
|
1142
|
+
seats = self._wf_seats(tx, context, principal)
|
|
1143
|
+
|
|
1144
|
+
def work():
|
|
1145
|
+
row, _relations = self._wf_design_target(
|
|
1146
|
+
tx, context, payload, seats, wf.access.DESIGNER_EDIT, key="from"
|
|
1147
|
+
)
|
|
1148
|
+
if row.get("status") == wf.definitions.ARCHIVED:
|
|
1149
|
+
raise _Refusal(
|
|
1150
|
+
CONFLICT,
|
|
1151
|
+
[
|
|
1152
|
+
{
|
|
1153
|
+
"code": "archived",
|
|
1154
|
+
"text": "An archived draft can't be copied.",
|
|
1155
|
+
}
|
|
1156
|
+
],
|
|
1157
|
+
)
|
|
1158
|
+
draft_id, replayed = wf.designer.create_draft(
|
|
1159
|
+
tx,
|
|
1160
|
+
row["sys_id"],
|
|
1161
|
+
by=seats.person,
|
|
1162
|
+
request_key=payload.get("request_key"),
|
|
1163
|
+
now=_now(),
|
|
1164
|
+
)
|
|
1165
|
+
body = self._wf_version_body(tx, context, principal, seats, draft_id)
|
|
1166
|
+
context.response().set_body(
|
|
1167
|
+
{"ok": True, "replayed": replayed, "version": body}
|
|
1168
|
+
)
|
|
1169
|
+
|
|
1170
|
+
self._wf_guarded(tx, context, work)
|
|
1171
|
+
|
|
1172
|
+
def OnActionWorkflowRouteEdit(self, tx, context):
|
|
1173
|
+
wf = _workflow()
|
|
1174
|
+
payload = context.payload() or {}
|
|
1175
|
+
principal = self._wf_principal(context)
|
|
1176
|
+
seats = self._wf_seats(tx, context, principal)
|
|
1177
|
+
|
|
1178
|
+
def work():
|
|
1179
|
+
row, _relations = self._wf_design_target(
|
|
1180
|
+
tx, context, payload, seats, wf.access.DESIGNER_EDIT
|
|
1181
|
+
)
|
|
1182
|
+
wf.designer.edit_draft(
|
|
1183
|
+
tx,
|
|
1184
|
+
row["sys_id"],
|
|
1185
|
+
payload.get("changes"),
|
|
1186
|
+
revision=payload.get("revision"),
|
|
1187
|
+
by=seats.person,
|
|
1188
|
+
now=_now(),
|
|
1189
|
+
)
|
|
1190
|
+
body = self._wf_version_body(tx, context, principal, seats, row["sys_id"])
|
|
1191
|
+
context.response().set_body({"ok": True, "version": body})
|
|
1192
|
+
|
|
1193
|
+
self._wf_guarded(tx, context, work)
|
|
1194
|
+
|
|
1195
|
+
def OnActionWorkflowRouteLint(self, tx, context):
|
|
1196
|
+
wf = _workflow()
|
|
1197
|
+
payload = context.payload() or {}
|
|
1198
|
+
principal = self._wf_principal(context)
|
|
1199
|
+
seats = self._wf_seats(tx, context, principal)
|
|
1200
|
+
|
|
1201
|
+
def work():
|
|
1202
|
+
row, _relations = self._wf_design_target(
|
|
1203
|
+
tx, context, payload, seats, wf.access.DESIGNER
|
|
1204
|
+
)
|
|
1205
|
+
context.response().set_body(
|
|
1206
|
+
{"lint": wf.designer.lint_version(tx, row["sys_id"], now=_now())}
|
|
1207
|
+
)
|
|
1208
|
+
|
|
1209
|
+
self._wf_guarded(tx, context, work)
|
|
1210
|
+
|
|
1211
|
+
def OnActionWorkflowRouteSimulate(self, tx, context):
|
|
1212
|
+
wf = _workflow()
|
|
1213
|
+
payload = context.payload() or {}
|
|
1214
|
+
principal = self._wf_principal(context)
|
|
1215
|
+
seats = self._wf_seats(tx, context, principal)
|
|
1216
|
+
|
|
1217
|
+
def work():
|
|
1218
|
+
row, _relations = self._wf_design_target(
|
|
1219
|
+
tx, context, payload, seats, wf.access.DESIGNER
|
|
1220
|
+
)
|
|
1221
|
+
body = wf.designer.simulate_version(
|
|
1222
|
+
tx, row["sys_id"], payload.get("sample"), now=_now()
|
|
1223
|
+
)
|
|
1224
|
+
context.response().set_body({"simulation": body})
|
|
1225
|
+
|
|
1226
|
+
self._wf_guarded(tx, context, work)
|
|
1227
|
+
|
|
1228
|
+
def OnActionWorkflowRouteTest(self, tx, context):
|
|
1229
|
+
wf = _workflow()
|
|
1230
|
+
payload = context.payload() or {}
|
|
1231
|
+
principal = self._wf_principal(context)
|
|
1232
|
+
seats = self._wf_seats(tx, context, principal)
|
|
1233
|
+
|
|
1234
|
+
def work():
|
|
1235
|
+
row, _relations = self._wf_design_target(
|
|
1236
|
+
tx, context, payload, seats, wf.access.DESIGNER
|
|
1237
|
+
)
|
|
1238
|
+
context.response().set_body(
|
|
1239
|
+
{"tests": wf.designer.test_version(tx, row["sys_id"], now=_now())}
|
|
1240
|
+
)
|
|
1241
|
+
|
|
1242
|
+
self._wf_guarded(tx, context, work)
|
|
1243
|
+
|
|
1244
|
+
def OnActionWorkflowRoutePublish(self, tx, context):
|
|
1245
|
+
wf = _workflow()
|
|
1246
|
+
payload = context.payload() or {}
|
|
1247
|
+
principal = self._wf_principal(context)
|
|
1248
|
+
seats = self._wf_seats(tx, context, principal)
|
|
1249
|
+
|
|
1250
|
+
def work():
|
|
1251
|
+
row, _relations = self._wf_design_target(
|
|
1252
|
+
tx, context, payload, seats, wf.access.DESIGNER
|
|
1253
|
+
)
|
|
1254
|
+
if self._wf_masquerading(principal):
|
|
1255
|
+
raise AccessError(authz.REFUSED)
|
|
1256
|
+
self._wf_design_target(
|
|
1257
|
+
tx, context, payload, seats, wf.access.DESIGNER_PUBLISH
|
|
1258
|
+
)
|
|
1259
|
+
request_key = self._wf_request_key(payload)
|
|
1260
|
+
if wf.designer.publish_replay(
|
|
1261
|
+
tx, row["sys_id"], by=seats.person, request_key=request_key
|
|
1262
|
+
):
|
|
1263
|
+
# this person's own publish again: answer as it is now
|
|
1264
|
+
body = self._wf_version_body(
|
|
1265
|
+
tx, context, principal, seats, row["sys_id"]
|
|
1266
|
+
)
|
|
1267
|
+
context.response().set_body(
|
|
1268
|
+
{"ok": True, "replayed": True, "in_flight": 0, "version": body}
|
|
1269
|
+
)
|
|
1270
|
+
return
|
|
1271
|
+
result = wf.designer.publish_draft(
|
|
1272
|
+
tx,
|
|
1273
|
+
row["sys_id"],
|
|
1274
|
+
effective_from=payload.get("effective_from"),
|
|
1275
|
+
comment=payload.get("comment"),
|
|
1276
|
+
by=seats.person,
|
|
1277
|
+
request_key=request_key,
|
|
1278
|
+
revision=payload.get("revision"),
|
|
1279
|
+
now=_now(),
|
|
1280
|
+
)
|
|
1281
|
+
body = self._wf_version_body(tx, context, principal, seats, row["sys_id"])
|
|
1282
|
+
context.response().set_body(
|
|
1283
|
+
{
|
|
1284
|
+
"ok": True,
|
|
1285
|
+
"replayed": result["replayed"],
|
|
1286
|
+
"in_flight": result["in_flight"],
|
|
1287
|
+
"version": body,
|
|
1288
|
+
}
|
|
1289
|
+
)
|
|
1290
|
+
|
|
1291
|
+
self._wf_guarded(tx, context, work)
|
|
1292
|
+
|
|
1293
|
+
def OnActionWorkflowRouteArchive(self, tx, context):
|
|
1294
|
+
wf = _workflow()
|
|
1295
|
+
payload = context.payload() or {}
|
|
1296
|
+
principal = self._wf_principal(context)
|
|
1297
|
+
seats = self._wf_seats(tx, context, principal)
|
|
1298
|
+
|
|
1299
|
+
def work():
|
|
1300
|
+
row, _relations = self._wf_design_target(
|
|
1301
|
+
tx, context, payload, seats, wf.access.DESIGNER_EDIT
|
|
1302
|
+
)
|
|
1303
|
+
replayed = wf.designer.archive_draft(
|
|
1304
|
+
tx, row["sys_id"], by=seats.person, now=_now()
|
|
1305
|
+
)
|
|
1306
|
+
body = self._wf_version_body(tx, context, principal, seats, row["sys_id"])
|
|
1307
|
+
context.response().set_body(
|
|
1308
|
+
{"ok": True, "replayed": replayed, "version": body}
|
|
1309
|
+
)
|
|
1310
|
+
|
|
1311
|
+
self._wf_guarded(tx, context, work)
|
|
1312
|
+
|
|
793
1313
|
# ── notices ────────────────────────────────────────────────────────────
|
|
794
1314
|
|
|
795
1315
|
def OnActionWorkflowNotices(self, tx, context):
|
velocity/aws/ops.py
CHANGED
|
@@ -379,6 +379,14 @@ def _overview(tx, hours, now):
|
|
|
379
379
|
}
|
|
380
380
|
|
|
381
381
|
|
|
382
|
+
def schedules(tx, *, now=None):
|
|
383
|
+
"""Every schedule in ``sys_task_triggers`` as :func:`shape_schedule`
|
|
384
|
+
(``health``: ok / never / overdue / disabled), by name; ``[]`` when the
|
|
385
|
+
table does not exist. What the dashboard's schedule section and the
|
|
386
|
+
workflow Operator console's scheduled jobs both read."""
|
|
387
|
+
return _schedules(tx, now or _utcnow())
|
|
388
|
+
|
|
389
|
+
|
|
382
390
|
def _schedules(tx, now):
|
|
383
391
|
if not _has(tx, TRIGGERS_TABLE):
|
|
384
392
|
return []
|
velocity/workflow/__init__.py
CHANGED
|
@@ -16,8 +16,11 @@ 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
18
|
:func:`register_person_label`, :func:`register_station_people`,
|
|
19
|
-
:func:`register_time_zone
|
|
20
|
-
|
|
19
|
+
:func:`register_time_zone`, :func:`register_heartbeats`,
|
|
20
|
+
:func:`register_role_label`). :mod:`.views` draws the Station Board, the
|
|
21
|
+
Flow map and the Dependency view; :mod:`.operator` the Operator console;
|
|
22
|
+
:mod:`.designer` the Route designer.
|
|
23
|
+
Nothing here names a business. See
|
|
21
24
|
docs/workflow.md.
|
|
22
25
|
"""
|
|
23
26
|
|
|
@@ -25,9 +28,11 @@ from . import (
|
|
|
25
28
|
access,
|
|
26
29
|
contract,
|
|
27
30
|
definitions,
|
|
31
|
+
designer,
|
|
28
32
|
engine,
|
|
29
33
|
hooks,
|
|
30
34
|
notices,
|
|
35
|
+
operator,
|
|
31
36
|
outbox,
|
|
32
37
|
points,
|
|
33
38
|
schema,
|
|
@@ -69,6 +74,7 @@ from .engine import ( # noqa: F401
|
|
|
69
74
|
place_hold,
|
|
70
75
|
prioritize,
|
|
71
76
|
release_hold,
|
|
77
|
+
resolve_problem,
|
|
72
78
|
resume_wait,
|
|
73
79
|
run_program,
|
|
74
80
|
run_route_tests,
|
|
@@ -90,10 +96,12 @@ from .hooks import ( # noqa: F401
|
|
|
90
96
|
register_calendar,
|
|
91
97
|
register_contact,
|
|
92
98
|
register_entity_scope,
|
|
99
|
+
register_heartbeats,
|
|
93
100
|
register_person_label,
|
|
94
101
|
register_person_seats,
|
|
95
102
|
register_program,
|
|
96
103
|
register_recipients,
|
|
104
|
+
register_role_label,
|
|
97
105
|
register_seats,
|
|
98
106
|
register_sheet,
|
|
99
107
|
register_station_people,
|
|
@@ -148,16 +156,19 @@ __all__ = [
|
|
|
148
156
|
"register_channel",
|
|
149
157
|
"register_contact",
|
|
150
158
|
"register_entity_scope",
|
|
159
|
+
"register_heartbeats",
|
|
151
160
|
"register_person_label",
|
|
152
161
|
"register_person_seats",
|
|
153
162
|
"register_program",
|
|
154
163
|
"register_recipients",
|
|
164
|
+
"register_role_label",
|
|
155
165
|
"register_seats",
|
|
156
166
|
"register_sheet",
|
|
157
167
|
"register_station_people",
|
|
158
168
|
"register_subject",
|
|
159
169
|
"register_time_zone",
|
|
160
170
|
"release_hold",
|
|
171
|
+
"resolve_problem",
|
|
161
172
|
"resume_wait",
|
|
162
173
|
"retire",
|
|
163
174
|
"route_from",
|