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 CHANGED
@@ -1,4 +1,4 @@
1
- __version__ = version = "0.5.1"
1
+ __version__ = version = "0.7.0"
2
2
 
3
3
  import importlib as _importlib
4
4
 
@@ -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 []
@@ -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`). :mod:`.views` draws the Station Board, the
20
- Flow map and the Dependency view. Nothing here names a business. See
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",