@opencrvs/toolkit 2.1.0-rc.90463d2 → 2.1.0-rc.9254c79
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.
- package/dist/application-config/index.js +200 -189
- package/dist/commons/api/router.d.ts +5 -24
- package/dist/commons/conditionals/conditionals.d.ts +3 -3
- package/dist/commons/conditionals/validate.d.ts +2 -1
- package/dist/commons/events/ActionConfig.d.ts +21 -0
- package/dist/commons/events/ActionDocument.d.ts +1 -7
- package/dist/commons/events/ActionStatus.d.ts +14 -0
- package/dist/commons/events/AdvancedSearchConfig.d.ts +6 -0
- package/dist/commons/events/CountryConfigQueryInput.d.ts +18 -0
- package/dist/commons/events/EventIndex.d.ts +5 -24
- package/dist/commons/events/EventMetadata.d.ts +1 -0
- package/dist/commons/events/FieldConfig.d.ts +5 -0
- package/dist/commons/events/FieldTypeMapping.d.ts +19 -19
- package/dist/commons/events/Flag.d.ts +48 -0
- package/dist/commons/events/WorkqueueConfig.d.ts +27 -12
- package/dist/commons/events/locations.d.ts +3 -93
- package/dist/commons/events/mocks.test.utils.d.ts +2 -16
- package/dist/commons/events/test.utils.d.ts +5 -5
- package/dist/conditionals/index.js +303 -55
- package/dist/events/index.js +3255 -3222
- package/dist/notification/index.js +1477 -907
- package/dist/scopes/index.d.ts +250 -0
- package/dist/scopes/index.js +304 -55
- package/opencrvs-toolkit-2.1.0-rc.9254c79.tgz +0 -0
- package/package.json +1 -1
- package/opencrvs-toolkit-2.1.0-rc.90463d2.tgz +0 -0
|
@@ -47,14 +47,14 @@ function joinUrl(base, path) {
|
|
|
47
47
|
}
|
|
48
48
|
|
|
49
49
|
// ../commons/src/events/AuditLog.ts
|
|
50
|
-
var
|
|
50
|
+
var z8 = __toESM(require("zod/v4"));
|
|
51
51
|
|
|
52
52
|
// ../commons/src/authentication.ts
|
|
53
53
|
var import_jwt_decode = __toESM(require("jwt-decode"));
|
|
54
|
-
var
|
|
54
|
+
var z7 = __toESM(require("zod/v4"));
|
|
55
55
|
|
|
56
56
|
// ../commons/src/scopes.ts
|
|
57
|
-
var
|
|
57
|
+
var z6 = __toESM(require("zod/v4"));
|
|
58
58
|
var qs = __toESM(require("qs"));
|
|
59
59
|
|
|
60
60
|
// ../commons/src/uuid.ts
|
|
@@ -65,12 +65,264 @@ function getUUID() {
|
|
|
65
65
|
return (0, import_uuid.v4)();
|
|
66
66
|
}
|
|
67
67
|
|
|
68
|
+
// ../commons/src/events/ActionType.ts
|
|
69
|
+
var z2 = __toESM(require("zod/v4"));
|
|
70
|
+
var ActionType = {
|
|
71
|
+
// Pre-declaration actions
|
|
72
|
+
DELETE: "DELETE",
|
|
73
|
+
CREATE: "CREATE",
|
|
74
|
+
NOTIFY: "NOTIFY",
|
|
75
|
+
// Declaration actions
|
|
76
|
+
DECLARE: "DECLARE",
|
|
77
|
+
REGISTER: "REGISTER",
|
|
78
|
+
EDIT: "EDIT",
|
|
79
|
+
// Declaration system actions. Non-configurable.
|
|
80
|
+
DUPLICATE_DETECTED: "DUPLICATE_DETECTED",
|
|
81
|
+
REJECT: "REJECT",
|
|
82
|
+
// REJECT_DECLARATION
|
|
83
|
+
MARK_AS_DUPLICATE: "MARK_AS_DUPLICATE",
|
|
84
|
+
MARK_AS_NOT_DUPLICATE: "MARK_AS_NOT_DUPLICATE",
|
|
85
|
+
ARCHIVE: "ARCHIVE",
|
|
86
|
+
UNARCHIVE: "UNARCHIVE",
|
|
87
|
+
// Record actions
|
|
88
|
+
PRINT_CERTIFICATE: "PRINT_CERTIFICATE",
|
|
89
|
+
REQUEST_CORRECTION: "REQUEST_CORRECTION",
|
|
90
|
+
REJECT_CORRECTION: "REJECT_CORRECTION",
|
|
91
|
+
APPROVE_CORRECTION: "APPROVE_CORRECTION",
|
|
92
|
+
// General actions
|
|
93
|
+
READ: "READ",
|
|
94
|
+
ASSIGN: "ASSIGN",
|
|
95
|
+
UNASSIGN: "UNASSIGN",
|
|
96
|
+
// Custom action
|
|
97
|
+
CUSTOM: "CUSTOM"
|
|
98
|
+
};
|
|
99
|
+
var ConfirmableActions = [
|
|
100
|
+
ActionType.NOTIFY,
|
|
101
|
+
ActionType.DECLARE,
|
|
102
|
+
ActionType.EDIT,
|
|
103
|
+
ActionType.REGISTER,
|
|
104
|
+
ActionType.REJECT,
|
|
105
|
+
ActionType.ARCHIVE,
|
|
106
|
+
ActionType.UNARCHIVE,
|
|
107
|
+
ActionType.PRINT_CERTIFICATE,
|
|
108
|
+
ActionType.REQUEST_CORRECTION,
|
|
109
|
+
ActionType.APPROVE_CORRECTION,
|
|
110
|
+
ActionType.REJECT_CORRECTION,
|
|
111
|
+
ActionType.CUSTOM
|
|
112
|
+
];
|
|
113
|
+
var ActionTypes = z2.enum([
|
|
114
|
+
"DELETE",
|
|
115
|
+
"CREATE",
|
|
116
|
+
"NOTIFY",
|
|
117
|
+
"DECLARE",
|
|
118
|
+
"EDIT",
|
|
119
|
+
"REGISTER",
|
|
120
|
+
"DUPLICATE_DETECTED",
|
|
121
|
+
"REJECT",
|
|
122
|
+
"MARK_AS_DUPLICATE",
|
|
123
|
+
"MARK_AS_NOT_DUPLICATE",
|
|
124
|
+
"ARCHIVE",
|
|
125
|
+
"UNARCHIVE",
|
|
126
|
+
"PRINT_CERTIFICATE",
|
|
127
|
+
"REQUEST_CORRECTION",
|
|
128
|
+
"REJECT_CORRECTION",
|
|
129
|
+
"APPROVE_CORRECTION",
|
|
130
|
+
"READ",
|
|
131
|
+
"ASSIGN",
|
|
132
|
+
"UNASSIGN",
|
|
133
|
+
"CUSTOM"
|
|
134
|
+
]);
|
|
135
|
+
var ClientSpecificAction = {
|
|
136
|
+
REVIEW_CORRECTION_REQUEST: "REVIEW_CORRECTION_REQUEST"
|
|
137
|
+
};
|
|
138
|
+
var declarationActionValues = [
|
|
139
|
+
ActionTypes.enum.DECLARE,
|
|
140
|
+
ActionTypes.enum.EDIT,
|
|
141
|
+
ActionTypes.enum.REGISTER,
|
|
142
|
+
ActionTypes.enum.NOTIFY,
|
|
143
|
+
ActionTypes.enum.DUPLICATE_DETECTED
|
|
144
|
+
];
|
|
145
|
+
var DeclarationActions = ActionTypes.extract(declarationActionValues);
|
|
146
|
+
var declarationUpdateActionValues = [
|
|
147
|
+
...declarationActionValues,
|
|
148
|
+
ActionTypes.enum.REQUEST_CORRECTION
|
|
149
|
+
];
|
|
150
|
+
var DeclarationUpdateActions = ActionTypes.extract(
|
|
151
|
+
declarationUpdateActionValues
|
|
152
|
+
);
|
|
153
|
+
var annotationActions = ActionTypes.exclude(declarationActionValues);
|
|
154
|
+
var writeActions = ActionTypes.exclude([
|
|
155
|
+
ActionType.CREATE,
|
|
156
|
+
ActionType.READ,
|
|
157
|
+
ActionType.ASSIGN,
|
|
158
|
+
ActionType.UNASSIGN
|
|
159
|
+
]);
|
|
160
|
+
var WorkqueueActionType = ActionTypes.extract([
|
|
161
|
+
ActionType.READ,
|
|
162
|
+
ActionType.DELETE,
|
|
163
|
+
ActionType.DECLARE,
|
|
164
|
+
ActionType.REGISTER,
|
|
165
|
+
ActionType.EDIT,
|
|
166
|
+
ActionType.REJECT,
|
|
167
|
+
ActionType.MARK_AS_DUPLICATE,
|
|
168
|
+
ActionType.ARCHIVE,
|
|
169
|
+
ActionType.UNARCHIVE,
|
|
170
|
+
ActionType.PRINT_CERTIFICATE,
|
|
171
|
+
ActionType.REQUEST_CORRECTION
|
|
172
|
+
]);
|
|
173
|
+
var META_ACTIONS = [
|
|
174
|
+
ActionType.ASSIGN,
|
|
175
|
+
ActionType.UNASSIGN,
|
|
176
|
+
ActionType.READ
|
|
177
|
+
];
|
|
178
|
+
function isMetaAction(actionType) {
|
|
179
|
+
return META_ACTIONS.includes(actionType);
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
// ../commons/src/events/ActionStatus.ts
|
|
183
|
+
var ActionStatus = {
|
|
184
|
+
Requested: "Requested",
|
|
185
|
+
Accepted: "Accepted",
|
|
186
|
+
Rejected: "Rejected"
|
|
187
|
+
};
|
|
188
|
+
|
|
189
|
+
// ../commons/src/events/Flag.ts
|
|
190
|
+
var z5 = __toESM(require("zod/v4"));
|
|
191
|
+
|
|
192
|
+
// ../commons/src/events/TranslationConfig.ts
|
|
193
|
+
var z3 = __toESM(require("zod/v4"));
|
|
194
|
+
var TranslationConfig = z3.object({
|
|
195
|
+
id: z3.string().describe(
|
|
196
|
+
"The identifier of the translation referred in translation CSV files"
|
|
197
|
+
),
|
|
198
|
+
defaultMessage: z3.string().describe("Default translation message"),
|
|
199
|
+
description: z3.string().describe(
|
|
200
|
+
"Describe the translation for a translator to be able to identify it."
|
|
201
|
+
)
|
|
202
|
+
}).meta({
|
|
203
|
+
description: "Translation configuration",
|
|
204
|
+
id: "TranslationConfig"
|
|
205
|
+
});
|
|
206
|
+
|
|
207
|
+
// ../commons/src/events/Conditional.ts
|
|
208
|
+
var z4 = __toESM(require("zod/v4"));
|
|
209
|
+
var Conditional = z4.any().describe("JSONSchema").meta({
|
|
210
|
+
description: "JSON schema conditional configuration",
|
|
211
|
+
id: "Conditional"
|
|
212
|
+
});
|
|
213
|
+
var ConditionalType = {
|
|
214
|
+
SHOW: "SHOW",
|
|
215
|
+
ENABLE: "ENABLE",
|
|
216
|
+
DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
|
|
217
|
+
};
|
|
218
|
+
var ShowConditional = z4.object({
|
|
219
|
+
type: z4.literal(ConditionalType.SHOW),
|
|
220
|
+
conditional: Conditional
|
|
221
|
+
}).describe(
|
|
222
|
+
"If 'SHOW' conditional is defined, the component is shown to the user only if the condition is met"
|
|
223
|
+
);
|
|
224
|
+
var EnableConditional = z4.object({
|
|
225
|
+
type: z4.literal(ConditionalType.ENABLE),
|
|
226
|
+
conditional: Conditional
|
|
227
|
+
}).describe(
|
|
228
|
+
"If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
|
|
229
|
+
);
|
|
230
|
+
var ActionConditional = z4.discriminatedUnion("type", [
|
|
231
|
+
// Action can be shown / hidden
|
|
232
|
+
ShowConditional,
|
|
233
|
+
// Action can be shown to the user in the list but as disabled
|
|
234
|
+
EnableConditional
|
|
235
|
+
]).meta({
|
|
236
|
+
id: "ActionConditional",
|
|
237
|
+
description: "Conditional gating whether an action is shown (SHOW) or enabled (ENABLE). When omitted from an action, the action is shown and enabled for everyone."
|
|
238
|
+
});
|
|
239
|
+
var DisplayOnReviewConditional = z4.object({
|
|
240
|
+
type: z4.literal(ConditionalType.DISPLAY_ON_REVIEW),
|
|
241
|
+
conditional: Conditional
|
|
242
|
+
}).describe(
|
|
243
|
+
"If 'DISPLAY_ON_REVIEW' conditional is defined, the component is shown on the review page only if both the 'DISPLAY_ON_REVIEW' and 'SHOW' conditions are met. This should only be used for fields within declaration forms, as they are the only ones with review pages."
|
|
244
|
+
);
|
|
245
|
+
var FieldConditional = z4.discriminatedUnion("type", [
|
|
246
|
+
// Field input can be shown / hidden
|
|
247
|
+
ShowConditional,
|
|
248
|
+
// Field input can be shown to the user but as disabled
|
|
249
|
+
EnableConditional,
|
|
250
|
+
// Field output can be shown / hidden on the review page
|
|
251
|
+
DisplayOnReviewConditional
|
|
252
|
+
]).meta({
|
|
253
|
+
id: "FieldConditional",
|
|
254
|
+
description: "Conditional gating whether a form field is shown (SHOW), enabled (ENABLE), or displayed on the review page (DISPLAY_ON_REVIEW). When omitted, the field is shown and enabled for everyone, and is displayed on review whenever it has a value."
|
|
255
|
+
});
|
|
256
|
+
|
|
257
|
+
// ../commons/src/events/Flag.ts
|
|
258
|
+
var InherentFlags = {
|
|
259
|
+
INCOMPLETE: "incomplete",
|
|
260
|
+
REJECTED: "rejected",
|
|
261
|
+
CORRECTION_REQUESTED: "correction-requested",
|
|
262
|
+
POTENTIAL_DUPLICATE: "potential-duplicate",
|
|
263
|
+
/**
|
|
264
|
+
* This flag is set by the Edit-action and removed after the declaration or registration.
|
|
265
|
+
* A record should never stay with the EDIT_IN_PROGRESS flag, since it should always be declared or registered right after.
|
|
266
|
+
*
|
|
267
|
+
* We only use this flag to determine that a NOTIFY, DECLARE or REGISTER action is allowed next.
|
|
268
|
+
*/
|
|
269
|
+
EDIT_IN_PROGRESS: "edit-in-progress",
|
|
270
|
+
SEALED: "sealed"
|
|
271
|
+
};
|
|
272
|
+
var actionFlagPattern;
|
|
273
|
+
function getActionFlagPattern() {
|
|
274
|
+
actionFlagPattern ??= new RegExp(
|
|
275
|
+
`^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
|
|
276
|
+
ActionStatus
|
|
277
|
+
).join("|").toLowerCase()})$`
|
|
278
|
+
);
|
|
279
|
+
return actionFlagPattern;
|
|
280
|
+
}
|
|
281
|
+
var ActionFlag = z5.string().refine((value) => getActionFlagPattern().test(value), {
|
|
282
|
+
message: "Flag must be in the format ActionType:ActionStatus (lowerCase)"
|
|
283
|
+
});
|
|
284
|
+
var CustomFlag = z5.string().refine((val) => !Object.values(InherentFlags).includes(val), {
|
|
285
|
+
message: `Custom flag cannot be one of the inherent flags: ${Object.values(
|
|
286
|
+
InherentFlags
|
|
287
|
+
).join(", ")}`
|
|
288
|
+
}).refine((val) => !ActionFlag.safeParse(val).success, {
|
|
289
|
+
message: "Custom flag cannot match the ActionFlag pattern (ActionType:ActionStatus)."
|
|
290
|
+
}).describe("Custom flag identifier defined by the country config.");
|
|
291
|
+
var Flag = ActionFlag.or(z5.enum(InherentFlags)).or(CustomFlag);
|
|
292
|
+
var ContainsFlags = z5.object({
|
|
293
|
+
anyOf: z5.array(Flag).optional(),
|
|
294
|
+
noneOf: z5.array(Flag).optional(),
|
|
295
|
+
allOf: z5.array(Flag).optional()
|
|
296
|
+
}).meta({
|
|
297
|
+
id: "ContainsFlags"
|
|
298
|
+
});
|
|
299
|
+
var FlagConfig = z5.object({
|
|
300
|
+
id: CustomFlag,
|
|
301
|
+
requiresAction: z5.boolean().describe(
|
|
302
|
+
"Indicates if this flag expects an action to be performed to be cleared."
|
|
303
|
+
),
|
|
304
|
+
label: TranslationConfig.describe("Human readable label of the flag.")
|
|
305
|
+
}).meta({
|
|
306
|
+
id: "FlagConfig",
|
|
307
|
+
description: "Configuration for a custom flag that can be added to or removed from records by event actions."
|
|
308
|
+
});
|
|
309
|
+
var ActionFlagConfig = z5.object({
|
|
310
|
+
id: Flag,
|
|
311
|
+
operation: z5.enum(["add", "remove"]).describe("Operation to perform on the flag."),
|
|
312
|
+
conditional: Conditional.optional().describe(
|
|
313
|
+
"When conditional is met, the operation is performed on the flag. If not provided, the operation is performed unconditionally."
|
|
314
|
+
)
|
|
315
|
+
}).meta({
|
|
316
|
+
id: "ActionFlagConfig",
|
|
317
|
+
description: "Add or remove operation applied to a flag when the parent action is accepted. Optionally gated by a conditional."
|
|
318
|
+
});
|
|
319
|
+
|
|
68
320
|
// ../commons/src/scopes.ts
|
|
69
|
-
var JurisdictionFilter =
|
|
321
|
+
var JurisdictionFilter = z6.enum(["administrativeArea", "location", "all"]).describe(
|
|
70
322
|
"Filters based on user jurisdiction relative to their office location in hierarchy."
|
|
71
323
|
);
|
|
72
|
-
var UserFilter =
|
|
73
|
-
var RecordScopeTypeV2 =
|
|
324
|
+
var UserFilter = z6.enum(["user"]).describe("Filters based on the user. Limits to self.");
|
|
325
|
+
var RecordScopeTypeV2 = z6.enum([
|
|
74
326
|
"record.search",
|
|
75
327
|
"record.create",
|
|
76
328
|
"record.read",
|
|
@@ -88,7 +340,7 @@ var RecordScopeTypeV2 = z2.enum([
|
|
|
88
340
|
"record.unassign-others",
|
|
89
341
|
"record.custom-action"
|
|
90
342
|
]);
|
|
91
|
-
var PlainScopeType =
|
|
343
|
+
var PlainScopeType = z6.enum([
|
|
92
344
|
// Misc. system scopes
|
|
93
345
|
"bypassratelimit",
|
|
94
346
|
"record.reindex",
|
|
@@ -107,15 +359,15 @@ var PlainScopeType = z2.enum([
|
|
|
107
359
|
"record.confirm-registration",
|
|
108
360
|
"record.reject-registration"
|
|
109
361
|
]);
|
|
110
|
-
var scopeByEvent =
|
|
362
|
+
var scopeByEvent = z6.preprocess(
|
|
111
363
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
112
|
-
|
|
364
|
+
z6.array(z6.string()).optional()
|
|
113
365
|
).describe("Event type, e.g. birth, death");
|
|
114
|
-
var userRole =
|
|
366
|
+
var userRole = z6.preprocess(
|
|
115
367
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
116
|
-
|
|
368
|
+
z6.array(z6.string()).optional()
|
|
117
369
|
).describe("User role, e.g. admin, field agent");
|
|
118
|
-
var scopeOptionsPlaceEvent =
|
|
370
|
+
var scopeOptionsPlaceEvent = z6.object({
|
|
119
371
|
event: scopeByEvent,
|
|
120
372
|
placeOfEvent: JurisdictionFilter.optional()
|
|
121
373
|
}).describe("Options applicable to all record scopes.");
|
|
@@ -127,36 +379,37 @@ var scopeOptionsDeclaredOrNotified = scopeOptionsPlaceEvent.extend({
|
|
|
127
379
|
}).describe("Options applicable to actions that may take place after DECLARE");
|
|
128
380
|
var AllRecordScopeOptions = scopeOptionsDeclaredOrNotified.extend({
|
|
129
381
|
registeredIn: JurisdictionFilter.optional(),
|
|
130
|
-
registeredBy: UserFilter.optional()
|
|
382
|
+
registeredBy: UserFilter.optional(),
|
|
383
|
+
flags: ContainsFlags.optional()
|
|
131
384
|
}).describe(
|
|
132
385
|
"Options applicable to actions that may take place after REGISTER, with full filtering capabilities."
|
|
133
386
|
);
|
|
134
387
|
var CustomActionScopeOptions = AllRecordScopeOptions.extend({
|
|
135
|
-
customActionTypes:
|
|
388
|
+
customActionTypes: z6.preprocess(
|
|
136
389
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
137
|
-
|
|
390
|
+
z6.array(z6.string()).optional()
|
|
138
391
|
).describe("Allowed custom action types")
|
|
139
392
|
});
|
|
140
|
-
var AccessLevelOptions =
|
|
393
|
+
var AccessLevelOptions = z6.object({
|
|
141
394
|
accessLevel: JurisdictionFilter.optional()
|
|
142
395
|
});
|
|
143
396
|
var AllUserScopeOptions = AccessLevelOptions.extend({
|
|
144
397
|
role: userRole.optional()
|
|
145
398
|
});
|
|
146
|
-
var WorkqueueOrDashboardOptions =
|
|
147
|
-
ids:
|
|
399
|
+
var WorkqueueOrDashboardOptions = z6.object({
|
|
400
|
+
ids: z6.preprocess(
|
|
148
401
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
149
|
-
|
|
402
|
+
z6.array(z6.string())
|
|
150
403
|
).describe("Must contain a list of workqueue or dashboard ids.")
|
|
151
404
|
});
|
|
152
|
-
var AllScopeOptions =
|
|
405
|
+
var AllScopeOptions = z6.object({
|
|
153
406
|
...AllRecordScopeOptions.shape,
|
|
154
407
|
...AccessLevelOptions.shape,
|
|
155
408
|
...AllUserScopeOptions.shape,
|
|
156
409
|
...WorkqueueOrDashboardOptions.shape
|
|
157
410
|
});
|
|
158
411
|
var ScopeOptionKey = AllScopeOptions.keyof();
|
|
159
|
-
var ResolvedScopeOptionsPlaceEvent =
|
|
412
|
+
var ResolvedScopeOptionsPlaceEvent = z6.object({
|
|
160
413
|
event: scopeByEvent,
|
|
161
414
|
placeOfEvent: UUID.nullish()
|
|
162
415
|
}).describe(
|
|
@@ -164,15 +417,16 @@ var ResolvedScopeOptionsPlaceEvent = z2.object({
|
|
|
164
417
|
);
|
|
165
418
|
var ResolvedScopeOptionsDeclared = ResolvedScopeOptionsPlaceEvent.extend({
|
|
166
419
|
notifiedIn: UUID.nullish(),
|
|
167
|
-
notifiedBy:
|
|
420
|
+
notifiedBy: z6.string().optional(),
|
|
168
421
|
declaredIn: UUID.nullish(),
|
|
169
|
-
declaredBy:
|
|
422
|
+
declaredBy: z6.string().optional()
|
|
170
423
|
}).describe(
|
|
171
424
|
"Resolved options applicable to actions that may take place after DECLARE, with location ID and user ID instead of filters."
|
|
172
425
|
);
|
|
173
426
|
var ResolvedScopeOptionsFull = ResolvedScopeOptionsDeclared.extend({
|
|
174
427
|
registeredIn: UUID.nullish(),
|
|
175
|
-
registeredBy:
|
|
428
|
+
registeredBy: z6.string().optional(),
|
|
429
|
+
flags: ContainsFlags.optional()
|
|
176
430
|
}).describe(
|
|
177
431
|
"Resolved options applicable to actions that may take place after REGISTER, with full filtering capabilities and location/user IDs instead of filters."
|
|
178
432
|
);
|
|
@@ -197,38 +451,38 @@ var ScopesWithFullOptions = RecordScopeTypeV2.extract([
|
|
|
197
451
|
"record.unassign-others"
|
|
198
452
|
]);
|
|
199
453
|
var ScopeOptionsPrintCertifiedCopies = AllRecordScopeOptions.extend({
|
|
200
|
-
templates:
|
|
454
|
+
templates: z6.preprocess(
|
|
201
455
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
202
|
-
|
|
456
|
+
z6.array(z6.string()).optional()
|
|
203
457
|
).describe(
|
|
204
458
|
"Template IDs for certified copies. Controls which certificate templates are returned to the client via the config service. Certificate printing is a client-side operation \u2014 this option is not validated when the printCertificate action is submitted."
|
|
205
459
|
)
|
|
206
460
|
});
|
|
207
|
-
var RecordScopeV2 =
|
|
208
|
-
|
|
461
|
+
var RecordScopeV2 = z6.discriminatedUnion("type", [
|
|
462
|
+
z6.object({
|
|
209
463
|
type: ScopesWithPlaceEventOptions,
|
|
210
464
|
options: scopeOptionsPlaceEvent.optional()
|
|
211
465
|
}),
|
|
212
|
-
|
|
466
|
+
z6.object({
|
|
213
467
|
type: ScopesWithDeclaredOptions,
|
|
214
468
|
options: scopeOptionsDeclaredOrNotified.optional()
|
|
215
469
|
}),
|
|
216
|
-
|
|
470
|
+
z6.object({
|
|
217
471
|
type: ScopesWithFullOptions,
|
|
218
472
|
options: AllRecordScopeOptions.optional()
|
|
219
473
|
}),
|
|
220
|
-
|
|
221
|
-
type:
|
|
474
|
+
z6.object({
|
|
475
|
+
type: z6.literal("record.custom-action"),
|
|
222
476
|
options: CustomActionScopeOptions.optional()
|
|
223
477
|
}),
|
|
224
|
-
|
|
225
|
-
type:
|
|
478
|
+
z6.object({
|
|
479
|
+
type: z6.literal("record.print-certified-copies"),
|
|
226
480
|
options: ScopeOptionsPrintCertifiedCopies.optional()
|
|
227
481
|
})
|
|
228
482
|
]).describe(
|
|
229
483
|
"Scopes used to check user's permission to perform actions on a record."
|
|
230
484
|
);
|
|
231
|
-
var SystemScopeType =
|
|
485
|
+
var SystemScopeType = z6.enum([
|
|
232
486
|
"organisation.read-locations",
|
|
233
487
|
"user.read",
|
|
234
488
|
"user.create",
|
|
@@ -242,61 +496,61 @@ var UserScopeType = SystemScopeType.extract([
|
|
|
242
496
|
"user.search"
|
|
243
497
|
]);
|
|
244
498
|
var ScopesWithRoleOption = UserScopeType.extract(["user.edit", "user.create"]);
|
|
245
|
-
var UserScopeV2 =
|
|
246
|
-
|
|
499
|
+
var UserScopeV2 = z6.discriminatedUnion("type", [
|
|
500
|
+
z6.object({
|
|
247
501
|
type: ScopesWithRoleOption,
|
|
248
502
|
options: AllUserScopeOptions.optional()
|
|
249
503
|
}),
|
|
250
|
-
|
|
504
|
+
z6.object({
|
|
251
505
|
type: UserScopeType.extract(["user.read", "user.search"]),
|
|
252
506
|
options: AccessLevelOptions.optional()
|
|
253
507
|
})
|
|
254
508
|
]);
|
|
255
|
-
var ResolvedRecordScopeV2 =
|
|
256
|
-
|
|
509
|
+
var ResolvedRecordScopeV2 = z6.discriminatedUnion("type", [
|
|
510
|
+
z6.object({
|
|
257
511
|
type: ScopesWithPlaceEventOptions,
|
|
258
512
|
options: ResolvedScopeOptionsPlaceEvent.optional()
|
|
259
513
|
}),
|
|
260
|
-
|
|
514
|
+
z6.object({
|
|
261
515
|
type: ScopesWithDeclaredOptions,
|
|
262
516
|
options: ResolvedScopeOptionsDeclared.optional()
|
|
263
517
|
}),
|
|
264
|
-
|
|
518
|
+
z6.object({
|
|
265
519
|
type: ScopesWithFullOptions,
|
|
266
520
|
options: ResolvedScopeOptionsFull.optional()
|
|
267
521
|
}),
|
|
268
|
-
|
|
269
|
-
type:
|
|
522
|
+
z6.object({
|
|
523
|
+
type: z6.literal("record.print-certified-copies"),
|
|
270
524
|
options: ResolvedScopeOptionsFull.extend({
|
|
271
|
-
templates:
|
|
525
|
+
templates: z6.array(z6.string()).optional()
|
|
272
526
|
}).optional()
|
|
273
527
|
})
|
|
274
528
|
]).describe("Resolved scope with location/user IDs instead of filters.");
|
|
275
|
-
var Scope =
|
|
276
|
-
|
|
529
|
+
var Scope = z6.discriminatedUnion("type", [
|
|
530
|
+
z6.object({ type: PlainScopeType }),
|
|
277
531
|
...RecordScopeV2.options,
|
|
278
532
|
...UserScopeV2.options,
|
|
279
|
-
|
|
280
|
-
type:
|
|
533
|
+
z6.object({
|
|
534
|
+
type: z6.literal("organisation.read-locations"),
|
|
281
535
|
options: AccessLevelOptions.optional()
|
|
282
536
|
}),
|
|
283
|
-
|
|
284
|
-
type:
|
|
537
|
+
z6.object({
|
|
538
|
+
type: z6.literal("workqueue"),
|
|
285
539
|
options: WorkqueueOrDashboardOptions
|
|
286
540
|
}),
|
|
287
|
-
|
|
288
|
-
type:
|
|
541
|
+
z6.object({
|
|
542
|
+
type: z6.literal("dashboard.view"),
|
|
289
543
|
options: WorkqueueOrDashboardOptions
|
|
290
544
|
})
|
|
291
545
|
]);
|
|
292
|
-
var ScopeType =
|
|
546
|
+
var ScopeType = z6.enum([
|
|
293
547
|
...SystemScopeType.options,
|
|
294
548
|
...RecordScopeTypeV2.options,
|
|
295
549
|
...PlainScopeType.options,
|
|
296
550
|
"workqueue",
|
|
297
551
|
"dashboard.view"
|
|
298
552
|
]);
|
|
299
|
-
var EncodedScope =
|
|
553
|
+
var EncodedScope = z6.string().brand("EncodedScope");
|
|
300
554
|
var DEFAULT_SCOPE_OPTIONS = {
|
|
301
555
|
placeOfEvent: JurisdictionFilter.enum.all,
|
|
302
556
|
accessLevel: JurisdictionFilter.enum.all,
|
|
@@ -306,162 +560,51 @@ var DEFAULT_SCOPE_OPTIONS = {
|
|
|
306
560
|
};
|
|
307
561
|
|
|
308
562
|
// ../commons/src/authentication.ts
|
|
309
|
-
var TokenUserType =
|
|
310
|
-
var TokenWithBearer =
|
|
311
|
-
|
|
312
|
-
// ../commons/src/events/ActionType.ts
|
|
313
|
-
var z4 = __toESM(require("zod/v4"));
|
|
314
|
-
var ActionType = {
|
|
315
|
-
// Pre-declaration actions
|
|
316
|
-
DELETE: "DELETE",
|
|
317
|
-
CREATE: "CREATE",
|
|
318
|
-
NOTIFY: "NOTIFY",
|
|
319
|
-
// Declaration actions
|
|
320
|
-
DECLARE: "DECLARE",
|
|
321
|
-
REGISTER: "REGISTER",
|
|
322
|
-
EDIT: "EDIT",
|
|
323
|
-
// Declaration system actions. Non-configurable.
|
|
324
|
-
DUPLICATE_DETECTED: "DUPLICATE_DETECTED",
|
|
325
|
-
REJECT: "REJECT",
|
|
326
|
-
// REJECT_DECLARATION
|
|
327
|
-
MARK_AS_DUPLICATE: "MARK_AS_DUPLICATE",
|
|
328
|
-
MARK_AS_NOT_DUPLICATE: "MARK_AS_NOT_DUPLICATE",
|
|
329
|
-
ARCHIVE: "ARCHIVE",
|
|
330
|
-
UNARCHIVE: "UNARCHIVE",
|
|
331
|
-
// Record actions
|
|
332
|
-
PRINT_CERTIFICATE: "PRINT_CERTIFICATE",
|
|
333
|
-
REQUEST_CORRECTION: "REQUEST_CORRECTION",
|
|
334
|
-
REJECT_CORRECTION: "REJECT_CORRECTION",
|
|
335
|
-
APPROVE_CORRECTION: "APPROVE_CORRECTION",
|
|
336
|
-
// General actions
|
|
337
|
-
READ: "READ",
|
|
338
|
-
ASSIGN: "ASSIGN",
|
|
339
|
-
UNASSIGN: "UNASSIGN",
|
|
340
|
-
// Custom action
|
|
341
|
-
CUSTOM: "CUSTOM"
|
|
342
|
-
};
|
|
343
|
-
var ConfirmableActions = [
|
|
344
|
-
ActionType.NOTIFY,
|
|
345
|
-
ActionType.DECLARE,
|
|
346
|
-
ActionType.EDIT,
|
|
347
|
-
ActionType.REGISTER,
|
|
348
|
-
ActionType.REJECT,
|
|
349
|
-
ActionType.ARCHIVE,
|
|
350
|
-
ActionType.UNARCHIVE,
|
|
351
|
-
ActionType.PRINT_CERTIFICATE,
|
|
352
|
-
ActionType.REQUEST_CORRECTION,
|
|
353
|
-
ActionType.APPROVE_CORRECTION,
|
|
354
|
-
ActionType.REJECT_CORRECTION,
|
|
355
|
-
ActionType.CUSTOM
|
|
356
|
-
];
|
|
357
|
-
var ActionTypes = z4.enum([
|
|
358
|
-
"DELETE",
|
|
359
|
-
"CREATE",
|
|
360
|
-
"NOTIFY",
|
|
361
|
-
"DECLARE",
|
|
362
|
-
"EDIT",
|
|
363
|
-
"REGISTER",
|
|
364
|
-
"DUPLICATE_DETECTED",
|
|
365
|
-
"REJECT",
|
|
366
|
-
"MARK_AS_DUPLICATE",
|
|
367
|
-
"MARK_AS_NOT_DUPLICATE",
|
|
368
|
-
"ARCHIVE",
|
|
369
|
-
"UNARCHIVE",
|
|
370
|
-
"PRINT_CERTIFICATE",
|
|
371
|
-
"REQUEST_CORRECTION",
|
|
372
|
-
"REJECT_CORRECTION",
|
|
373
|
-
"APPROVE_CORRECTION",
|
|
374
|
-
"READ",
|
|
375
|
-
"ASSIGN",
|
|
376
|
-
"UNASSIGN",
|
|
377
|
-
"CUSTOM"
|
|
378
|
-
]);
|
|
379
|
-
var ClientSpecificAction = {
|
|
380
|
-
REVIEW_CORRECTION_REQUEST: "REVIEW_CORRECTION_REQUEST"
|
|
381
|
-
};
|
|
382
|
-
var declarationActionValues = [
|
|
383
|
-
ActionTypes.enum.DECLARE,
|
|
384
|
-
ActionTypes.enum.EDIT,
|
|
385
|
-
ActionTypes.enum.REGISTER,
|
|
386
|
-
ActionTypes.enum.NOTIFY,
|
|
387
|
-
ActionTypes.enum.DUPLICATE_DETECTED
|
|
388
|
-
];
|
|
389
|
-
var DeclarationActions = ActionTypes.extract(declarationActionValues);
|
|
390
|
-
var declarationUpdateActionValues = [
|
|
391
|
-
...declarationActionValues,
|
|
392
|
-
ActionTypes.enum.REQUEST_CORRECTION
|
|
393
|
-
];
|
|
394
|
-
var DeclarationUpdateActions = ActionTypes.extract(
|
|
395
|
-
declarationUpdateActionValues
|
|
396
|
-
);
|
|
397
|
-
var annotationActions = ActionTypes.exclude(declarationActionValues);
|
|
398
|
-
var writeActions = ActionTypes.exclude([
|
|
399
|
-
ActionType.CREATE,
|
|
400
|
-
ActionType.READ,
|
|
401
|
-
ActionType.ASSIGN,
|
|
402
|
-
ActionType.UNASSIGN
|
|
403
|
-
]);
|
|
404
|
-
var WorkqueueActionType = ActionTypes.extract([
|
|
405
|
-
ActionType.READ,
|
|
406
|
-
ActionType.DELETE,
|
|
407
|
-
ActionType.DECLARE,
|
|
408
|
-
ActionType.REGISTER,
|
|
409
|
-
ActionType.EDIT,
|
|
410
|
-
ActionType.REJECT,
|
|
411
|
-
ActionType.MARK_AS_DUPLICATE,
|
|
412
|
-
ActionType.ARCHIVE,
|
|
413
|
-
ActionType.UNARCHIVE,
|
|
414
|
-
ActionType.PRINT_CERTIFICATE,
|
|
415
|
-
ActionType.REQUEST_CORRECTION
|
|
416
|
-
]);
|
|
417
|
-
var META_ACTIONS = [
|
|
418
|
-
ActionType.ASSIGN,
|
|
419
|
-
ActionType.UNASSIGN,
|
|
420
|
-
ActionType.READ
|
|
421
|
-
];
|
|
563
|
+
var TokenUserType = z7.enum(["user", "system"]);
|
|
564
|
+
var TokenWithBearer = z7.string().regex(/^Bearer\s/);
|
|
422
565
|
|
|
423
566
|
// ../commons/src/events/AuditLog.ts
|
|
424
|
-
var AuditLogEntryBase =
|
|
425
|
-
id:
|
|
426
|
-
clientId:
|
|
567
|
+
var AuditLogEntryBase = z8.object({
|
|
568
|
+
id: z8.string(),
|
|
569
|
+
clientId: z8.string(),
|
|
427
570
|
clientType: TokenUserType,
|
|
428
|
-
createdAt:
|
|
571
|
+
createdAt: z8.string()
|
|
429
572
|
});
|
|
430
573
|
var EventCreateEntrySchema = AuditLogEntryBase.extend({
|
|
431
|
-
operation:
|
|
432
|
-
requestData:
|
|
433
|
-
transactionId:
|
|
434
|
-
type:
|
|
435
|
-
createdAtLocation:
|
|
574
|
+
operation: z8.literal("event.create"),
|
|
575
|
+
requestData: z8.object({
|
|
576
|
+
transactionId: z8.string(),
|
|
577
|
+
type: z8.string(),
|
|
578
|
+
createdAtLocation: z8.string().nullable()
|
|
436
579
|
}),
|
|
437
|
-
responseSummary:
|
|
438
|
-
eventId:
|
|
439
|
-
trackingId:
|
|
580
|
+
responseSummary: z8.object({
|
|
581
|
+
eventId: z8.string(),
|
|
582
|
+
trackingId: z8.string()
|
|
440
583
|
})
|
|
441
584
|
});
|
|
442
585
|
var EventGetEntrySchema = AuditLogEntryBase.extend({
|
|
443
|
-
operation:
|
|
444
|
-
requestData:
|
|
445
|
-
responseSummary:
|
|
446
|
-
eventType:
|
|
447
|
-
trackingId:
|
|
586
|
+
operation: z8.literal("event.get"),
|
|
587
|
+
requestData: z8.object({ eventId: z8.string() }),
|
|
588
|
+
responseSummary: z8.object({
|
|
589
|
+
eventType: z8.string(),
|
|
590
|
+
trackingId: z8.string()
|
|
448
591
|
})
|
|
449
592
|
});
|
|
450
593
|
var EventSearchEntrySchema = AuditLogEntryBase.extend({
|
|
451
|
-
operation:
|
|
452
|
-
clientType:
|
|
453
|
-
requestData:
|
|
454
|
-
query:
|
|
455
|
-
limit:
|
|
456
|
-
offset:
|
|
594
|
+
operation: z8.literal("event.search"),
|
|
595
|
+
clientType: z8.literal("system"),
|
|
596
|
+
requestData: z8.object({
|
|
597
|
+
query: z8.record(z8.string(), z8.unknown()).nullable(),
|
|
598
|
+
limit: z8.number().nullable(),
|
|
599
|
+
offset: z8.number().nullable()
|
|
457
600
|
}),
|
|
458
|
-
responseSummary:
|
|
459
|
-
total:
|
|
460
|
-
eventIds:
|
|
601
|
+
responseSummary: z8.object({
|
|
602
|
+
total: z8.number(),
|
|
603
|
+
eventIds: z8.array(z8.string())
|
|
461
604
|
})
|
|
462
605
|
});
|
|
463
606
|
var EventActionEntrySchema = AuditLogEntryBase.extend({
|
|
464
|
-
operation:
|
|
607
|
+
operation: z8.enum([
|
|
465
608
|
"event.actions.notify.request",
|
|
466
609
|
"event.actions.declare.request",
|
|
467
610
|
"event.actions.register.request",
|
|
@@ -481,83 +624,83 @@ var EventActionEntrySchema = AuditLogEntryBase.extend({
|
|
|
481
624
|
"event.actions.mark_as_duplicate.request",
|
|
482
625
|
"event.actions.mark_as_not_duplicate.request"
|
|
483
626
|
]),
|
|
484
|
-
requestData:
|
|
485
|
-
eventId:
|
|
486
|
-
actionType:
|
|
487
|
-
eventType:
|
|
488
|
-
trackingId:
|
|
489
|
-
transactionId:
|
|
627
|
+
requestData: z8.object({
|
|
628
|
+
eventId: z8.string(),
|
|
629
|
+
actionType: z8.string(),
|
|
630
|
+
eventType: z8.string(),
|
|
631
|
+
trackingId: z8.string(),
|
|
632
|
+
transactionId: z8.string()
|
|
490
633
|
})
|
|
491
634
|
});
|
|
492
635
|
var EventCustomActionEntrySchema = AuditLogEntryBase.extend({
|
|
493
|
-
operation:
|
|
494
|
-
requestData:
|
|
495
|
-
eventId:
|
|
496
|
-
actionType:
|
|
497
|
-
customAction:
|
|
498
|
-
eventType:
|
|
499
|
-
trackingId:
|
|
500
|
-
transactionId:
|
|
636
|
+
operation: z8.literal("event.actions.custom.request"),
|
|
637
|
+
requestData: z8.object({
|
|
638
|
+
eventId: z8.string(),
|
|
639
|
+
actionType: z8.literal(ActionType.CUSTOM),
|
|
640
|
+
customAction: z8.string(),
|
|
641
|
+
eventType: z8.string(),
|
|
642
|
+
trackingId: z8.string(),
|
|
643
|
+
transactionId: z8.string()
|
|
501
644
|
})
|
|
502
645
|
});
|
|
503
646
|
var IntegrationCreateEntrySchema = AuditLogEntryBase.extend({
|
|
504
|
-
operation:
|
|
505
|
-
requestData:
|
|
506
|
-
responseSummary:
|
|
647
|
+
operation: z8.literal("integrations.create"),
|
|
648
|
+
requestData: z8.object({ name: z8.string(), scopes: z8.array(z8.string()) }),
|
|
649
|
+
responseSummary: z8.object({ clientId: z8.string() })
|
|
507
650
|
});
|
|
508
651
|
var IntegrationRefreshTokenEntrySchema = AuditLogEntryBase.extend({
|
|
509
|
-
operation:
|
|
510
|
-
requestData:
|
|
511
|
-
responseSummary:
|
|
652
|
+
operation: z8.literal("integrations.refreshToken"),
|
|
653
|
+
requestData: z8.object({ clientId: z8.string() }),
|
|
654
|
+
responseSummary: z8.object({ clientId: z8.string() })
|
|
512
655
|
});
|
|
513
656
|
var IntegrationDeactivateEntrySchema = AuditLogEntryBase.extend({
|
|
514
|
-
operation:
|
|
515
|
-
requestData:
|
|
516
|
-
responseSummary:
|
|
657
|
+
operation: z8.literal("integrations.deactivate"),
|
|
658
|
+
requestData: z8.object({ id: z8.string() }),
|
|
659
|
+
responseSummary: z8.object({ id: z8.string(), status: z8.string() })
|
|
517
660
|
});
|
|
518
661
|
var IntegrationActivateEntrySchema = AuditLogEntryBase.extend({
|
|
519
|
-
operation:
|
|
520
|
-
requestData:
|
|
521
|
-
responseSummary:
|
|
662
|
+
operation: z8.literal("integrations.activate"),
|
|
663
|
+
requestData: z8.object({ id: z8.string() }),
|
|
664
|
+
responseSummary: z8.object({ id: z8.string(), status: z8.string() })
|
|
522
665
|
});
|
|
523
666
|
var IntegrationDeleteEntrySchema = AuditLogEntryBase.extend({
|
|
524
|
-
operation:
|
|
525
|
-
requestData:
|
|
526
|
-
responseSummary:
|
|
667
|
+
operation: z8.literal("integrations.delete"),
|
|
668
|
+
requestData: z8.object({ id: z8.string() }),
|
|
669
|
+
responseSummary: z8.object({ id: z8.string(), name: z8.string() })
|
|
527
670
|
});
|
|
528
671
|
var IntegrationRefreshSecretEntrySchema = AuditLogEntryBase.extend({
|
|
529
|
-
operation:
|
|
530
|
-
requestData:
|
|
531
|
-
responseSummary:
|
|
672
|
+
operation: z8.literal("integrations.refreshSecret"),
|
|
673
|
+
requestData: z8.object({ id: z8.string() }),
|
|
674
|
+
responseSummary: z8.object({ clientId: z8.string() })
|
|
532
675
|
});
|
|
533
676
|
var AttachmentUploadEntrySchema = AuditLogEntryBase.extend({
|
|
534
|
-
operation:
|
|
535
|
-
requestData:
|
|
536
|
-
transactionId:
|
|
537
|
-
path:
|
|
677
|
+
operation: z8.literal("attachments.upload"),
|
|
678
|
+
requestData: z8.object({
|
|
679
|
+
transactionId: z8.string(),
|
|
680
|
+
path: z8.string().nullable()
|
|
538
681
|
}),
|
|
539
|
-
responseSummary:
|
|
682
|
+
responseSummary: z8.object({ fileUrl: z8.string() })
|
|
540
683
|
});
|
|
541
|
-
var subjectOnly =
|
|
542
|
-
var subjectWithReason =
|
|
543
|
-
subjectId:
|
|
544
|
-
reason:
|
|
545
|
-
comment:
|
|
684
|
+
var subjectOnly = z8.object({ subjectId: z8.string() });
|
|
685
|
+
var subjectWithReason = z8.object({
|
|
686
|
+
subjectId: z8.string(),
|
|
687
|
+
reason: z8.string(),
|
|
688
|
+
comment: z8.string().optional()
|
|
546
689
|
});
|
|
547
690
|
var UserCreateEntrySchema = AuditLogEntryBase.extend({
|
|
548
|
-
operation:
|
|
549
|
-
requestData:
|
|
550
|
-
subjectId:
|
|
551
|
-
role:
|
|
552
|
-
primaryOfficeId:
|
|
691
|
+
operation: z8.literal("user.create_user"),
|
|
692
|
+
requestData: z8.object({
|
|
693
|
+
subjectId: z8.string(),
|
|
694
|
+
role: z8.string(),
|
|
695
|
+
primaryOfficeId: z8.string()
|
|
553
696
|
})
|
|
554
697
|
});
|
|
555
698
|
var UserReasonEntrySchema = AuditLogEntryBase.extend({
|
|
556
|
-
operation:
|
|
699
|
+
operation: z8.enum(["user.deactivate", "user.reactivate"]),
|
|
557
700
|
requestData: subjectWithReason
|
|
558
701
|
});
|
|
559
702
|
var UserSubjectOnlyEntrySchema = AuditLogEntryBase.extend({
|
|
560
|
-
operation:
|
|
703
|
+
operation: z8.enum([
|
|
561
704
|
"user.edit_user",
|
|
562
705
|
"user.logged_in",
|
|
563
706
|
"user.logged_out",
|
|
@@ -571,14 +714,14 @@ var UserSubjectOnlyEntrySchema = AuditLogEntryBase.extend({
|
|
|
571
714
|
requestData: subjectOnly
|
|
572
715
|
});
|
|
573
716
|
var UserEmailChangedEntrySchema = AuditLogEntryBase.extend({
|
|
574
|
-
operation:
|
|
717
|
+
operation: z8.literal("user.email_address_changed"),
|
|
575
718
|
requestData: subjectOnly,
|
|
576
|
-
responseSummary:
|
|
719
|
+
responseSummary: z8.object({ email: z8.string() })
|
|
577
720
|
});
|
|
578
721
|
var UserPhoneChangedEntrySchema = AuditLogEntryBase.extend({
|
|
579
|
-
operation:
|
|
722
|
+
operation: z8.literal("user.phone_number_changed"),
|
|
580
723
|
requestData: subjectOnly,
|
|
581
|
-
responseSummary:
|
|
724
|
+
responseSummary: z8.object({ phoneNumber: z8.string() })
|
|
582
725
|
});
|
|
583
726
|
var userBaseOmit = {
|
|
584
727
|
id: true,
|
|
@@ -586,14 +729,14 @@ var userBaseOmit = {
|
|
|
586
729
|
clientType: true,
|
|
587
730
|
createdAt: true
|
|
588
731
|
};
|
|
589
|
-
var UserAuditRecordInput =
|
|
732
|
+
var UserAuditRecordInput = z8.discriminatedUnion("operation", [
|
|
590
733
|
UserCreateEntrySchema.omit(userBaseOmit),
|
|
591
734
|
UserReasonEntrySchema.omit(userBaseOmit),
|
|
592
735
|
UserSubjectOnlyEntrySchema.omit(userBaseOmit),
|
|
593
736
|
UserEmailChangedEntrySchema.omit(userBaseOmit),
|
|
594
737
|
UserPhoneChangedEntrySchema.omit(userBaseOmit)
|
|
595
738
|
]);
|
|
596
|
-
var AuditLogEntrySchema =
|
|
739
|
+
var AuditLogEntrySchema = z8.discriminatedUnion("operation", [
|
|
597
740
|
EventCreateEntrySchema,
|
|
598
741
|
EventGetEntrySchema,
|
|
599
742
|
EventSearchEntrySchema,
|
|
@@ -620,76 +763,11 @@ var CHILD_ONBOARDING_EVENT = "child-onboarding";
|
|
|
620
763
|
// ../commons/src/events/ActionConfig.ts
|
|
621
764
|
var z24 = __toESM(require("zod/v4"));
|
|
622
765
|
|
|
623
|
-
// ../commons/src/events/TranslationConfig.ts
|
|
624
|
-
var z6 = __toESM(require("zod/v4"));
|
|
625
|
-
var TranslationConfig = z6.object({
|
|
626
|
-
id: z6.string().describe(
|
|
627
|
-
"The identifier of the translation referred in translation CSV files"
|
|
628
|
-
),
|
|
629
|
-
defaultMessage: z6.string().describe("Default translation message"),
|
|
630
|
-
description: z6.string().describe(
|
|
631
|
-
"Describe the translation for a translator to be able to identify it."
|
|
632
|
-
)
|
|
633
|
-
}).meta({
|
|
634
|
-
description: "Translation configuration",
|
|
635
|
-
id: "TranslationConfig"
|
|
636
|
-
});
|
|
637
|
-
|
|
638
766
|
// ../commons/src/events/FieldConfig.ts
|
|
639
767
|
var import_v43 = __toESM(require("zod/v4"));
|
|
640
768
|
|
|
641
|
-
// ../commons/src/events/Conditional.ts
|
|
642
|
-
var z7 = __toESM(require("zod/v4"));
|
|
643
|
-
var Conditional = z7.any().describe("JSONSchema").meta({
|
|
644
|
-
description: "JSON schema conditional configuration",
|
|
645
|
-
id: "Conditional"
|
|
646
|
-
});
|
|
647
|
-
var ConditionalType = {
|
|
648
|
-
SHOW: "SHOW",
|
|
649
|
-
ENABLE: "ENABLE",
|
|
650
|
-
DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
|
|
651
|
-
};
|
|
652
|
-
var ShowConditional = z7.object({
|
|
653
|
-
type: z7.literal(ConditionalType.SHOW),
|
|
654
|
-
conditional: Conditional
|
|
655
|
-
}).describe(
|
|
656
|
-
"If 'SHOW' conditional is defined, the component is shown to the user only if the condition is met"
|
|
657
|
-
);
|
|
658
|
-
var EnableConditional = z7.object({
|
|
659
|
-
type: z7.literal(ConditionalType.ENABLE),
|
|
660
|
-
conditional: Conditional
|
|
661
|
-
}).describe(
|
|
662
|
-
"If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
|
|
663
|
-
);
|
|
664
|
-
var ActionConditional = z7.discriminatedUnion("type", [
|
|
665
|
-
// Action can be shown / hidden
|
|
666
|
-
ShowConditional,
|
|
667
|
-
// Action can be shown to the user in the list but as disabled
|
|
668
|
-
EnableConditional
|
|
669
|
-
]).meta({
|
|
670
|
-
id: "ActionConditional",
|
|
671
|
-
description: "Conditional gating whether an action is shown (SHOW) or enabled (ENABLE). When omitted from an action, the action is shown and enabled for everyone."
|
|
672
|
-
});
|
|
673
|
-
var DisplayOnReviewConditional = z7.object({
|
|
674
|
-
type: z7.literal(ConditionalType.DISPLAY_ON_REVIEW),
|
|
675
|
-
conditional: Conditional
|
|
676
|
-
}).describe(
|
|
677
|
-
"If 'DISPLAY_ON_REVIEW' conditional is defined, the component is shown on the review page only if both the 'DISPLAY_ON_REVIEW' and 'SHOW' conditions are met. This should only be used for fields within declaration forms, as they are the only ones with review pages."
|
|
678
|
-
);
|
|
679
|
-
var FieldConditional = z7.discriminatedUnion("type", [
|
|
680
|
-
// Field input can be shown / hidden
|
|
681
|
-
ShowConditional,
|
|
682
|
-
// Field input can be shown to the user but as disabled
|
|
683
|
-
EnableConditional,
|
|
684
|
-
// Field output can be shown / hidden on the review page
|
|
685
|
-
DisplayOnReviewConditional
|
|
686
|
-
]).meta({
|
|
687
|
-
id: "FieldConditional",
|
|
688
|
-
description: "Conditional gating whether a form field is shown (SHOW), enabled (ENABLE), or displayed on the review page (DISPLAY_ON_REVIEW). When omitted, the field is shown and enabled for everyone, and is displayed on review whenever it has a value."
|
|
689
|
-
});
|
|
690
|
-
|
|
691
769
|
// ../commons/src/events/FieldType.ts
|
|
692
|
-
var
|
|
770
|
+
var z9 = __toESM(require("zod/v4"));
|
|
693
771
|
var FieldType = {
|
|
694
772
|
NAME: "NAME",
|
|
695
773
|
PHONE: "PHONE",
|
|
@@ -753,7 +831,7 @@ var FieldType = {
|
|
|
753
831
|
*/
|
|
754
832
|
_EXPERIMENTAL_CUSTOM: "CUSTOM"
|
|
755
833
|
};
|
|
756
|
-
var FileFieldType =
|
|
834
|
+
var FileFieldType = z9.enum([
|
|
757
835
|
FieldType.FILE,
|
|
758
836
|
FieldType.FILE_WITH_OPTIONS,
|
|
759
837
|
FieldType.SIGNATURE
|
|
@@ -789,160 +867,164 @@ var HiddenFieldTypes = [
|
|
|
789
867
|
];
|
|
790
868
|
|
|
791
869
|
// ../commons/src/events/FieldValue.ts
|
|
792
|
-
var
|
|
870
|
+
var z13 = __toESM(require("zod/v4"));
|
|
793
871
|
|
|
794
872
|
// ../commons/src/documents.ts
|
|
795
|
-
var
|
|
796
|
-
var FullDocumentUrl =
|
|
873
|
+
var z10 = __toESM(require("zod/v4"));
|
|
874
|
+
var FullDocumentUrl = z10.string().brand("FullDocumentUrl").describe(
|
|
797
875
|
"A full url with protocol, host, bucket name, starting from the root of the S3 server, https://minio.opencrvs.com/bucket-name/document-id.jpg"
|
|
798
876
|
);
|
|
799
|
-
var FullDocumentPath =
|
|
877
|
+
var FullDocumentPath = z10.string().overwrite((val) => val.startsWith("/") ? val : `/${val}`).meta({ effectType: "input", type: "string" }).describe(
|
|
800
878
|
"A full absolute path with bucket name, starting from the root of the S3 server, /bucket-name/document-id.jpg"
|
|
801
879
|
);
|
|
802
|
-
var DocumentPath =
|
|
880
|
+
var DocumentPath = z10.string().brand("DocumentPath").describe(
|
|
803
881
|
"A relative path within the S3 bucket, never starting with /. e.g. document-id.jpg or directory/document-id.jpg. The document service constructs the full /bucket/path internally."
|
|
804
882
|
);
|
|
805
883
|
|
|
806
884
|
// ../commons/src/events/CompositeFieldValue.ts
|
|
807
|
-
var
|
|
885
|
+
var z11 = __toESM(require("zod/v4"));
|
|
808
886
|
var AddressType = {
|
|
809
887
|
DOMESTIC: "DOMESTIC",
|
|
810
888
|
INTERNATIONAL: "INTERNATIONAL"
|
|
811
889
|
};
|
|
812
|
-
var FileFieldValue =
|
|
890
|
+
var FileFieldValue = z11.object({
|
|
813
891
|
path: DocumentPath,
|
|
814
|
-
originalFilename:
|
|
815
|
-
type:
|
|
816
|
-
});
|
|
817
|
-
var NameFieldValue =
|
|
818
|
-
firstname:
|
|
819
|
-
surname:
|
|
820
|
-
middlename:
|
|
821
|
-
});
|
|
822
|
-
var NameFieldUpdateValue =
|
|
823
|
-
firstname:
|
|
824
|
-
surname:
|
|
825
|
-
middlename:
|
|
826
|
-
}).or(
|
|
827
|
-
var StreetLevelDetailsValue =
|
|
828
|
-
var StreetLevelDetailsUpdateValue =
|
|
829
|
-
var BaseAddressFieldValue =
|
|
830
|
-
country:
|
|
892
|
+
originalFilename: z11.string(),
|
|
893
|
+
type: z11.string()
|
|
894
|
+
});
|
|
895
|
+
var NameFieldValue = z11.object({
|
|
896
|
+
firstname: z11.string(),
|
|
897
|
+
surname: z11.string(),
|
|
898
|
+
middlename: z11.string().optional()
|
|
899
|
+
});
|
|
900
|
+
var NameFieldUpdateValue = z11.object({
|
|
901
|
+
firstname: z11.string().nullish(),
|
|
902
|
+
surname: z11.string().nullish(),
|
|
903
|
+
middlename: z11.string().nullish()
|
|
904
|
+
}).or(z11.null()).or(z11.undefined());
|
|
905
|
+
var StreetLevelDetailsValue = z11.record(z11.string(), z11.string()).optional();
|
|
906
|
+
var StreetLevelDetailsUpdateValue = z11.record(z11.string(), z11.string().nullable()).nullish();
|
|
907
|
+
var BaseAddressFieldValue = z11.object({
|
|
908
|
+
country: z11.string(),
|
|
831
909
|
streetLevelDetails: StreetLevelDetailsValue
|
|
832
910
|
});
|
|
833
|
-
var BaseAddressFieldUpdateValue =
|
|
834
|
-
country:
|
|
911
|
+
var BaseAddressFieldUpdateValue = z11.object({
|
|
912
|
+
country: z11.string().nullish(),
|
|
835
913
|
streetLevelDetails: StreetLevelDetailsUpdateValue
|
|
836
914
|
});
|
|
837
915
|
var DomesticAddressFieldValue = BaseAddressFieldValue.extend({
|
|
838
|
-
addressType:
|
|
839
|
-
administrativeArea:
|
|
916
|
+
addressType: z11.literal(AddressType.DOMESTIC),
|
|
917
|
+
administrativeArea: z11.string().uuid()
|
|
840
918
|
});
|
|
841
919
|
var InternationalAddressFieldValue = BaseAddressFieldValue.extend({
|
|
842
|
-
addressType:
|
|
920
|
+
addressType: z11.literal(AddressType.INTERNATIONAL)
|
|
843
921
|
});
|
|
844
|
-
var AddressFieldValue =
|
|
922
|
+
var AddressFieldValue = z11.discriminatedUnion("addressType", [
|
|
845
923
|
DomesticAddressFieldValue,
|
|
846
924
|
InternationalAddressFieldValue
|
|
847
925
|
]);
|
|
848
926
|
var DomesticAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend({
|
|
849
|
-
addressType:
|
|
850
|
-
administrativeArea:
|
|
927
|
+
addressType: z11.literal(AddressType.DOMESTIC),
|
|
928
|
+
administrativeArea: z11.string().uuid().nullish()
|
|
851
929
|
/* Leaf level admin structure */
|
|
852
930
|
});
|
|
853
931
|
var InternationalAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend(
|
|
854
932
|
{
|
|
855
|
-
addressType:
|
|
933
|
+
addressType: z11.literal(AddressType.INTERNATIONAL)
|
|
856
934
|
}
|
|
857
935
|
);
|
|
858
|
-
var AddressFieldUpdateValue =
|
|
936
|
+
var AddressFieldUpdateValue = z11.discriminatedUnion("addressType", [
|
|
859
937
|
DomesticAddressUpdateFieldValue,
|
|
860
938
|
InternationalAddressUpdateFieldValue
|
|
861
939
|
]).nullish();
|
|
862
|
-
var FileFieldValueWithOption =
|
|
940
|
+
var FileFieldValueWithOption = z11.object({
|
|
863
941
|
path: DocumentPath,
|
|
864
|
-
originalFilename:
|
|
865
|
-
type:
|
|
866
|
-
option:
|
|
867
|
-
});
|
|
868
|
-
var FileFieldWithOptionValue =
|
|
869
|
-
var HttpFieldValue =
|
|
870
|
-
loading:
|
|
871
|
-
error:
|
|
872
|
-
data:
|
|
873
|
-
});
|
|
874
|
-
var HttpFieldUpdateValue =
|
|
875
|
-
loading:
|
|
876
|
-
error:
|
|
877
|
-
data:
|
|
878
|
-
}).or(
|
|
879
|
-
var QueryParamReaderFieldValue =
|
|
880
|
-
data:
|
|
881
|
-
updatedAt:
|
|
942
|
+
originalFilename: z11.string(),
|
|
943
|
+
type: z11.string(),
|
|
944
|
+
option: z11.string()
|
|
945
|
+
});
|
|
946
|
+
var FileFieldWithOptionValue = z11.array(FileFieldValueWithOption);
|
|
947
|
+
var HttpFieldValue = z11.object({
|
|
948
|
+
loading: z11.boolean(),
|
|
949
|
+
error: z11.object({ statusCode: z11.number(), message: z11.string() }).nullish(),
|
|
950
|
+
data: z11.any()
|
|
951
|
+
});
|
|
952
|
+
var HttpFieldUpdateValue = z11.object({
|
|
953
|
+
loading: z11.boolean().nullish(),
|
|
954
|
+
error: z11.object({ statusCode: z11.number(), message: z11.string() }).nullish(),
|
|
955
|
+
data: z11.any().nullish()
|
|
956
|
+
}).or(z11.null()).or(z11.undefined());
|
|
957
|
+
var QueryParamReaderFieldValue = z11.object({
|
|
958
|
+
data: z11.record(z11.string(), z11.string()),
|
|
959
|
+
updatedAt: z11.iso.datetime()
|
|
882
960
|
}).nullish();
|
|
883
|
-
var QueryParamReaderFieldUpdateValue =
|
|
884
|
-
data:
|
|
961
|
+
var QueryParamReaderFieldUpdateValue = z11.object({
|
|
962
|
+
data: z11.record(z11.string(), z11.string())
|
|
885
963
|
});
|
|
886
|
-
var ReadDataValue =
|
|
887
|
-
data:
|
|
964
|
+
var ReadDataValue = z11.object({
|
|
965
|
+
data: z11.any()
|
|
888
966
|
});
|
|
889
967
|
var QrReaderFieldValue = ReadDataValue;
|
|
890
968
|
var IdReaderFieldValue = ReadDataValue;
|
|
891
|
-
var NumberWithUnitFieldValue =
|
|
892
|
-
numericValue:
|
|
893
|
-
unit:
|
|
969
|
+
var NumberWithUnitFieldValue = z11.object({
|
|
970
|
+
numericValue: z11.number(),
|
|
971
|
+
unit: z11.string()
|
|
894
972
|
});
|
|
895
|
-
var NumberWithUnitFieldUpdateValue =
|
|
896
|
-
numericValue:
|
|
897
|
-
unit:
|
|
973
|
+
var NumberWithUnitFieldUpdateValue = z11.object({
|
|
974
|
+
numericValue: z11.number().optional(),
|
|
975
|
+
unit: z11.string().optional()
|
|
898
976
|
});
|
|
899
|
-
var CustomFieldValue =
|
|
977
|
+
var CustomFieldValue = z11.unknown().brand("CustomFieldValue");
|
|
900
978
|
|
|
901
979
|
// ../commons/src/events/PlainDate.ts
|
|
902
980
|
var import_zod = require("zod");
|
|
903
981
|
var PlainDate = import_zod.z.string().date().brand("PlainDate").describe("Date in the format YYYY-MM-DD");
|
|
982
|
+
function plainDateToLocalDate(date) {
|
|
983
|
+
const [year, month, day] = date.split("-").map(Number);
|
|
984
|
+
return new Date(year, month - 1, day);
|
|
985
|
+
}
|
|
904
986
|
|
|
905
987
|
// ../commons/src/events/FieldValue.ts
|
|
906
|
-
var TextValue =
|
|
907
|
-
var HiddenFieldValue =
|
|
908
|
-
var NonEmptyTextValue =
|
|
909
|
-
var DateValue =
|
|
910
|
-
var AgeValue =
|
|
911
|
-
age:
|
|
912
|
-
asOfDateRef:
|
|
988
|
+
var TextValue = z13.string();
|
|
989
|
+
var HiddenFieldValue = z13.string();
|
|
990
|
+
var NonEmptyTextValue = z13.string().trim().min(1);
|
|
991
|
+
var DateValue = z13.iso.date().describe("Date in the format YYYY-MM-DD");
|
|
992
|
+
var AgeValue = z13.object({
|
|
993
|
+
age: z13.number(),
|
|
994
|
+
asOfDateRef: z13.string()
|
|
913
995
|
});
|
|
914
996
|
var AgeUpdateValue = AgeValue.optional().nullable();
|
|
915
|
-
var AutocompleteValue =
|
|
916
|
-
label:
|
|
917
|
-
value:
|
|
997
|
+
var AutocompleteValue = z13.object({
|
|
998
|
+
label: z13.string(),
|
|
999
|
+
value: z13.string()
|
|
918
1000
|
});
|
|
919
1001
|
var AutocompleteUpdateValue = AutocompleteValue.optional().nullable();
|
|
920
|
-
var TimeValue =
|
|
921
|
-
var DatetimeValue =
|
|
922
|
-
var SelectDateRangeValue =
|
|
1002
|
+
var TimeValue = z13.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
|
|
1003
|
+
var DatetimeValue = z13.iso.datetime();
|
|
1004
|
+
var SelectDateRangeValue = z13.enum([
|
|
923
1005
|
"last7Days",
|
|
924
1006
|
"last30Days",
|
|
925
1007
|
"last90Days",
|
|
926
1008
|
"last365Days"
|
|
927
1009
|
]);
|
|
928
|
-
var DateRangeFieldValue =
|
|
1010
|
+
var DateRangeFieldValue = z13.object({
|
|
929
1011
|
start: PlainDate,
|
|
930
1012
|
end: PlainDate
|
|
931
1013
|
}).or(PlainDate).describe(
|
|
932
1014
|
"Date range with start and end dates in the format YYYY-MM-DD. Inclusive start, exclusive end."
|
|
933
1015
|
);
|
|
934
|
-
var EmailValue =
|
|
935
|
-
var CheckboxFieldValue =
|
|
936
|
-
var NumberFieldValue =
|
|
1016
|
+
var EmailValue = z13.email();
|
|
1017
|
+
var CheckboxFieldValue = z13.boolean();
|
|
1018
|
+
var NumberFieldValue = z13.number();
|
|
937
1019
|
var SignatureFieldValue = FileFieldValue;
|
|
938
|
-
var ButtonFieldValue =
|
|
939
|
-
var VerificationStatusValue =
|
|
1020
|
+
var ButtonFieldValue = z13.number();
|
|
1021
|
+
var VerificationStatusValue = z13.enum([
|
|
940
1022
|
"verified",
|
|
941
1023
|
"authenticated",
|
|
942
1024
|
"failed",
|
|
943
1025
|
"pending"
|
|
944
1026
|
]);
|
|
945
|
-
var LeafFieldValues =
|
|
1027
|
+
var LeafFieldValues = z13.union([
|
|
946
1028
|
AddressFieldValue,
|
|
947
1029
|
TextValue,
|
|
948
1030
|
PlainDate,
|
|
@@ -968,11 +1050,11 @@ var LeafFieldValues = z12.union([
|
|
|
968
1050
|
AutocompleteValue,
|
|
969
1051
|
AutocompleteUpdateValue
|
|
970
1052
|
]);
|
|
971
|
-
var FieldGroupValue =
|
|
972
|
-
var DataFieldValue =
|
|
973
|
-
data:
|
|
1053
|
+
var FieldGroupValue = z13.record(z13.string(), LeafFieldValues);
|
|
1054
|
+
var DataFieldValue = z13.object({
|
|
1055
|
+
data: z13.record(z13.string(), LeafFieldValues)
|
|
974
1056
|
}).nullish();
|
|
975
|
-
var FieldValue =
|
|
1057
|
+
var FieldValue = z13.union([
|
|
976
1058
|
LeafFieldValues,
|
|
977
1059
|
DataFieldValue,
|
|
978
1060
|
FieldGroupValue
|
|
@@ -1006,7 +1088,7 @@ function safeUnion(schemas) {
|
|
|
1006
1088
|
const sortedSchemas = [...schemas].sort(
|
|
1007
1089
|
(a, b) => schemaPriority(a) - schemaPriority(b)
|
|
1008
1090
|
);
|
|
1009
|
-
return
|
|
1091
|
+
return z13.any().superRefine((val, ctx) => {
|
|
1010
1092
|
for (const schema of sortedSchemas) {
|
|
1011
1093
|
if (schema.safeParse(val).success) {
|
|
1012
1094
|
return;
|
|
@@ -1045,9 +1127,9 @@ var FieldUpdateValue = safeUnion([
|
|
|
1045
1127
|
]);
|
|
1046
1128
|
|
|
1047
1129
|
// ../commons/src/events/serializers/user/serializer.ts
|
|
1048
|
-
var
|
|
1049
|
-
var SerializedUserField =
|
|
1050
|
-
$userField:
|
|
1130
|
+
var z14 = __toESM(require("zod/v4"));
|
|
1131
|
+
var SerializedUserField = z14.object({
|
|
1132
|
+
$userField: z14.enum([
|
|
1051
1133
|
"id",
|
|
1052
1134
|
"name",
|
|
1053
1135
|
"role",
|
|
@@ -1061,7 +1143,7 @@ var SerializedUserField = z13.object({
|
|
|
1061
1143
|
"primaryOfficeId",
|
|
1062
1144
|
"administrativeAreaId"
|
|
1063
1145
|
]),
|
|
1064
|
-
$location:
|
|
1146
|
+
$location: z14.string().optional()
|
|
1065
1147
|
});
|
|
1066
1148
|
function userSerializer(userField) {
|
|
1067
1149
|
return {
|
|
@@ -1087,27 +1169,22 @@ var import_v4 = require("zod/v4");
|
|
|
1087
1169
|
var z16 = __toESM(require("zod/v4"));
|
|
1088
1170
|
|
|
1089
1171
|
// ../commons/src/events/ActionDocument.ts
|
|
1090
|
-
var
|
|
1091
|
-
var ActionUpdate =
|
|
1172
|
+
var z15 = __toESM(require("zod/v4"));
|
|
1173
|
+
var ActionUpdate = z15.record(z15.string(), FieldUpdateValue).describe(
|
|
1092
1174
|
"Record of field-level changes made by an action. Supports partial updates and nullable values."
|
|
1093
1175
|
);
|
|
1094
|
-
var EventState =
|
|
1176
|
+
var EventState = z15.record(z15.string(), FieldValue).describe(
|
|
1095
1177
|
"Aggregate representation of event data after all actions have been applied, with all updates consolidated and null values removed."
|
|
1096
1178
|
);
|
|
1097
|
-
var
|
|
1098
|
-
Requested: "Requested",
|
|
1099
|
-
Accepted: "Accepted",
|
|
1100
|
-
Rejected: "Rejected"
|
|
1101
|
-
};
|
|
1102
|
-
var ActionBase = z14.object({
|
|
1179
|
+
var ActionBase = z15.object({
|
|
1103
1180
|
id: UUID.describe("Unique identifier of the action."),
|
|
1104
|
-
transactionId:
|
|
1181
|
+
transactionId: z15.string().describe("Unique identifier of the transaction."),
|
|
1105
1182
|
createdByUserType: TokenUserType.describe(
|
|
1106
1183
|
"Indicates whether the action was created by a human-user or by a system-user."
|
|
1107
1184
|
),
|
|
1108
|
-
createdAt:
|
|
1109
|
-
createdBy:
|
|
1110
|
-
createdByRole:
|
|
1185
|
+
createdAt: z15.string().datetime().describe("Timestamp indicating when the action was created."),
|
|
1186
|
+
createdBy: z15.string().describe("Identifier of the user who created the action."),
|
|
1187
|
+
createdByRole: z15.string().optional().describe("Role of the user who created the action."),
|
|
1111
1188
|
createdBySignature: DocumentPath.nullish().describe(
|
|
1112
1189
|
"Reference to the signature of the user who created the action."
|
|
1113
1190
|
),
|
|
@@ -1119,7 +1196,7 @@ var ActionBase = z14.object({
|
|
|
1119
1196
|
"Declaration data defined by the ActionConfig. Supports partial updates."
|
|
1120
1197
|
),
|
|
1121
1198
|
annotation: ActionUpdate.optional().nullable().describe("Action-specific metadata used to annotate the event."),
|
|
1122
|
-
status:
|
|
1199
|
+
status: z15.enum([
|
|
1123
1200
|
ActionStatus.Requested,
|
|
1124
1201
|
ActionStatus.Accepted,
|
|
1125
1202
|
ActionStatus.Rejected
|
|
@@ -1131,139 +1208,139 @@ var ActionBase = z14.object({
|
|
|
1131
1208
|
)
|
|
1132
1209
|
});
|
|
1133
1210
|
var AssignedAction = ActionBase.extend(
|
|
1134
|
-
|
|
1135
|
-
type:
|
|
1136
|
-
assignedTo:
|
|
1211
|
+
z15.object({
|
|
1212
|
+
type: z15.literal(ActionType.ASSIGN),
|
|
1213
|
+
assignedTo: z15.string().describe("Identifier of the user to whom the action is assigned.")
|
|
1137
1214
|
// TODO move into 'content' property
|
|
1138
1215
|
}).shape
|
|
1139
1216
|
);
|
|
1140
1217
|
var UnassignedAction = ActionBase.extend(
|
|
1141
|
-
|
|
1142
|
-
type:
|
|
1218
|
+
z15.object({
|
|
1219
|
+
type: z15.literal(ActionType.UNASSIGN)
|
|
1143
1220
|
}).shape
|
|
1144
1221
|
);
|
|
1145
1222
|
var RegisterAction = ActionBase.extend(
|
|
1146
|
-
|
|
1147
|
-
type:
|
|
1148
|
-
registrationNumber:
|
|
1223
|
+
z15.object({
|
|
1224
|
+
type: z15.literal(ActionType.REGISTER),
|
|
1225
|
+
registrationNumber: z15.string().optional().describe(
|
|
1149
1226
|
"Registration number of the event. Always present for accepted registrations."
|
|
1150
1227
|
)
|
|
1151
1228
|
// TODO move into 'content' property
|
|
1152
1229
|
}).shape
|
|
1153
1230
|
);
|
|
1154
1231
|
var DeclareAction = ActionBase.extend(
|
|
1155
|
-
|
|
1156
|
-
type:
|
|
1232
|
+
z15.object({
|
|
1233
|
+
type: z15.literal(ActionType.DECLARE)
|
|
1157
1234
|
}).shape
|
|
1158
1235
|
);
|
|
1159
|
-
var ReasonContent =
|
|
1160
|
-
reason:
|
|
1236
|
+
var ReasonContent = z15.object({
|
|
1237
|
+
reason: z15.string().min(1, { error: "Message cannot be empty" }).describe(
|
|
1161
1238
|
"Message describing the reason for rejecting or archiving the event."
|
|
1162
1239
|
)
|
|
1163
1240
|
});
|
|
1164
1241
|
var RejectAction = ActionBase.extend(
|
|
1165
|
-
|
|
1166
|
-
type:
|
|
1242
|
+
z15.object({
|
|
1243
|
+
type: z15.literal(ActionType.REJECT),
|
|
1167
1244
|
content: ReasonContent
|
|
1168
1245
|
}).shape
|
|
1169
1246
|
);
|
|
1170
|
-
var PotentialDuplicate =
|
|
1247
|
+
var PotentialDuplicate = z15.object({
|
|
1171
1248
|
id: UUID,
|
|
1172
|
-
trackingId:
|
|
1249
|
+
trackingId: z15.string()
|
|
1173
1250
|
});
|
|
1174
1251
|
var DuplicateDetectedAction = ActionBase.extend(
|
|
1175
|
-
|
|
1176
|
-
type:
|
|
1177
|
-
content:
|
|
1178
|
-
duplicates:
|
|
1252
|
+
z15.object({
|
|
1253
|
+
type: z15.literal(ActionType.DUPLICATE_DETECTED),
|
|
1254
|
+
content: z15.object({
|
|
1255
|
+
duplicates: z15.array(PotentialDuplicate)
|
|
1179
1256
|
})
|
|
1180
1257
|
}).shape
|
|
1181
1258
|
);
|
|
1182
1259
|
var MarkNotDuplicateAction = ActionBase.extend(
|
|
1183
|
-
|
|
1184
|
-
type:
|
|
1260
|
+
z15.object({
|
|
1261
|
+
type: z15.literal(ActionType.MARK_AS_NOT_DUPLICATE)
|
|
1185
1262
|
}).shape
|
|
1186
1263
|
);
|
|
1187
1264
|
var MarkAsDuplicateAction = ActionBase.extend(
|
|
1188
|
-
|
|
1189
|
-
type:
|
|
1190
|
-
content:
|
|
1265
|
+
z15.object({
|
|
1266
|
+
type: z15.literal(ActionType.MARK_AS_DUPLICATE),
|
|
1267
|
+
content: z15.object({
|
|
1191
1268
|
duplicateOf: UUID
|
|
1192
1269
|
}).optional()
|
|
1193
1270
|
}).shape
|
|
1194
1271
|
);
|
|
1195
1272
|
var ArchiveAction = ActionBase.extend(
|
|
1196
|
-
|
|
1197
|
-
type:
|
|
1273
|
+
z15.object({
|
|
1274
|
+
type: z15.literal(ActionType.ARCHIVE),
|
|
1198
1275
|
content: ReasonContent
|
|
1199
1276
|
}).shape
|
|
1200
1277
|
);
|
|
1201
1278
|
var UnarchiveAction = ActionBase.extend(
|
|
1202
|
-
|
|
1203
|
-
type:
|
|
1279
|
+
z15.object({
|
|
1280
|
+
type: z15.literal(ActionType.UNARCHIVE)
|
|
1204
1281
|
}).shape
|
|
1205
1282
|
);
|
|
1206
1283
|
var CreatedAction = ActionBase.extend(
|
|
1207
|
-
|
|
1208
|
-
type:
|
|
1284
|
+
z15.object({
|
|
1285
|
+
type: z15.literal(ActionType.CREATE)
|
|
1209
1286
|
}).shape
|
|
1210
1287
|
);
|
|
1211
1288
|
var NotifiedAction = ActionBase.extend(
|
|
1212
|
-
|
|
1213
|
-
type:
|
|
1289
|
+
z15.object({
|
|
1290
|
+
type: z15.literal(ActionType.NOTIFY)
|
|
1214
1291
|
}).shape
|
|
1215
1292
|
);
|
|
1216
1293
|
var EditAction = ActionBase.extend(
|
|
1217
|
-
|
|
1218
|
-
type:
|
|
1294
|
+
z15.object({
|
|
1295
|
+
type: z15.literal(ActionType.EDIT),
|
|
1219
1296
|
/** @deprecated New Edit-actions should no longer contain content. This is kept for old 2.0 edits. */
|
|
1220
|
-
content:
|
|
1221
|
-
comment:
|
|
1297
|
+
content: z15.object({
|
|
1298
|
+
comment: z15.string().describe("Comment for the edit action.").optional()
|
|
1222
1299
|
}).optional()
|
|
1223
1300
|
}).shape
|
|
1224
1301
|
);
|
|
1225
|
-
var PrintContent =
|
|
1226
|
-
templateId:
|
|
1302
|
+
var PrintContent = z15.object({
|
|
1303
|
+
templateId: z15.string().optional()
|
|
1227
1304
|
});
|
|
1228
1305
|
var PrintCertificateAction = ActionBase.extend(
|
|
1229
|
-
|
|
1230
|
-
type:
|
|
1306
|
+
z15.object({
|
|
1307
|
+
type: z15.literal(ActionType.PRINT_CERTIFICATE),
|
|
1231
1308
|
content: PrintContent.optional().nullable()
|
|
1232
1309
|
}).shape
|
|
1233
1310
|
);
|
|
1234
1311
|
var RequestedCorrectionAction = ActionBase.extend(
|
|
1235
|
-
|
|
1236
|
-
type:
|
|
1312
|
+
z15.object({
|
|
1313
|
+
type: z15.literal(ActionType.REQUEST_CORRECTION)
|
|
1237
1314
|
}).shape
|
|
1238
1315
|
);
|
|
1239
1316
|
var ApprovedCorrectionAction = ActionBase.extend(
|
|
1240
|
-
|
|
1241
|
-
type:
|
|
1242
|
-
requestId:
|
|
1317
|
+
z15.object({
|
|
1318
|
+
type: z15.literal(ActionType.APPROVE_CORRECTION),
|
|
1319
|
+
requestId: z15.string(),
|
|
1243
1320
|
// TODO move into 'content' property
|
|
1244
|
-
content:
|
|
1321
|
+
content: z15.object({ immediateCorrection: z15.boolean().optional() }).optional()
|
|
1245
1322
|
}).shape
|
|
1246
1323
|
);
|
|
1247
1324
|
var RejectedCorrectionAction = ActionBase.extend(
|
|
1248
|
-
|
|
1249
|
-
type:
|
|
1250
|
-
requestId:
|
|
1325
|
+
z15.object({
|
|
1326
|
+
type: z15.literal(ActionType.REJECT_CORRECTION),
|
|
1327
|
+
requestId: z15.string(),
|
|
1251
1328
|
// TODO move into 'content' property
|
|
1252
1329
|
content: ReasonContent
|
|
1253
1330
|
}).shape
|
|
1254
1331
|
);
|
|
1255
1332
|
var ReadAction = ActionBase.extend(
|
|
1256
|
-
|
|
1257
|
-
type:
|
|
1333
|
+
z15.object({
|
|
1334
|
+
type: z15.literal(ActionType.READ)
|
|
1258
1335
|
}).shape
|
|
1259
1336
|
);
|
|
1260
1337
|
var CustomAction = ActionBase.merge(
|
|
1261
|
-
|
|
1262
|
-
type:
|
|
1263
|
-
customActionType:
|
|
1338
|
+
z15.object({
|
|
1339
|
+
type: z15.literal(ActionType.CUSTOM),
|
|
1340
|
+
customActionType: z15.string()
|
|
1264
1341
|
})
|
|
1265
1342
|
);
|
|
1266
|
-
var ActionDocument =
|
|
1343
|
+
var ActionDocument = z15.discriminatedUnion("type", [
|
|
1267
1344
|
CreatedAction.meta({ id: "CreatedAction" }),
|
|
1268
1345
|
RejectAction.meta({ id: "RejectAction" }),
|
|
1269
1346
|
DuplicateDetectedAction.meta({ id: "DuplicateDetectedAction" }),
|
|
@@ -1286,68 +1363,16 @@ var ActionDocument = z14.discriminatedUnion("type", [
|
|
|
1286
1363
|
]).meta({
|
|
1287
1364
|
id: "ActionDocument"
|
|
1288
1365
|
});
|
|
1289
|
-
var AsyncRejectActionDocument = ActionBase.omit({
|
|
1290
|
-
declaration: true,
|
|
1291
|
-
annotation: true
|
|
1292
|
-
}).extend(
|
|
1293
|
-
|
|
1294
|
-
type:
|
|
1295
|
-
status:
|
|
1296
|
-
}).shape
|
|
1297
|
-
);
|
|
1298
|
-
var Action =
|
|
1299
|
-
|
|
1300
|
-
// ../commons/src/events/Flag.ts
|
|
1301
|
-
var z15 = __toESM(require("zod/v4"));
|
|
1302
|
-
var InherentFlags = {
|
|
1303
|
-
INCOMPLETE: "incomplete",
|
|
1304
|
-
REJECTED: "rejected",
|
|
1305
|
-
CORRECTION_REQUESTED: "correction-requested",
|
|
1306
|
-
POTENTIAL_DUPLICATE: "potential-duplicate",
|
|
1307
|
-
/**
|
|
1308
|
-
* This flag is set by the Edit-action and removed after the declaration or registration.
|
|
1309
|
-
* A record should never stay with the EDIT_IN_PROGRESS flag, since it should always be declared or registered right after.
|
|
1310
|
-
*
|
|
1311
|
-
* We only use this flag to determine that a NOTIFY, DECLARE or REGISTER action is allowed next.
|
|
1312
|
-
*/
|
|
1313
|
-
EDIT_IN_PROGRESS: "edit-in-progress"
|
|
1314
|
-
};
|
|
1315
|
-
var ActionFlag = z15.string().regex(
|
|
1316
|
-
new RegExp(
|
|
1317
|
-
`^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
|
|
1318
|
-
ActionStatus
|
|
1319
|
-
).join("|").toLowerCase()})$`
|
|
1320
|
-
),
|
|
1321
|
-
"Flag must be in the format ActionType:ActionStatus (lowerCase)"
|
|
1322
|
-
);
|
|
1323
|
-
var CustomFlag = z15.string().refine((val) => !Object.values(InherentFlags).includes(val), {
|
|
1324
|
-
message: `Custom flag cannot be one of the inherent flags: ${Object.values(
|
|
1325
|
-
InherentFlags
|
|
1326
|
-
).join(", ")}`
|
|
1327
|
-
}).refine((val) => !ActionFlag.safeParse(val).success, {
|
|
1328
|
-
message: "Custom flag cannot match the ActionFlag pattern (ActionType:ActionStatus)."
|
|
1329
|
-
}).describe("Custom flag identifier defined by the country config.");
|
|
1330
|
-
var Flag = ActionFlag.or(z15.enum(InherentFlags)).or(CustomFlag);
|
|
1331
|
-
var FlagConfig = z15.object({
|
|
1332
|
-
id: CustomFlag,
|
|
1333
|
-
requiresAction: z15.boolean().describe(
|
|
1334
|
-
"Indicates if this flag expects an action to be performed to be cleared."
|
|
1335
|
-
),
|
|
1336
|
-
label: TranslationConfig.describe("Human readable label of the flag.")
|
|
1337
|
-
}).meta({
|
|
1338
|
-
id: "FlagConfig",
|
|
1339
|
-
description: "Configuration for a custom flag that can be added to or removed from records by event actions."
|
|
1340
|
-
});
|
|
1341
|
-
var ActionFlagConfig = z15.object({
|
|
1342
|
-
id: Flag,
|
|
1343
|
-
operation: z15.enum(["add", "remove"]).describe("Operation to perform on the flag."),
|
|
1344
|
-
conditional: Conditional.optional().describe(
|
|
1345
|
-
"When conditional is met, the operation is performed on the flag. If not provided, the operation is performed unconditionally."
|
|
1346
|
-
)
|
|
1347
|
-
}).meta({
|
|
1348
|
-
id: "ActionFlagConfig",
|
|
1349
|
-
description: "Add or remove operation applied to a flag when the parent action is accepted. Optionally gated by a conditional."
|
|
1350
|
-
});
|
|
1366
|
+
var AsyncRejectActionDocument = ActionBase.omit({
|
|
1367
|
+
declaration: true,
|
|
1368
|
+
annotation: true
|
|
1369
|
+
}).extend(
|
|
1370
|
+
z15.object({
|
|
1371
|
+
type: z15.enum(ConfirmableActions),
|
|
1372
|
+
status: z15.literal(ActionStatus.Rejected)
|
|
1373
|
+
}).shape
|
|
1374
|
+
);
|
|
1375
|
+
var Action = z15.union([ActionDocument, AsyncRejectActionDocument]);
|
|
1351
1376
|
|
|
1352
1377
|
// ../commons/src/events/EventMetadata.ts
|
|
1353
1378
|
var EventStatus = z16.enum([
|
|
@@ -1505,13 +1530,6 @@ var Range = import_v4.z.object({
|
|
|
1505
1530
|
}).meta({
|
|
1506
1531
|
id: "Range"
|
|
1507
1532
|
});
|
|
1508
|
-
var ContainsFlags = import_v4.z.object({
|
|
1509
|
-
anyOf: import_v4.z.array(Flag).optional(),
|
|
1510
|
-
noneOf: import_v4.z.array(Flag).optional(),
|
|
1511
|
-
allOf: import_v4.z.array(Flag).optional()
|
|
1512
|
-
}).meta({
|
|
1513
|
-
id: "ContainsFlags"
|
|
1514
|
-
});
|
|
1515
1533
|
var Within = import_v4.z.object({ type: import_v4.z.literal("within"), location: import_v4.z.string() }).meta({
|
|
1516
1534
|
id: "Within"
|
|
1517
1535
|
});
|
|
@@ -3145,13 +3163,13 @@ var AdvancedSearchConfig = z28.object({
|
|
|
3145
3163
|
});
|
|
3146
3164
|
|
|
3147
3165
|
// ../commons/src/events/utils.ts
|
|
3148
|
-
var
|
|
3166
|
+
var import_lodash4 = require("lodash");
|
|
3149
3167
|
|
|
3150
3168
|
// ../commons/src/conditionals/validate.ts
|
|
3151
3169
|
var import__ = __toESM(require("ajv/dist/2019"));
|
|
3152
3170
|
var import_ajv_formats = __toESM(require("ajv-formats"));
|
|
3153
|
-
var
|
|
3154
|
-
var
|
|
3171
|
+
var z32 = __toESM(require("zod/v4"));
|
|
3172
|
+
var import_date_fns2 = require("date-fns");
|
|
3155
3173
|
|
|
3156
3174
|
// ../commons/src/events/FieldTypeMapping.ts
|
|
3157
3175
|
var z30 = __toESM(require("zod/v4"));
|
|
@@ -3159,152 +3177,26 @@ var z30 = __toESM(require("zod/v4"));
|
|
|
3159
3177
|
// ../commons/src/events/DynamicFieldValue.ts
|
|
3160
3178
|
var z29 = __toESM(require("zod/v4"));
|
|
3161
3179
|
|
|
3162
|
-
// ../commons/src/
|
|
3163
|
-
var
|
|
3164
|
-
$data: true,
|
|
3165
|
-
allowUnionTypes: true,
|
|
3166
|
-
strict: false
|
|
3167
|
-
// Allow minContains and other newer features
|
|
3168
|
-
});
|
|
3169
|
-
var DataContext = z31.object({
|
|
3170
|
-
rootData: z31.object({
|
|
3171
|
-
$leafAdminStructureLocationIds: z31.array(z31.object({ id: UUID }))
|
|
3172
|
-
})
|
|
3173
|
-
});
|
|
3174
|
-
function resolveDataPath(rootData, dataPath, instancePath) {
|
|
3175
|
-
const pathParts = dataPath.split("/");
|
|
3176
|
-
const levels = parseInt(pathParts[0], 10);
|
|
3177
|
-
const referencePath = pathParts.slice(1);
|
|
3178
|
-
const instanceParts = instancePath.split("/").filter(Boolean);
|
|
3179
|
-
const traversedParts = instanceParts.slice(0, -levels);
|
|
3180
|
-
let current = rootData;
|
|
3181
|
-
for (const part of traversedParts) {
|
|
3182
|
-
if (current === null || current === void 0) {
|
|
3183
|
-
return void 0;
|
|
3184
|
-
}
|
|
3185
|
-
current = current[part];
|
|
3186
|
-
}
|
|
3187
|
-
for (const part of referencePath) {
|
|
3188
|
-
if (current === null || current === void 0) {
|
|
3189
|
-
return void 0;
|
|
3190
|
-
}
|
|
3191
|
-
current = current[part];
|
|
3192
|
-
}
|
|
3193
|
-
return current;
|
|
3194
|
-
}
|
|
3195
|
-
function todayISO() {
|
|
3196
|
-
return (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
|
|
3197
|
-
}
|
|
3198
|
-
var compiledFunctionCache = /* @__PURE__ */ new Map();
|
|
3199
|
-
function compileClientFunction(code) {
|
|
3200
|
-
let fn = compiledFunctionCache.get(code);
|
|
3201
|
-
if (!fn) {
|
|
3202
|
-
fn = new Function(`return (${code})`)();
|
|
3203
|
-
compiledFunctionCache.set(code, fn);
|
|
3204
|
-
}
|
|
3205
|
-
return fn;
|
|
3206
|
-
}
|
|
3207
|
-
(0, import_ajv_formats.default)(ajv);
|
|
3208
|
-
function buildClientFunctionContext(input) {
|
|
3209
|
-
return {
|
|
3210
|
-
$form: input.form,
|
|
3211
|
-
$now: todayISO(),
|
|
3212
|
-
// eslint-disable-next-line @typescript-eslint/no-use-before-define
|
|
3213
|
-
$online: isOnline(),
|
|
3214
|
-
$user: input.validatorContext?.user,
|
|
3215
|
-
$event: input.validatorContext?.event,
|
|
3216
|
-
$leafAdminStructureLocationIds: input.validatorContext?.leafAdminStructureLocationIds ?? [],
|
|
3217
|
-
user: input.systemVariables?.user,
|
|
3218
|
-
$window: input.systemVariables?.$window,
|
|
3219
|
-
locations: input.locations,
|
|
3220
|
-
adminLevelIds: input.adminLevelIds
|
|
3221
|
-
};
|
|
3222
|
-
}
|
|
3223
|
-
function runClientFunction(code, data, context) {
|
|
3224
|
-
return compileClientFunction(code)(data, context);
|
|
3225
|
-
}
|
|
3226
|
-
ajv.addKeyword({
|
|
3227
|
-
keyword: "daysFromDate",
|
|
3228
|
-
type: "string",
|
|
3229
|
-
schemaType: "object",
|
|
3230
|
-
$data: true,
|
|
3231
|
-
errors: true,
|
|
3232
|
-
validate(schema, data, _2, dataContext) {
|
|
3233
|
-
if (!(dataContext && dataContext.rootData && typeof dataContext.rootData === "object" && "$now" in dataContext.rootData && typeof dataContext.rootData.$now === "string")) {
|
|
3234
|
-
throw new Error("Validation context must contain $now");
|
|
3235
|
-
}
|
|
3236
|
-
const { days, clause } = schema;
|
|
3237
|
-
if (typeof data !== "string") {
|
|
3238
|
-
return false;
|
|
3239
|
-
}
|
|
3240
|
-
const date = new Date(data);
|
|
3241
|
-
if (isNaN(date.getTime())) {
|
|
3242
|
-
return false;
|
|
3243
|
-
}
|
|
3244
|
-
let referenceDate = schema.referenceDate;
|
|
3245
|
-
if (referenceDate && typeof referenceDate === "object" && "$data" in referenceDate) {
|
|
3246
|
-
referenceDate = resolveDataPath(
|
|
3247
|
-
dataContext.rootData,
|
|
3248
|
-
referenceDate.$data,
|
|
3249
|
-
dataContext.instancePath
|
|
3250
|
-
);
|
|
3251
|
-
}
|
|
3252
|
-
if (!referenceDate) {
|
|
3253
|
-
referenceDate = dataContext.rootData.$now;
|
|
3254
|
-
}
|
|
3255
|
-
const baseDate = new Date(referenceDate);
|
|
3256
|
-
if (isNaN(baseDate.getTime())) {
|
|
3257
|
-
return false;
|
|
3258
|
-
}
|
|
3259
|
-
const offsetDate = new Date(baseDate.getTime() + days * 24 * 60 * 60 * 1e3);
|
|
3260
|
-
return clause === "after" ? (0, import_date_fns.isAfter)(date, offsetDate) : (0, import_date_fns.isBefore)(date, offsetDate);
|
|
3261
|
-
}
|
|
3262
|
-
});
|
|
3263
|
-
ajv.addKeyword({
|
|
3264
|
-
keyword: "isLeafLevelLocation",
|
|
3265
|
-
type: "string",
|
|
3266
|
-
schemaType: "boolean",
|
|
3267
|
-
$data: true,
|
|
3268
|
-
errors: true,
|
|
3269
|
-
// @ts-ignore -- Force type. We will move this away from AJV next. Parsing the array will take seconds and is only called by core.
|
|
3270
|
-
validate(_schema, data, _2, dataContext) {
|
|
3271
|
-
const locationIdInput = data;
|
|
3272
|
-
const locations = dataContext?.rootData.$leafAdminStructureLocationIds ?? [];
|
|
3273
|
-
return locations.some((location) => location.id === locationIdInput);
|
|
3274
|
-
}
|
|
3275
|
-
});
|
|
3276
|
-
ajv.addKeyword({
|
|
3277
|
-
keyword: "customClientValidator",
|
|
3278
|
-
schemaType: "object",
|
|
3279
|
-
errors: true,
|
|
3280
|
-
// @ts-expect-error -- AJV's public types don't expose `rootData`. All
|
|
3281
|
-
// `validate()` callers build root data via `buildClientFunctionContext`,
|
|
3282
|
-
// so the cast holds.
|
|
3283
|
-
validate(schema, data, _2, dataContext) {
|
|
3284
|
-
return Boolean(
|
|
3285
|
-
runClientFunction(
|
|
3286
|
-
schema.code,
|
|
3287
|
-
data,
|
|
3288
|
-
dataContext?.rootData ?? buildClientFunctionContext({ form: {} })
|
|
3289
|
-
)
|
|
3290
|
-
);
|
|
3291
|
-
}
|
|
3292
|
-
});
|
|
3293
|
-
function isOnline() {
|
|
3294
|
-
if (typeof window !== "undefined" && typeof navigator !== "undefined") {
|
|
3295
|
-
return navigator.onLine;
|
|
3296
|
-
}
|
|
3297
|
-
return true;
|
|
3298
|
-
}
|
|
3180
|
+
// ../commons/src/events/state/index.ts
|
|
3181
|
+
var import_lodash3 = require("lodash");
|
|
3299
3182
|
|
|
3300
3183
|
// ../commons/src/utils.ts
|
|
3301
|
-
var
|
|
3184
|
+
var z31 = __toESM(require("zod/v4"));
|
|
3302
3185
|
var _ = __toESM(require("lodash"));
|
|
3303
|
-
|
|
3304
|
-
|
|
3305
|
-
|
|
3306
|
-
|
|
3307
|
-
|
|
3186
|
+
function getOrThrow(x, message) {
|
|
3187
|
+
if (x === void 0 || x === null) {
|
|
3188
|
+
throw new Error(message);
|
|
3189
|
+
}
|
|
3190
|
+
return x;
|
|
3191
|
+
}
|
|
3192
|
+
function joinValues(values, separator = " ") {
|
|
3193
|
+
return values.filter((value) => !!value).join(separator).trim();
|
|
3194
|
+
}
|
|
3195
|
+
var FullNameV1 = z31.array(
|
|
3196
|
+
z31.object({
|
|
3197
|
+
use: z31.string(),
|
|
3198
|
+
family: z31.string(),
|
|
3199
|
+
given: z31.array(z31.string())
|
|
3308
3200
|
})
|
|
3309
3201
|
);
|
|
3310
3202
|
function omitKeyDeep(obj, keyToRemove) {
|
|
@@ -3322,37 +3214,263 @@ function omitKeyDeep(obj, keyToRemove) {
|
|
|
3322
3214
|
}
|
|
3323
3215
|
return newObj;
|
|
3324
3216
|
}
|
|
3325
|
-
|
|
3326
|
-
// ../commons/src/events/utils.ts
|
|
3327
|
-
var
|
|
3328
|
-
function
|
|
3329
|
-
|
|
3217
|
+
|
|
3218
|
+
// ../commons/src/events/state/utils.ts
|
|
3219
|
+
var import_lodash = require("lodash");
|
|
3220
|
+
function getActionRequests(actionType, actions) {
|
|
3221
|
+
const filtered = actions.filter((action) => action.type === actionType).reverse();
|
|
3222
|
+
const accept = filtered.find(
|
|
3223
|
+
(action) => action.status === ActionStatus.Accepted
|
|
3224
|
+
);
|
|
3225
|
+
const request = filtered.find(
|
|
3226
|
+
(action) => action.status === ActionStatus.Requested
|
|
3227
|
+
);
|
|
3228
|
+
const reject = filtered.find(
|
|
3229
|
+
(action) => action.status === ActionStatus.Rejected
|
|
3230
|
+
);
|
|
3231
|
+
return {
|
|
3232
|
+
reject,
|
|
3233
|
+
accept,
|
|
3234
|
+
request
|
|
3235
|
+
};
|
|
3236
|
+
}
|
|
3237
|
+
function getDeclarationActionCreationMetadata(actionType, actions) {
|
|
3238
|
+
const { accept: acceptAction, request: requestAction } = getActionRequests(
|
|
3239
|
+
actionType,
|
|
3240
|
+
actions
|
|
3241
|
+
);
|
|
3242
|
+
if (!acceptAction) {
|
|
3243
|
+
return null;
|
|
3244
|
+
}
|
|
3245
|
+
const registrationNumber = acceptAction.type === ActionType.REGISTER ? acceptAction.registrationNumber : null;
|
|
3246
|
+
return {
|
|
3247
|
+
// When 3rd party API returns 200 OK, we assume that the request was accepted, and persist single 'accepted' action.
|
|
3248
|
+
createdAt: requestAction?.createdAt ?? acceptAction.createdAt,
|
|
3249
|
+
createdBy: requestAction?.createdBy ?? acceptAction.createdBy,
|
|
3250
|
+
createdByUserType: requestAction?.createdByUserType ?? acceptAction.createdByUserType,
|
|
3251
|
+
createdAtLocation: requestAction?.createdAtLocation ?? acceptAction.createdAtLocation,
|
|
3252
|
+
acceptedAt: acceptAction.createdAt,
|
|
3253
|
+
createdByRole: requestAction?.createdByRole ?? acceptAction.createdByRole,
|
|
3254
|
+
registrationNumber
|
|
3255
|
+
};
|
|
3256
|
+
}
|
|
3257
|
+
var updateActions = ActionTypes.extract([
|
|
3258
|
+
ActionType.CREATE,
|
|
3259
|
+
ActionType.NOTIFY,
|
|
3260
|
+
ActionType.EDIT,
|
|
3261
|
+
ActionType.DECLARE,
|
|
3262
|
+
ActionType.REGISTER,
|
|
3263
|
+
ActionType.REJECT,
|
|
3264
|
+
ActionType.ARCHIVE,
|
|
3265
|
+
ActionType.UNARCHIVE,
|
|
3266
|
+
ActionType.PRINT_CERTIFICATE,
|
|
3267
|
+
ActionType.REQUEST_CORRECTION,
|
|
3268
|
+
ActionType.APPROVE_CORRECTION,
|
|
3269
|
+
ActionType.REJECT_CORRECTION,
|
|
3270
|
+
ActionType.CUSTOM
|
|
3271
|
+
]);
|
|
3272
|
+
function getActionUpdateMetadata(actions) {
|
|
3273
|
+
const createAction = getOrThrow(
|
|
3274
|
+
actions.find((action) => action.type === ActionType.CREATE),
|
|
3275
|
+
`Event has no ${ActionType.CREATE} action`
|
|
3276
|
+
);
|
|
3277
|
+
const metadataFields = [
|
|
3278
|
+
"createdAt",
|
|
3279
|
+
"createdBy",
|
|
3280
|
+
"createdByUserType",
|
|
3281
|
+
"createdAtLocation",
|
|
3282
|
+
"createdByRole"
|
|
3283
|
+
];
|
|
3284
|
+
return actions.filter(({ type }) => updateActions.safeParse(type).success).reduce(
|
|
3285
|
+
(_2, action) => {
|
|
3286
|
+
if (action.originalActionId) {
|
|
3287
|
+
const originalAction = actions.find(({ id }) => id === action.originalActionId) ?? action;
|
|
3288
|
+
return (0, import_lodash.pick)(originalAction, metadataFields);
|
|
3289
|
+
}
|
|
3290
|
+
return (0, import_lodash.pick)(action, metadataFields);
|
|
3291
|
+
},
|
|
3292
|
+
(0, import_lodash.pick)(createAction, metadataFields)
|
|
3293
|
+
);
|
|
3294
|
+
}
|
|
3295
|
+
function getLegalStatuses(actions) {
|
|
3296
|
+
return {
|
|
3297
|
+
[EventStatus.enum.NOTIFIED]: getDeclarationActionCreationMetadata(
|
|
3298
|
+
ActionType.NOTIFY,
|
|
3299
|
+
actions
|
|
3300
|
+
),
|
|
3301
|
+
[EventStatus.enum.DECLARED]: getDeclarationActionCreationMetadata(
|
|
3302
|
+
ActionType.DECLARE,
|
|
3303
|
+
actions
|
|
3304
|
+
),
|
|
3305
|
+
[EventStatus.enum.REGISTERED]: getDeclarationActionCreationMetadata(
|
|
3306
|
+
ActionType.REGISTER,
|
|
3307
|
+
actions
|
|
3308
|
+
)
|
|
3309
|
+
};
|
|
3310
|
+
}
|
|
3311
|
+
|
|
3312
|
+
// ../commons/src/events/state/flags.ts
|
|
3313
|
+
var import_lodash2 = require("lodash");
|
|
3314
|
+
var import_date_fns = require("date-fns");
|
|
3315
|
+
function isFlagConditionMet(conditional, form, action) {
|
|
3316
|
+
const now2 = (0, import_date_fns.isValid)((0, import_date_fns.parseISO)(action.createdAt)) ? (0, import_date_fns.formatISO)((0, import_date_fns.parseISO)(action.createdAt), { representation: "date" }) : (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
|
|
3317
|
+
return validate(conditional, {
|
|
3318
|
+
$form: form,
|
|
3319
|
+
$now: now2,
|
|
3320
|
+
$online: true,
|
|
3321
|
+
$user: {
|
|
3322
|
+
sub: "",
|
|
3323
|
+
exp: "",
|
|
3324
|
+
role: action.createdByRole,
|
|
3325
|
+
algorithm: "",
|
|
3326
|
+
scope: [],
|
|
3327
|
+
userType: action.createdByUserType
|
|
3328
|
+
}
|
|
3329
|
+
});
|
|
3330
|
+
}
|
|
3331
|
+
function actionConfigRemovesFlag(action, flagId, actionsUpToAndIncluding, event2, eventConfiguration) {
|
|
3332
|
+
if (!isActionConfigType(action.type)) {
|
|
3333
|
+
return false;
|
|
3334
|
+
}
|
|
3335
|
+
const actionConfig = getActionConfig({
|
|
3336
|
+
eventConfiguration,
|
|
3337
|
+
actionType: action.type,
|
|
3338
|
+
customActionType: "customActionType" in action ? action.customActionType : void 0
|
|
3339
|
+
});
|
|
3340
|
+
const removeOperations = (actionConfig?.flags ?? []).filter(
|
|
3341
|
+
({ id, operation }) => id === flagId && operation === "remove"
|
|
3342
|
+
);
|
|
3343
|
+
if (removeOperations.length === 0) {
|
|
3344
|
+
return false;
|
|
3345
|
+
}
|
|
3346
|
+
const eventUpToThisAction = { ...event2, actions: actionsUpToAndIncluding };
|
|
3347
|
+
const declaration = aggregateActionDeclarations(eventUpToThisAction);
|
|
3348
|
+
const annotation = aggregateActionAnnotations(eventUpToThisAction);
|
|
3349
|
+
const form = { ...declaration, ...annotation };
|
|
3350
|
+
return removeOperations.some(
|
|
3351
|
+
({ conditional }) => conditional ? isFlagConditionMet(conditional, form, action) : true
|
|
3352
|
+
);
|
|
3353
|
+
}
|
|
3354
|
+
var INHERENT_FLAG_RULES = [
|
|
3355
|
+
{
|
|
3356
|
+
flag: InherentFlags.CORRECTION_REQUESTED,
|
|
3357
|
+
setOn: [ActionType.REQUEST_CORRECTION],
|
|
3358
|
+
resetOn: [ActionType.APPROVE_CORRECTION, ActionType.REJECT_CORRECTION]
|
|
3359
|
+
},
|
|
3360
|
+
{
|
|
3361
|
+
// INCOMPLETE mirrors the NOTIFIED status: set by NOTIFY, cleared by any
|
|
3362
|
+
// other status-changing action (see getStatusFromActions). ARCHIVE/UNARCHIVE
|
|
3363
|
+
// are deliberately excluded so the flag freezes across an archive/unarchive
|
|
3364
|
+
// round trip and comes back exactly as it was.
|
|
3365
|
+
flag: InherentFlags.INCOMPLETE,
|
|
3366
|
+
setOn: [ActionType.NOTIFY],
|
|
3367
|
+
resetOn: [ActionType.CREATE, ActionType.DECLARE, ActionType.REGISTER]
|
|
3368
|
+
},
|
|
3369
|
+
{
|
|
3370
|
+
flag: InherentFlags.REJECTED,
|
|
3371
|
+
setOn: [ActionType.REJECT],
|
|
3372
|
+
resetOn: [
|
|
3373
|
+
ActionType.NOTIFY,
|
|
3374
|
+
ActionType.DECLARE,
|
|
3375
|
+
ActionType.EDIT,
|
|
3376
|
+
ActionType.REGISTER
|
|
3377
|
+
]
|
|
3378
|
+
},
|
|
3379
|
+
{
|
|
3380
|
+
flag: InherentFlags.POTENTIAL_DUPLICATE,
|
|
3381
|
+
setOn: [ActionType.DUPLICATE_DETECTED],
|
|
3382
|
+
resetOn: [ActionType.MARK_AS_DUPLICATE, ActionType.MARK_AS_NOT_DUPLICATE]
|
|
3383
|
+
},
|
|
3384
|
+
{
|
|
3385
|
+
flag: InherentFlags.EDIT_IN_PROGRESS,
|
|
3386
|
+
setOn: [ActionType.EDIT],
|
|
3387
|
+
resetOnAnyOtherAction: true
|
|
3388
|
+
}
|
|
3389
|
+
];
|
|
3390
|
+
function resolveInherentFlag(rule, acceptedActions, event2, eventConfiguration) {
|
|
3391
|
+
return acceptedActions.reduce((present, action, idx) => {
|
|
3392
|
+
if (rule.setOn.includes(action.type)) {
|
|
3393
|
+
return true;
|
|
3394
|
+
}
|
|
3395
|
+
if (rule.resetOnAnyOtherAction || (rule.resetOn ?? []).includes(action.type)) {
|
|
3396
|
+
return false;
|
|
3397
|
+
}
|
|
3398
|
+
if (actionConfigRemovesFlag(
|
|
3399
|
+
action,
|
|
3400
|
+
rule.flag,
|
|
3401
|
+
acceptedActions.slice(0, idx + 1),
|
|
3402
|
+
event2,
|
|
3403
|
+
eventConfiguration
|
|
3404
|
+
)) {
|
|
3405
|
+
return false;
|
|
3406
|
+
}
|
|
3407
|
+
return present;
|
|
3408
|
+
}, false);
|
|
3409
|
+
}
|
|
3410
|
+
function resolveEventCustomFlags(event2, eventConfiguration) {
|
|
3411
|
+
const actions = getAcceptedActions(event2).filter(({ type }) => !isMetaAction(type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
3412
|
+
return actions.reduce((acc, action, idx) => {
|
|
3413
|
+
let actionConfig;
|
|
3414
|
+
if (isActionConfigType(action.type)) {
|
|
3415
|
+
actionConfig = getActionConfig({
|
|
3416
|
+
eventConfiguration,
|
|
3417
|
+
actionType: action.type,
|
|
3418
|
+
customActionType: "customActionType" in action ? action.customActionType : void 0
|
|
3419
|
+
});
|
|
3420
|
+
}
|
|
3421
|
+
if (!actionConfig) {
|
|
3422
|
+
return acc;
|
|
3423
|
+
}
|
|
3424
|
+
const eventUpToThisAction = {
|
|
3425
|
+
...event2,
|
|
3426
|
+
actions: actions.slice(0, idx + 1)
|
|
3427
|
+
};
|
|
3428
|
+
const declaration = aggregateActionDeclarations(eventUpToThisAction);
|
|
3429
|
+
const annotation = aggregateActionAnnotations(eventUpToThisAction);
|
|
3430
|
+
const form = { ...declaration, ...annotation };
|
|
3431
|
+
const flagsWithMetConditions = (actionConfig.flags ?? []).filter(
|
|
3432
|
+
({ conditional }) => (
|
|
3433
|
+
// If conditional is not provided, the flag is resolved
|
|
3434
|
+
conditional ? isFlagConditionMet(conditional, form, action) : true
|
|
3435
|
+
)
|
|
3436
|
+
);
|
|
3437
|
+
const addedFlags = flagsWithMetConditions.filter(({ operation }) => operation === "add").map(({ id }) => id);
|
|
3438
|
+
const removedFlags = flagsWithMetConditions.filter(({ operation }) => operation === "remove").map(({ id }) => id);
|
|
3439
|
+
const flags = [...acc, ...addedFlags].filter(
|
|
3440
|
+
(flagId) => !removedFlags.includes(flagId)
|
|
3441
|
+
);
|
|
3442
|
+
return (0, import_lodash2.uniq)(flags);
|
|
3443
|
+
}, []);
|
|
3444
|
+
}
|
|
3445
|
+
function getActionStatusFlags(sortedActions) {
|
|
3446
|
+
const actionStatus = sortedActions.reduce(
|
|
3447
|
+
(actionStatuses, { type, status }) => ({
|
|
3448
|
+
...actionStatuses,
|
|
3449
|
+
[type]: status
|
|
3450
|
+
}),
|
|
3451
|
+
{}
|
|
3452
|
+
);
|
|
3453
|
+
return Object.entries(actionStatus).filter(([, status]) => status !== ActionStatus.Accepted).map(([type, status]) => {
|
|
3454
|
+
const flag = joinValues([type, status], ":").toLowerCase();
|
|
3455
|
+
return flag;
|
|
3456
|
+
});
|
|
3330
3457
|
}
|
|
3331
|
-
|
|
3332
|
-
|
|
3333
|
-
|
|
3334
|
-
|
|
3335
|
-
|
|
3336
|
-
|
|
3337
|
-
}
|
|
3338
|
-
|
|
3339
|
-
|
|
3340
|
-
|
|
3341
|
-
|
|
3342
|
-
|
|
3343
|
-
|
|
3458
|
+
function getInherentFlags(sortedActions, event2, eventConfiguration) {
|
|
3459
|
+
const acceptedActions = sortedActions.filter(
|
|
3460
|
+
({ status }) => status === ActionStatus.Accepted
|
|
3461
|
+
);
|
|
3462
|
+
return INHERENT_FLAG_RULES.filter(
|
|
3463
|
+
(rule) => resolveInherentFlag(rule, acceptedActions, event2, eventConfiguration)
|
|
3464
|
+
).map(({ flag }) => flag);
|
|
3465
|
+
}
|
|
3466
|
+
function getEventFlags(event2, config) {
|
|
3467
|
+
const sortedActions = event2.actions.filter(({ type }) => !isMetaAction(type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
3468
|
+
return [
|
|
3469
|
+
...getActionStatusFlags(sortedActions),
|
|
3470
|
+
...getInherentFlags(sortedActions, event2, config),
|
|
3471
|
+
...resolveEventCustomFlags(event2, config)
|
|
3472
|
+
];
|
|
3344
3473
|
}
|
|
3345
|
-
var findAllFields = (config) => {
|
|
3346
|
-
return (0, import_lodash.flattenDeep)([
|
|
3347
|
-
...getDeclarationFields(config),
|
|
3348
|
-
...getAllAnnotationFields(config)
|
|
3349
|
-
]);
|
|
3350
|
-
};
|
|
3351
|
-
var EXCLUDED_ACTIONS = [
|
|
3352
|
-
ActionType.REQUEST_CORRECTION,
|
|
3353
|
-
ActionType.PRINT_CERTIFICATE,
|
|
3354
|
-
ActionType.REJECT_CORRECTION
|
|
3355
|
-
];
|
|
3356
3474
|
|
|
3357
3475
|
// ../commons/src/conditionals/conditionals.ts
|
|
3358
3476
|
var objectHash = __toESM(require("object-hash"));
|
|
@@ -3881,84 +3999,590 @@ function createFieldConditionals(fieldId) {
|
|
|
3881
3999
|
},
|
|
3882
4000
|
this.$$subfield
|
|
3883
4001
|
)
|
|
3884
|
-
},
|
|
3885
|
-
required: [fieldId]
|
|
3886
|
-
});
|
|
3887
|
-
},
|
|
3888
|
-
getId: () => ({ fieldId }),
|
|
3889
|
-
/**
|
|
3890
|
-
* @deprecated
|
|
3891
|
-
* use field(fieldId).get(nestedProperty) instead
|
|
3892
|
-
* with 'and' combinator e.g.
|
|
3893
|
-
* and(
|
|
3894
|
-
* field('child.name').get('firstname').isEqualTo('John'),
|
|
3895
|
-
* field('child.name').get('surname').isEqualTo('Doe')
|
|
3896
|
-
* )
|
|
3897
|
-
*/
|
|
3898
|
-
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
3899
|
-
object: (options) => defineFormConditional({
|
|
3900
|
-
type: "object",
|
|
3901
|
-
properties: {
|
|
3902
|
-
[fieldId]: {
|
|
3903
|
-
type: "object",
|
|
3904
|
-
properties: Object.fromEntries(
|
|
3905
|
-
Object.entries(options).map(([key, value]) => {
|
|
3906
|
-
return [key, value.properties.$form.properties[key]];
|
|
3907
|
-
})
|
|
3908
|
-
),
|
|
3909
|
-
required: Object.keys(options)
|
|
4002
|
+
},
|
|
4003
|
+
required: [fieldId]
|
|
4004
|
+
});
|
|
4005
|
+
},
|
|
4006
|
+
getId: () => ({ fieldId }),
|
|
4007
|
+
/**
|
|
4008
|
+
* @deprecated
|
|
4009
|
+
* use field(fieldId).get(nestedProperty) instead
|
|
4010
|
+
* with 'and' combinator e.g.
|
|
4011
|
+
* and(
|
|
4012
|
+
* field('child.name').get('firstname').isEqualTo('John'),
|
|
4013
|
+
* field('child.name').get('surname').isEqualTo('Doe')
|
|
4014
|
+
* )
|
|
4015
|
+
*/
|
|
4016
|
+
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
4017
|
+
object: (options) => defineFormConditional({
|
|
4018
|
+
type: "object",
|
|
4019
|
+
properties: {
|
|
4020
|
+
[fieldId]: {
|
|
4021
|
+
type: "object",
|
|
4022
|
+
properties: Object.fromEntries(
|
|
4023
|
+
Object.entries(options).map(([key, value]) => {
|
|
4024
|
+
return [key, value.properties.$form.properties[key]];
|
|
4025
|
+
})
|
|
4026
|
+
),
|
|
4027
|
+
required: Object.keys(options)
|
|
4028
|
+
}
|
|
4029
|
+
},
|
|
4030
|
+
required: [fieldId]
|
|
4031
|
+
}),
|
|
4032
|
+
/**
|
|
4033
|
+
* Custom client-side validator. The provided function is serialised and executed
|
|
4034
|
+
* just-in-time on the client only. External references (e.g. lodash) are not
|
|
4035
|
+
* available inside the function body — all logic must be self-contained.
|
|
4036
|
+
*
|
|
4037
|
+
* @example
|
|
4038
|
+
* field('nid').customClientValidator((value) => {
|
|
4039
|
+
* // LUHN check — all logic must be inline
|
|
4040
|
+
* const digits = String(value).split('').map(Number)
|
|
4041
|
+
* // ...
|
|
4042
|
+
* return isValid
|
|
4043
|
+
* })
|
|
4044
|
+
*/
|
|
4045
|
+
customClientValidator(validationFn) {
|
|
4046
|
+
const code = validationFn.toString();
|
|
4047
|
+
return defineFormConditional({
|
|
4048
|
+
type: "object",
|
|
4049
|
+
properties: wrapToPath(
|
|
4050
|
+
{ [fieldId]: { customClientValidator: { code } } },
|
|
4051
|
+
this.$$subfield
|
|
4052
|
+
),
|
|
4053
|
+
required: [fieldId]
|
|
4054
|
+
});
|
|
4055
|
+
},
|
|
4056
|
+
/**
|
|
4057
|
+
* Custom client-side evaluation. Returns a {@link FieldReference} descriptor
|
|
4058
|
+
* that can be used as the `value` property or a DATA component entry.
|
|
4059
|
+
* The function receives the referenced field's value as the first argument and
|
|
4060
|
+
* the full form context as the second; its return value replaces the field reference.
|
|
4061
|
+
* The function is serialised and executed just-in-time on the client only.
|
|
4062
|
+
* External references (e.g. lodash) are not available inside the function body.
|
|
4063
|
+
*
|
|
4064
|
+
* For computing a default value without referencing a specific field, use
|
|
4065
|
+
* `evaluate(fn)` in the `defaultValue` property instead.
|
|
4066
|
+
*
|
|
4067
|
+
* @example
|
|
4068
|
+
* field('a').customClientEvaluation((aValue, ctx) =>
|
|
4069
|
+
* Number(aValue) + Number(ctx.$form.b)
|
|
4070
|
+
* )
|
|
4071
|
+
*/
|
|
4072
|
+
customClientEvaluation(computationFn) {
|
|
4073
|
+
return {
|
|
4074
|
+
$$code: computationFn.toString(),
|
|
4075
|
+
$$field: fieldId,
|
|
4076
|
+
$$subfield: this.$$subfield
|
|
4077
|
+
};
|
|
4078
|
+
}
|
|
4079
|
+
};
|
|
4080
|
+
}
|
|
4081
|
+
|
|
4082
|
+
// ../commons/src/events/state/index.ts
|
|
4083
|
+
function getStatusFromActions(actions) {
|
|
4084
|
+
const acceptedActions = actions.filter(
|
|
4085
|
+
({ status }) => status === ActionStatus.Accepted
|
|
4086
|
+
);
|
|
4087
|
+
const isCurrentlyArchived = acceptedActions.reduce(
|
|
4088
|
+
(archived, action) => {
|
|
4089
|
+
if (action.type === ActionType.ARCHIVE) {
|
|
4090
|
+
return true;
|
|
4091
|
+
}
|
|
4092
|
+
if (action.type === ActionType.UNARCHIVE) {
|
|
4093
|
+
return false;
|
|
4094
|
+
}
|
|
4095
|
+
return archived;
|
|
4096
|
+
},
|
|
4097
|
+
false
|
|
4098
|
+
);
|
|
4099
|
+
if (isCurrentlyArchived) {
|
|
4100
|
+
return EventStatus.enum.ARCHIVED;
|
|
4101
|
+
}
|
|
4102
|
+
return acceptedActions.filter(
|
|
4103
|
+
({ type }) => type !== ActionType.ARCHIVE && type !== ActionType.UNARCHIVE
|
|
4104
|
+
).reduce((status, action) => {
|
|
4105
|
+
switch (action.type) {
|
|
4106
|
+
case ActionType.CREATE:
|
|
4107
|
+
return EventStatus.enum.CREATED;
|
|
4108
|
+
case ActionType.DECLARE:
|
|
4109
|
+
return EventStatus.enum.DECLARED;
|
|
4110
|
+
case ActionType.REGISTER:
|
|
4111
|
+
return EventStatus.enum.REGISTERED;
|
|
4112
|
+
case ActionType.NOTIFY:
|
|
4113
|
+
return EventStatus.enum.NOTIFIED;
|
|
4114
|
+
// Already filtered out above; listed here only to satisfy exhaustiveness.
|
|
4115
|
+
case ActionType.ARCHIVE:
|
|
4116
|
+
case ActionType.UNARCHIVE:
|
|
4117
|
+
case ActionType.CUSTOM:
|
|
4118
|
+
case ActionType.PRINT_CERTIFICATE:
|
|
4119
|
+
case ActionType.ASSIGN:
|
|
4120
|
+
case ActionType.UNASSIGN:
|
|
4121
|
+
case ActionType.REJECT:
|
|
4122
|
+
case ActionType.REQUEST_CORRECTION:
|
|
4123
|
+
case ActionType.APPROVE_CORRECTION:
|
|
4124
|
+
case ActionType.DUPLICATE_DETECTED:
|
|
4125
|
+
case ActionType.MARK_AS_NOT_DUPLICATE:
|
|
4126
|
+
case ActionType.MARK_AS_DUPLICATE:
|
|
4127
|
+
case ActionType.REJECT_CORRECTION:
|
|
4128
|
+
case ActionType.READ:
|
|
4129
|
+
case ActionType.EDIT:
|
|
4130
|
+
default:
|
|
4131
|
+
return status;
|
|
4132
|
+
}
|
|
4133
|
+
}, EventStatus.enum.CREATED);
|
|
4134
|
+
}
|
|
4135
|
+
function getAssignedUserFromActions(actions) {
|
|
4136
|
+
return actions.reduce((user2, action) => {
|
|
4137
|
+
if (action.type === ActionType.ASSIGN) {
|
|
4138
|
+
return action.assignedTo;
|
|
4139
|
+
}
|
|
4140
|
+
if (action.type === ActionType.UNASSIGN) {
|
|
4141
|
+
return null;
|
|
4142
|
+
}
|
|
4143
|
+
return user2;
|
|
4144
|
+
}, null);
|
|
4145
|
+
}
|
|
4146
|
+
function deepDropNulls(obj) {
|
|
4147
|
+
if (Array.isArray(obj)) {
|
|
4148
|
+
return obj.map(deepDropNulls);
|
|
4149
|
+
}
|
|
4150
|
+
if (obj !== null && typeof obj === "object") {
|
|
4151
|
+
return Object.entries(obj).reduce((acc, [key, value]) => {
|
|
4152
|
+
const cleanedValue = deepDropNulls(value);
|
|
4153
|
+
if (cleanedValue !== null) {
|
|
4154
|
+
;
|
|
4155
|
+
acc[key] = cleanedValue;
|
|
4156
|
+
}
|
|
4157
|
+
return acc;
|
|
4158
|
+
}, {});
|
|
4159
|
+
}
|
|
4160
|
+
return obj;
|
|
4161
|
+
}
|
|
4162
|
+
var DEFAULT_DATE_OF_EVENT_PROPERTY = "createdAt";
|
|
4163
|
+
function extractDateString(dateTime) {
|
|
4164
|
+
return dateTime.split("T")[0];
|
|
4165
|
+
}
|
|
4166
|
+
function resolveDateOfEvent(eventIndex, declaration, config) {
|
|
4167
|
+
if (!config.dateOfEvent) {
|
|
4168
|
+
return extractDateString(eventIndex[DEFAULT_DATE_OF_EVENT_PROPERTY]);
|
|
4169
|
+
}
|
|
4170
|
+
const parsedDate = isFieldReference(config.dateOfEvent) ? ZodDate.safeParse(declaration[config.dateOfEvent.$$field]) : ZodDateTime.safeParse(
|
|
4171
|
+
getMixedPath(eventIndex, config.dateOfEvent.$$event)
|
|
4172
|
+
);
|
|
4173
|
+
return parsedDate.success ? extractDateString(parsedDate.data) : void 0;
|
|
4174
|
+
}
|
|
4175
|
+
var DEFAULT_PLACE_OF_EVENT_PROPERTY = "createdAtLocation";
|
|
4176
|
+
function getParsedUUID(value, oldValue) {
|
|
4177
|
+
const parsed = UUID.safeParse(value);
|
|
4178
|
+
return parsed.success ? parsed.data : oldValue;
|
|
4179
|
+
}
|
|
4180
|
+
function resolvePlaceOfEvent(eventMetadata, declaration, config) {
|
|
4181
|
+
let placeOfEvent = getParsedUUID(
|
|
4182
|
+
eventMetadata[DEFAULT_PLACE_OF_EVENT_PROPERTY]
|
|
4183
|
+
);
|
|
4184
|
+
if (config.placeOfEvent) {
|
|
4185
|
+
const addressFieldValue = AddressFieldValue.safeParse(
|
|
4186
|
+
declaration[config.placeOfEvent.$$field]
|
|
4187
|
+
);
|
|
4188
|
+
if (addressFieldValue.success && addressFieldValue.data.addressType === AddressType.DOMESTIC && addressFieldValue.data.administrativeArea) {
|
|
4189
|
+
placeOfEvent = getParsedUUID(
|
|
4190
|
+
addressFieldValue.data.administrativeArea,
|
|
4191
|
+
placeOfEvent
|
|
4192
|
+
);
|
|
4193
|
+
} else {
|
|
4194
|
+
placeOfEvent = getParsedUUID(
|
|
4195
|
+
declaration[config.placeOfEvent.$$field],
|
|
4196
|
+
placeOfEvent
|
|
4197
|
+
);
|
|
4198
|
+
}
|
|
4199
|
+
}
|
|
4200
|
+
return placeOfEvent;
|
|
4201
|
+
}
|
|
4202
|
+
function extractPotentialDuplicatesFromActions(actions) {
|
|
4203
|
+
return actions.reduce((duplicates, action) => {
|
|
4204
|
+
if (action.type === ActionType.DUPLICATE_DETECTED) {
|
|
4205
|
+
duplicates = action.content.duplicates;
|
|
4206
|
+
}
|
|
4207
|
+
if (action.type === ActionType.MARK_AS_NOT_DUPLICATE || action.type === ActionType.MARK_AS_DUPLICATE) {
|
|
4208
|
+
duplicates = [];
|
|
4209
|
+
}
|
|
4210
|
+
return duplicates;
|
|
4211
|
+
}, []);
|
|
4212
|
+
}
|
|
4213
|
+
function getCurrentEventState(event2, config) {
|
|
4214
|
+
const sortedActions = event2.actions.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
4215
|
+
const creationAction = sortedActions.find(
|
|
4216
|
+
(action) => action.type === ActionType.CREATE
|
|
4217
|
+
);
|
|
4218
|
+
if (!creationAction) {
|
|
4219
|
+
throw new Error(`Event ${event2.id} has no creation action`);
|
|
4220
|
+
}
|
|
4221
|
+
const acceptedActions = getAcceptedActions(event2).sort(
|
|
4222
|
+
(a, b) => a.createdAt.localeCompare(b.createdAt)
|
|
4223
|
+
);
|
|
4224
|
+
const requestActionMetadata = getActionUpdateMetadata(sortedActions);
|
|
4225
|
+
const acceptedActionMetadata = getActionUpdateMetadata(acceptedActions);
|
|
4226
|
+
const declaration = aggregateActionDeclarations(event2);
|
|
4227
|
+
const status = getStatusFromActions(sortedActions);
|
|
4228
|
+
const legalStatuses = getLegalStatuses(sortedActions);
|
|
4229
|
+
const base = deepDropNulls({
|
|
4230
|
+
id: event2.id,
|
|
4231
|
+
type: event2.type,
|
|
4232
|
+
status,
|
|
4233
|
+
legalStatuses,
|
|
4234
|
+
createdAt: creationAction.createdAt,
|
|
4235
|
+
createdBy: creationAction.createdBy,
|
|
4236
|
+
createdByUserType: creationAction.createdByUserType,
|
|
4237
|
+
createdAtLocation: creationAction.createdAtLocation,
|
|
4238
|
+
updatedAt: acceptedActionMetadata.createdAt,
|
|
4239
|
+
assignedTo: getAssignedUserFromActions(acceptedActions),
|
|
4240
|
+
updatedBy: requestActionMetadata.createdBy,
|
|
4241
|
+
updatedAtLocation: requestActionMetadata.createdAtLocation,
|
|
4242
|
+
declaration,
|
|
4243
|
+
trackingId: event2.trackingId,
|
|
4244
|
+
updatedByUserRole: requestActionMetadata.createdByRole,
|
|
4245
|
+
placeOfEvent: resolvePlaceOfEvent(
|
|
4246
|
+
{ createdAtLocation: creationAction.createdAtLocation },
|
|
4247
|
+
declaration,
|
|
4248
|
+
config
|
|
4249
|
+
),
|
|
4250
|
+
potentialDuplicates: extractPotentialDuplicatesFromActions(sortedActions),
|
|
4251
|
+
flags: getEventFlags(event2, config)
|
|
4252
|
+
});
|
|
4253
|
+
return deepDropNulls({
|
|
4254
|
+
...base,
|
|
4255
|
+
dateOfEvent: resolveDateOfEvent(base, declaration, config)
|
|
4256
|
+
});
|
|
4257
|
+
}
|
|
4258
|
+
|
|
4259
|
+
// ../commons/src/conditionals/validate.ts
|
|
4260
|
+
var ajv = new import__.default({
|
|
4261
|
+
$data: true,
|
|
4262
|
+
allowUnionTypes: true,
|
|
4263
|
+
strict: false
|
|
4264
|
+
// Allow minContains and other newer features
|
|
4265
|
+
});
|
|
4266
|
+
var DataContext = z32.object({
|
|
4267
|
+
rootData: z32.object({
|
|
4268
|
+
$leafAdminStructureLocationIds: z32.array(z32.object({ id: UUID }))
|
|
4269
|
+
})
|
|
4270
|
+
});
|
|
4271
|
+
function resolveDataPath(rootData, dataPath, instancePath) {
|
|
4272
|
+
const pathParts = dataPath.split("/");
|
|
4273
|
+
const levels = parseInt(pathParts[0], 10);
|
|
4274
|
+
const referencePath = pathParts.slice(1);
|
|
4275
|
+
const instanceParts = instancePath.split("/").filter(Boolean);
|
|
4276
|
+
const traversedParts = instanceParts.slice(0, -levels);
|
|
4277
|
+
let current = rootData;
|
|
4278
|
+
for (const part of traversedParts) {
|
|
4279
|
+
if (current === null || current === void 0) {
|
|
4280
|
+
return void 0;
|
|
4281
|
+
}
|
|
4282
|
+
current = current[part];
|
|
4283
|
+
}
|
|
4284
|
+
for (const part of referencePath) {
|
|
4285
|
+
if (current === null || current === void 0) {
|
|
4286
|
+
return void 0;
|
|
4287
|
+
}
|
|
4288
|
+
current = current[part];
|
|
4289
|
+
}
|
|
4290
|
+
return current;
|
|
4291
|
+
}
|
|
4292
|
+
function todayISO() {
|
|
4293
|
+
return (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
|
|
4294
|
+
}
|
|
4295
|
+
var compiledFunctionCache = /* @__PURE__ */ new Map();
|
|
4296
|
+
function compileClientFunction(code) {
|
|
4297
|
+
let fn = compiledFunctionCache.get(code);
|
|
4298
|
+
if (!fn) {
|
|
4299
|
+
fn = new Function(`return (${code})`)();
|
|
4300
|
+
compiledFunctionCache.set(code, fn);
|
|
4301
|
+
}
|
|
4302
|
+
return fn;
|
|
4303
|
+
}
|
|
4304
|
+
(0, import_ajv_formats.default)(ajv);
|
|
4305
|
+
function buildClientFunctionContext(input) {
|
|
4306
|
+
const flags = input.validatorContext?.event && input.validatorContext?.eventConfig ? getCurrentEventState(
|
|
4307
|
+
input.validatorContext?.event,
|
|
4308
|
+
input.validatorContext?.eventConfig
|
|
4309
|
+
)?.flags : [];
|
|
4310
|
+
return {
|
|
4311
|
+
$form: input.form,
|
|
4312
|
+
$flags: flags,
|
|
4313
|
+
$now: todayISO(),
|
|
4314
|
+
// eslint-disable-next-line @typescript-eslint/no-use-before-define
|
|
4315
|
+
$online: isOnline(),
|
|
4316
|
+
$user: input.validatorContext?.user,
|
|
4317
|
+
$event: input.validatorContext?.event,
|
|
4318
|
+
$leafAdminStructureLocationIds: input.validatorContext?.leafAdminStructureLocationIds ?? [],
|
|
4319
|
+
user: input.systemVariables?.user,
|
|
4320
|
+
$window: input.systemVariables?.$window,
|
|
4321
|
+
locations: input.locations,
|
|
4322
|
+
adminLevelIds: input.adminLevelIds
|
|
4323
|
+
};
|
|
4324
|
+
}
|
|
4325
|
+
function runClientFunction(code, data, context) {
|
|
4326
|
+
return compileClientFunction(code)(data, context);
|
|
4327
|
+
}
|
|
4328
|
+
ajv.addKeyword({
|
|
4329
|
+
keyword: "daysFromDate",
|
|
4330
|
+
type: "string",
|
|
4331
|
+
schemaType: "object",
|
|
4332
|
+
$data: true,
|
|
4333
|
+
errors: true,
|
|
4334
|
+
validate(schema, data, _2, dataContext) {
|
|
4335
|
+
if (!(dataContext && dataContext.rootData && typeof dataContext.rootData === "object" && "$now" in dataContext.rootData && typeof dataContext.rootData.$now === "string")) {
|
|
4336
|
+
throw new Error("Validation context must contain $now");
|
|
4337
|
+
}
|
|
4338
|
+
const { days, clause } = schema;
|
|
4339
|
+
if (typeof data !== "string") {
|
|
4340
|
+
return false;
|
|
4341
|
+
}
|
|
4342
|
+
const date = new Date(data);
|
|
4343
|
+
if (isNaN(date.getTime())) {
|
|
4344
|
+
return false;
|
|
4345
|
+
}
|
|
4346
|
+
let referenceDate = schema.referenceDate;
|
|
4347
|
+
if (referenceDate && typeof referenceDate === "object" && "$data" in referenceDate) {
|
|
4348
|
+
referenceDate = resolveDataPath(
|
|
4349
|
+
dataContext.rootData,
|
|
4350
|
+
referenceDate.$data,
|
|
4351
|
+
dataContext.instancePath
|
|
4352
|
+
);
|
|
4353
|
+
}
|
|
4354
|
+
if (!referenceDate) {
|
|
4355
|
+
referenceDate = dataContext.rootData.$now;
|
|
4356
|
+
}
|
|
4357
|
+
const baseDate = new Date(referenceDate);
|
|
4358
|
+
if (isNaN(baseDate.getTime())) {
|
|
4359
|
+
return false;
|
|
4360
|
+
}
|
|
4361
|
+
const offsetDate = new Date(baseDate.getTime() + days * 24 * 60 * 60 * 1e3);
|
|
4362
|
+
return clause === "after" ? (0, import_date_fns2.isAfter)(date, offsetDate) : (0, import_date_fns2.isBefore)(date, offsetDate);
|
|
4363
|
+
}
|
|
4364
|
+
});
|
|
4365
|
+
ajv.addKeyword({
|
|
4366
|
+
keyword: "isLeafLevelLocation",
|
|
4367
|
+
type: "string",
|
|
4368
|
+
schemaType: "boolean",
|
|
4369
|
+
$data: true,
|
|
4370
|
+
errors: true,
|
|
4371
|
+
// @ts-ignore -- Force type. We will move this away from AJV next. Parsing the array will take seconds and is only called by core.
|
|
4372
|
+
validate(_schema, data, _2, dataContext) {
|
|
4373
|
+
const locationIdInput = data;
|
|
4374
|
+
const locations = dataContext?.rootData.$leafAdminStructureLocationIds ?? [];
|
|
4375
|
+
return locations.some((location) => location.id === locationIdInput);
|
|
4376
|
+
}
|
|
4377
|
+
});
|
|
4378
|
+
function isAgeValue(value) {
|
|
4379
|
+
return typeof value === "object" && value !== null && "age" in value && typeof value.age === "number";
|
|
4380
|
+
}
|
|
4381
|
+
ajv.addKeyword({
|
|
4382
|
+
keyword: "customClientValidator",
|
|
4383
|
+
schemaType: "object",
|
|
4384
|
+
errors: true,
|
|
4385
|
+
// @ts-expect-error -- AJV's public types don't expose `rootData`. All
|
|
4386
|
+
// `validate()` callers build root data via `buildClientFunctionContext`,
|
|
4387
|
+
// so the cast holds.
|
|
4388
|
+
validate(schema, data, _2, dataContext) {
|
|
4389
|
+
return Boolean(
|
|
4390
|
+
runClientFunction(
|
|
4391
|
+
schema.code,
|
|
4392
|
+
data,
|
|
4393
|
+
dataContext?.rootData ?? buildClientFunctionContext({ form: {} })
|
|
4394
|
+
)
|
|
4395
|
+
);
|
|
4396
|
+
}
|
|
4397
|
+
});
|
|
4398
|
+
function validate(schema, data) {
|
|
4399
|
+
const validator = ajv.getSchema(schema.$id) || ajv.compile(schema);
|
|
4400
|
+
if ("$form" in data) {
|
|
4401
|
+
const entries = Object.entries(data.$form).map(([key, value]) => {
|
|
4402
|
+
if (!isAgeValue(value)) {
|
|
4403
|
+
return [key, value];
|
|
4404
|
+
}
|
|
4405
|
+
const age = value.age;
|
|
4406
|
+
const maybeAsOfDate = PlainDate.safeParse(data.$form[value.asOfDateRef]);
|
|
4407
|
+
return [
|
|
4408
|
+
key,
|
|
4409
|
+
{
|
|
4410
|
+
age,
|
|
4411
|
+
dob: ageToDate(
|
|
4412
|
+
age,
|
|
4413
|
+
maybeAsOfDate.success ? maybeAsOfDate.data : PlainDate.parse(data.$now)
|
|
4414
|
+
)
|
|
3910
4415
|
}
|
|
3911
|
-
|
|
3912
|
-
|
|
3913
|
-
|
|
3914
|
-
|
|
3915
|
-
|
|
3916
|
-
|
|
3917
|
-
|
|
3918
|
-
|
|
3919
|
-
|
|
3920
|
-
|
|
3921
|
-
|
|
3922
|
-
|
|
3923
|
-
|
|
3924
|
-
|
|
3925
|
-
|
|
3926
|
-
|
|
3927
|
-
|
|
3928
|
-
|
|
3929
|
-
|
|
3930
|
-
|
|
3931
|
-
|
|
3932
|
-
|
|
3933
|
-
|
|
3934
|
-
|
|
3935
|
-
|
|
3936
|
-
|
|
3937
|
-
|
|
3938
|
-
|
|
3939
|
-
|
|
3940
|
-
|
|
3941
|
-
|
|
3942
|
-
|
|
3943
|
-
|
|
3944
|
-
|
|
3945
|
-
|
|
3946
|
-
|
|
3947
|
-
|
|
3948
|
-
|
|
3949
|
-
|
|
3950
|
-
|
|
3951
|
-
|
|
3952
|
-
|
|
3953
|
-
|
|
3954
|
-
|
|
3955
|
-
|
|
3956
|
-
|
|
3957
|
-
|
|
3958
|
-
|
|
3959
|
-
|
|
4416
|
+
];
|
|
4417
|
+
});
|
|
4418
|
+
data.$form = Object.fromEntries(entries);
|
|
4419
|
+
}
|
|
4420
|
+
const result = validator(data);
|
|
4421
|
+
return result;
|
|
4422
|
+
}
|
|
4423
|
+
function isOnline() {
|
|
4424
|
+
if (typeof window !== "undefined" && typeof navigator !== "undefined") {
|
|
4425
|
+
return navigator.onLine;
|
|
4426
|
+
}
|
|
4427
|
+
return true;
|
|
4428
|
+
}
|
|
4429
|
+
|
|
4430
|
+
// ../commons/src/events/utils.ts
|
|
4431
|
+
var import_date_fns3 = require("date-fns");
|
|
4432
|
+
function ageToDate(age, asOfDate) {
|
|
4433
|
+
const date = plainDateToLocalDate(asOfDate);
|
|
4434
|
+
return PlainDate.parse((0, import_date_fns3.format)((0, import_date_fns3.subYears)(date, age), "yyyy-MM-dd"));
|
|
4435
|
+
}
|
|
4436
|
+
function getDeclarationFields(configuration) {
|
|
4437
|
+
return configuration.declaration.pages.flatMap(({ fields }) => fields);
|
|
4438
|
+
}
|
|
4439
|
+
function isActionConfigType(type) {
|
|
4440
|
+
return actionConfigTypes.has(type);
|
|
4441
|
+
}
|
|
4442
|
+
function getActionConfig({
|
|
4443
|
+
eventConfiguration,
|
|
4444
|
+
actionType,
|
|
4445
|
+
customActionType
|
|
4446
|
+
}) {
|
|
4447
|
+
if (actionType === ActionType.NOTIFY) {
|
|
4448
|
+
return eventConfiguration.actions.find((a) => a.type === ActionType.NOTIFY) ?? eventConfiguration.actions.find((a) => a.type === ActionType.DECLARE);
|
|
4449
|
+
}
|
|
4450
|
+
return eventConfiguration.actions.find((a) => {
|
|
4451
|
+
if (a.type === ActionType.CUSTOM && customActionType) {
|
|
4452
|
+
return a.customActionType === customActionType;
|
|
4453
|
+
}
|
|
4454
|
+
return a.type === actionType;
|
|
4455
|
+
});
|
|
4456
|
+
}
|
|
4457
|
+
var getActionAnnotationFields = (actionConfig) => {
|
|
4458
|
+
if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
|
|
4459
|
+
return actionConfig.correctionForm.pages.flatMap(({ fields }) => fields);
|
|
4460
|
+
}
|
|
4461
|
+
if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
|
|
4462
|
+
return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
|
|
4463
|
+
}
|
|
4464
|
+
const reviewFields = "review" in actionConfig && actionConfig.review != null ? actionConfig.review.fields : [];
|
|
4465
|
+
const formFields = "form" in actionConfig && actionConfig.form != null ? actionConfig.form : [];
|
|
4466
|
+
return [...reviewFields, ...formFields];
|
|
4467
|
+
};
|
|
4468
|
+
function getAllAnnotationFields(config) {
|
|
4469
|
+
return (0, import_lodash4.flattenDeep)(config.actions.map(getActionAnnotationFields));
|
|
4470
|
+
}
|
|
4471
|
+
function deepMerge(currentDocument, actionDocument) {
|
|
4472
|
+
const currentDocumentClone = (0, import_lodash4.cloneDeep)(currentDocument);
|
|
4473
|
+
return (0, import_lodash4.mergeWith)(
|
|
4474
|
+
(0, import_lodash4.cloneDeep)(currentDocumentClone),
|
|
4475
|
+
actionDocument,
|
|
4476
|
+
(previousValue, incomingValue) => {
|
|
4477
|
+
if (incomingValue === void 0) {
|
|
4478
|
+
return previousValue;
|
|
4479
|
+
}
|
|
4480
|
+
if ((0, import_lodash4.isArray)(incomingValue)) {
|
|
4481
|
+
return incomingValue;
|
|
4482
|
+
}
|
|
4483
|
+
if ((0, import_lodash4.isObject)(previousValue) && (0, import_lodash4.isObject)(incomingValue)) {
|
|
4484
|
+
return void 0;
|
|
4485
|
+
}
|
|
4486
|
+
return incomingValue;
|
|
4487
|
+
}
|
|
4488
|
+
);
|
|
4489
|
+
}
|
|
4490
|
+
var findAllFields = (config) => {
|
|
4491
|
+
return (0, import_lodash4.flattenDeep)([
|
|
4492
|
+
...getDeclarationFields(config),
|
|
4493
|
+
...getAllAnnotationFields(config)
|
|
4494
|
+
]);
|
|
4495
|
+
};
|
|
4496
|
+
function getMixedPath(obj, path, defaultValue) {
|
|
4497
|
+
const parts = path.split(".");
|
|
4498
|
+
const resolve = (current, segments) => {
|
|
4499
|
+
if (current == null || segments.length === 0) {
|
|
4500
|
+
return current;
|
|
4501
|
+
}
|
|
4502
|
+
for (let i = segments.length; i > 0; i--) {
|
|
4503
|
+
const compoundKey = segments.slice(0, i).join(".");
|
|
4504
|
+
if ((0, import_lodash4.has)(current, compoundKey)) {
|
|
4505
|
+
const next = (0, import_lodash4.get)(current, compoundKey);
|
|
4506
|
+
return resolve(next, segments.slice(i));
|
|
4507
|
+
}
|
|
3960
4508
|
}
|
|
4509
|
+
return void 0;
|
|
3961
4510
|
};
|
|
4511
|
+
const result = resolve(obj, parts);
|
|
4512
|
+
return (0, import_lodash4.isNil)(result) ? defaultValue : result;
|
|
4513
|
+
}
|
|
4514
|
+
function isAcceptedAction(a) {
|
|
4515
|
+
return a.status === ActionStatus.Accepted;
|
|
4516
|
+
}
|
|
4517
|
+
function getCompleteActionAnnotation(event2, action) {
|
|
4518
|
+
if (action.originalActionId) {
|
|
4519
|
+
const originalAction = event2.actions.find(
|
|
4520
|
+
({ id }) => id === action.originalActionId
|
|
4521
|
+
);
|
|
4522
|
+
if (originalAction?.status === ActionStatus.Requested) {
|
|
4523
|
+
return deepMerge(originalAction.annotation ?? {}, action.annotation ?? {});
|
|
4524
|
+
}
|
|
4525
|
+
}
|
|
4526
|
+
return action.annotation ?? {};
|
|
4527
|
+
}
|
|
4528
|
+
function getCompleteActionDeclaration(declaration, event2, action) {
|
|
4529
|
+
if (action.originalActionId) {
|
|
4530
|
+
const originalAction = event2.actions.find(
|
|
4531
|
+
({ id }) => id === action.originalActionId
|
|
4532
|
+
);
|
|
4533
|
+
if (originalAction?.status === ActionStatus.Requested) {
|
|
4534
|
+
return deepMerge(
|
|
4535
|
+
deepMerge(declaration, originalAction.declaration),
|
|
4536
|
+
action.declaration
|
|
4537
|
+
);
|
|
4538
|
+
}
|
|
4539
|
+
}
|
|
4540
|
+
return deepMerge(declaration, action.declaration);
|
|
4541
|
+
}
|
|
4542
|
+
function getAcceptedActions(event2) {
|
|
4543
|
+
return event2.actions.filter(isAcceptedAction).map((action) => ({
|
|
4544
|
+
...action,
|
|
4545
|
+
declaration: getCompleteActionDeclaration({}, event2, action),
|
|
4546
|
+
annotation: getCompleteActionAnnotation(event2, action)
|
|
4547
|
+
}));
|
|
4548
|
+
}
|
|
4549
|
+
var EXCLUDED_ACTIONS = [
|
|
4550
|
+
ActionType.REQUEST_CORRECTION,
|
|
4551
|
+
ActionType.PRINT_CERTIFICATE,
|
|
4552
|
+
ActionType.REJECT_CORRECTION
|
|
4553
|
+
];
|
|
4554
|
+
function aggregateActionDeclarations(event2) {
|
|
4555
|
+
const allAcceptedActions = getAcceptedActions(event2);
|
|
4556
|
+
const aggregatedActions = allAcceptedActions.filter((a) => !EXCLUDED_ACTIONS.some((type) => type === a.type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
4557
|
+
return aggregatedActions.reduce((declaration, action) => {
|
|
4558
|
+
if (action.type === ActionType.APPROVE_CORRECTION) {
|
|
4559
|
+
const requestAction = allAcceptedActions.find(
|
|
4560
|
+
({ id }) => id === action.requestId
|
|
4561
|
+
);
|
|
4562
|
+
if (!requestAction) {
|
|
4563
|
+
return declaration;
|
|
4564
|
+
}
|
|
4565
|
+
const declarationWithApprovedCorrection = getCompleteActionDeclaration(
|
|
4566
|
+
declaration,
|
|
4567
|
+
event2,
|
|
4568
|
+
requestAction
|
|
4569
|
+
);
|
|
4570
|
+
return getCompleteActionDeclaration(
|
|
4571
|
+
declarationWithApprovedCorrection,
|
|
4572
|
+
event2,
|
|
4573
|
+
action
|
|
4574
|
+
);
|
|
4575
|
+
}
|
|
4576
|
+
return getCompleteActionDeclaration(declaration, event2, action);
|
|
4577
|
+
}, {});
|
|
4578
|
+
}
|
|
4579
|
+
function aggregateActionAnnotations(event2) {
|
|
4580
|
+
return event2.actions.reduce((ann, sortedAction) => {
|
|
4581
|
+
if (!("annotation" in sortedAction) || !sortedAction.annotation) {
|
|
4582
|
+
return ann;
|
|
4583
|
+
}
|
|
4584
|
+
return deepMerge(ann, sortedAction.annotation);
|
|
4585
|
+
}, {});
|
|
3962
4586
|
}
|
|
3963
4587
|
|
|
3964
4588
|
// ../commons/src/events/eventConfigValidation.ts
|
|
@@ -4802,14 +5426,14 @@ var DraftInput = BaseActionInput.omit({ waitFor: true }).extend({
|
|
|
4802
5426
|
|
|
4803
5427
|
// ../commons/src/events/EventInput.ts
|
|
4804
5428
|
var z40 = __toESM(require("zod/v4"));
|
|
4805
|
-
var
|
|
5429
|
+
var import_uuid11 = require("uuid");
|
|
4806
5430
|
var EventInput = z40.object({
|
|
4807
5431
|
transactionId: z40.string(),
|
|
4808
5432
|
type: z40.string(),
|
|
4809
5433
|
createdAtLocation: UUID.nullish().describe(
|
|
4810
5434
|
"Location where the event occurred. Required for system users."
|
|
4811
5435
|
)
|
|
4812
|
-
}).meta({ default: { transactionId: (0,
|
|
5436
|
+
}).meta({ default: { transactionId: (0, import_uuid11.v4)(), type: "birth" } });
|
|
4813
5437
|
|
|
4814
5438
|
// ../commons/src/events/EventDocument.ts
|
|
4815
5439
|
var z41 = __toESM(require("zod/v4"));
|
|
@@ -4826,67 +5450,6 @@ var EventDocument = z41.object({
|
|
|
4826
5450
|
)
|
|
4827
5451
|
}).meta({ id: "EventDocument" });
|
|
4828
5452
|
|
|
4829
|
-
// ../commons/src/events/state/index.ts
|
|
4830
|
-
var import_lodash4 = require("lodash");
|
|
4831
|
-
|
|
4832
|
-
// ../commons/src/events/state/utils.ts
|
|
4833
|
-
var import_lodash2 = require("lodash");
|
|
4834
|
-
var updateActions = ActionTypes.extract([
|
|
4835
|
-
ActionType.CREATE,
|
|
4836
|
-
ActionType.NOTIFY,
|
|
4837
|
-
ActionType.EDIT,
|
|
4838
|
-
ActionType.DECLARE,
|
|
4839
|
-
ActionType.REGISTER,
|
|
4840
|
-
ActionType.REJECT,
|
|
4841
|
-
ActionType.ARCHIVE,
|
|
4842
|
-
ActionType.UNARCHIVE,
|
|
4843
|
-
ActionType.PRINT_CERTIFICATE,
|
|
4844
|
-
ActionType.REQUEST_CORRECTION,
|
|
4845
|
-
ActionType.APPROVE_CORRECTION,
|
|
4846
|
-
ActionType.REJECT_CORRECTION,
|
|
4847
|
-
ActionType.CUSTOM
|
|
4848
|
-
]);
|
|
4849
|
-
|
|
4850
|
-
// ../commons/src/events/state/flags.ts
|
|
4851
|
-
var import_lodash3 = require("lodash");
|
|
4852
|
-
var import_date_fns3 = require("date-fns");
|
|
4853
|
-
var INHERENT_FLAG_RULES = [
|
|
4854
|
-
{
|
|
4855
|
-
flag: InherentFlags.CORRECTION_REQUESTED,
|
|
4856
|
-
setOn: [ActionType.REQUEST_CORRECTION],
|
|
4857
|
-
resetOn: [ActionType.APPROVE_CORRECTION, ActionType.REJECT_CORRECTION]
|
|
4858
|
-
},
|
|
4859
|
-
{
|
|
4860
|
-
// INCOMPLETE mirrors the NOTIFIED status: set by NOTIFY, cleared by any
|
|
4861
|
-
// other status-changing action (see getStatusFromActions). ARCHIVE/UNARCHIVE
|
|
4862
|
-
// are deliberately excluded so the flag freezes across an archive/unarchive
|
|
4863
|
-
// round trip and comes back exactly as it was.
|
|
4864
|
-
flag: InherentFlags.INCOMPLETE,
|
|
4865
|
-
setOn: [ActionType.NOTIFY],
|
|
4866
|
-
resetOn: [ActionType.CREATE, ActionType.DECLARE, ActionType.REGISTER]
|
|
4867
|
-
},
|
|
4868
|
-
{
|
|
4869
|
-
flag: InherentFlags.REJECTED,
|
|
4870
|
-
setOn: [ActionType.REJECT],
|
|
4871
|
-
resetOn: [
|
|
4872
|
-
ActionType.NOTIFY,
|
|
4873
|
-
ActionType.DECLARE,
|
|
4874
|
-
ActionType.EDIT,
|
|
4875
|
-
ActionType.REGISTER
|
|
4876
|
-
]
|
|
4877
|
-
},
|
|
4878
|
-
{
|
|
4879
|
-
flag: InherentFlags.POTENTIAL_DUPLICATE,
|
|
4880
|
-
setOn: [ActionType.DUPLICATE_DETECTED],
|
|
4881
|
-
resetOn: [ActionType.MARK_AS_DUPLICATE, ActionType.MARK_AS_NOT_DUPLICATE]
|
|
4882
|
-
},
|
|
4883
|
-
{
|
|
4884
|
-
flag: InherentFlags.EDIT_IN_PROGRESS,
|
|
4885
|
-
setOn: [ActionType.EDIT],
|
|
4886
|
-
resetOnAnyOtherAction: true
|
|
4887
|
-
}
|
|
4888
|
-
];
|
|
4889
|
-
|
|
4890
5453
|
// ../commons/src/events/defineConfig.ts
|
|
4891
5454
|
var IGNORED_EVENT_TYPES = [
|
|
4892
5455
|
"FOOTBALL_CLUB_MEMBERSHIP",
|
|
@@ -7359,44 +7922,21 @@ var LocationTypeV1 = z43.enum([
|
|
|
7359
7922
|
"CRVS_OFFICE",
|
|
7360
7923
|
"HEALTH_FACILITY"
|
|
7361
7924
|
]);
|
|
7362
|
-
var LocationStatus = z43.enum(["active", "inactive"]);
|
|
7363
|
-
var LocationVersion = z43.object({
|
|
7364
|
-
versionId: UUID,
|
|
7365
|
-
effectiveFrom: z43.iso.date(),
|
|
7366
|
-
name: z43.string(),
|
|
7367
|
-
externalId: z43.string().nullish(),
|
|
7368
|
-
status: LocationStatus
|
|
7369
|
-
});
|
|
7370
7925
|
var AdministrativeArea = z43.object({
|
|
7371
7926
|
id: UUID,
|
|
7372
7927
|
name: z43.string(),
|
|
7373
7928
|
externalId: z43.string().nullish(),
|
|
7374
7929
|
parentId: UUID.nullable(),
|
|
7375
|
-
|
|
7376
|
-
versions: z43.array(LocationVersion)
|
|
7930
|
+
validUntil: z43.iso.datetime().nullable()
|
|
7377
7931
|
});
|
|
7378
7932
|
var Location = z43.object({
|
|
7379
7933
|
id: UUID,
|
|
7380
7934
|
name: z43.string(),
|
|
7381
7935
|
externalId: z43.string().nullish(),
|
|
7382
7936
|
administrativeAreaId: UUID.nullable(),
|
|
7383
|
-
|
|
7384
|
-
status: LocationStatus,
|
|
7385
|
-
versions: z43.array(LocationVersion)
|
|
7386
|
-
});
|
|
7387
|
-
var SetLocationPayload = z43.object({
|
|
7388
|
-
id: UUID,
|
|
7389
|
-
name: z43.string(),
|
|
7390
|
-
externalId: z43.string().nullish(),
|
|
7391
|
-
administrativeAreaId: UUID.nullable(),
|
|
7937
|
+
validUntil: z43.iso.datetime().nullable(),
|
|
7392
7938
|
locationType: z43.string().nullable()
|
|
7393
7939
|
});
|
|
7394
|
-
var SetAdministrativeAreaPayload = z43.object({
|
|
7395
|
-
id: UUID,
|
|
7396
|
-
name: z43.string(),
|
|
7397
|
-
externalId: z43.string().nullish(),
|
|
7398
|
-
parentId: UUID.nullable()
|
|
7399
|
-
});
|
|
7400
7940
|
|
|
7401
7941
|
// ../commons/src/events/scopes.ts
|
|
7402
7942
|
var ACTION_SCOPE_MAP = {
|
|
@@ -7495,80 +8035,75 @@ var REJECTED_ACTIONS = [
|
|
|
7495
8035
|
var import_lodash7 = require("lodash");
|
|
7496
8036
|
|
|
7497
8037
|
// ../commons/src/events/mocks.test.utils.ts
|
|
7498
|
-
|
|
7499
|
-
return {
|
|
7500
|
-
...entity,
|
|
7501
|
-
status: "active",
|
|
7502
|
-
versions: [
|
|
7503
|
-
{
|
|
7504
|
-
versionId: entity.id,
|
|
7505
|
-
effectiveFrom: "0001-01-01",
|
|
7506
|
-
name: entity.name,
|
|
7507
|
-
externalId: entity.externalId ?? null,
|
|
7508
|
-
status: "active"
|
|
7509
|
-
}
|
|
7510
|
-
]
|
|
7511
|
-
};
|
|
7512
|
-
}
|
|
7513
|
-
var MOCK_ADMINISTRATIVE_AREAS_BASE = [
|
|
8038
|
+
var V2_DEFAULT_MOCK_ADMINISTRATIVE_AREAS = [
|
|
7514
8039
|
{
|
|
7515
8040
|
id: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
7516
8041
|
name: "Central",
|
|
7517
8042
|
parentId: null,
|
|
8043
|
+
validUntil: null,
|
|
7518
8044
|
externalId: "ydyJb1RAy4U1"
|
|
7519
8045
|
},
|
|
7520
8046
|
{
|
|
7521
8047
|
id: "c599b691-fd2d-45e1-abf4-d185de727fb5",
|
|
7522
8048
|
name: "Sulaka",
|
|
7523
8049
|
parentId: null,
|
|
8050
|
+
validUntil: null,
|
|
7524
8051
|
externalId: "pQ8nGxWmZ2Q3"
|
|
7525
8052
|
},
|
|
7526
8053
|
{
|
|
7527
8054
|
id: "7ef2b9c7-5e6d-49f6-ae05-656207d0fc64",
|
|
7528
8055
|
name: "Pualula",
|
|
7529
8056
|
parentId: null,
|
|
8057
|
+
validUntil: null,
|
|
7530
8058
|
externalId: "Aq91DweLmT8k"
|
|
7531
8059
|
},
|
|
7532
8060
|
{
|
|
7533
8061
|
id: "6d1a59df-988c-4021-a846-ccbc021931a7",
|
|
7534
8062
|
name: "Chuminga",
|
|
7535
8063
|
parentId: null,
|
|
8064
|
+
validUntil: null,
|
|
7536
8065
|
externalId: "Rw0fYNh2Xk9a"
|
|
7537
8066
|
},
|
|
7538
8067
|
{
|
|
7539
8068
|
id: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
7540
8069
|
name: "Ibombo",
|
|
7541
8070
|
parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8071
|
+
validUntil: null,
|
|
7542
8072
|
externalId: "k7DsP4vbN1Qe"
|
|
7543
8073
|
},
|
|
7544
8074
|
{
|
|
7545
8075
|
id: "27160bbd-32d1-4625-812f-860226bfb92a",
|
|
7546
8076
|
name: "Isango",
|
|
7547
8077
|
parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8078
|
+
validUntil: null,
|
|
7548
8079
|
externalId: "Gm3Z9eQpHw4L"
|
|
7549
8080
|
},
|
|
7550
8081
|
{
|
|
7551
8082
|
id: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
7552
8083
|
name: "Isamba",
|
|
7553
8084
|
parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8085
|
+
validUntil: null,
|
|
7554
8086
|
externalId: "sT0xVu1KqJ7r"
|
|
7555
8087
|
},
|
|
7556
8088
|
{
|
|
7557
8089
|
id: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
7558
8090
|
name: "Itambo",
|
|
7559
8091
|
parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8092
|
+
validUntil: null,
|
|
7560
8093
|
externalId: "Nq6Bv2HpL9Te"
|
|
7561
8094
|
},
|
|
7562
8095
|
{
|
|
7563
8096
|
id: "d42ab2fe-e7ed-470e-8b31-4fb27f9b8250",
|
|
7564
8097
|
name: "Ezhi",
|
|
7565
8098
|
parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8099
|
+
validUntil: null,
|
|
7566
8100
|
externalId: "xK8cQ0ZRy5Wd"
|
|
7567
8101
|
},
|
|
7568
8102
|
{
|
|
7569
8103
|
id: "8fbd09d2-212b-47f4-beb3-5e1694931d9f",
|
|
7570
8104
|
name: "Ilanga",
|
|
7571
8105
|
parentId: "c599b691-fd2d-45e1-abf4-d185de727fb5",
|
|
8106
|
+
validUntil: null,
|
|
7572
8107
|
externalId: "Cq4Jm1XvN8Ls"
|
|
7573
8108
|
},
|
|
7574
8109
|
// Villages under Ibombo (62a0ccb4-880d-4f30-8882-f256007dfff9)
|
|
@@ -7576,42 +8111,49 @@ var MOCK_ADMINISTRATIVE_AREAS_BASE = [
|
|
|
7576
8111
|
id: "1d4e5f6a-7b8c-4912-8efa-345678901234",
|
|
7577
8112
|
name: "Klow",
|
|
7578
8113
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8114
|
+
validUntil: null,
|
|
7579
8115
|
externalId: "IkYcYBUcyY2"
|
|
7580
8116
|
},
|
|
7581
8117
|
{
|
|
7582
8118
|
id: "2e5f6a7b-8c9d-4a23-8fab-456789012345",
|
|
7583
8119
|
name: "Mbondo",
|
|
7584
8120
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8121
|
+
validUntil: null,
|
|
7585
8122
|
externalId: "Qhvv5hvo3mY"
|
|
7586
8123
|
},
|
|
7587
8124
|
{
|
|
7588
8125
|
id: "3f6a7b8c-9d0e-4b34-8abc-567890123456",
|
|
7589
8126
|
name: "Ndara",
|
|
7590
8127
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8128
|
+
validUntil: null,
|
|
7591
8129
|
externalId: "crXh068O9TR"
|
|
7592
8130
|
},
|
|
7593
8131
|
{
|
|
7594
8132
|
id: "4a7b8c9d-0e1f-4c45-abcd-678901234567",
|
|
7595
8133
|
name: "Olani",
|
|
7596
8134
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8135
|
+
validUntil: null,
|
|
7597
8136
|
externalId: "r00It8Tvvp7"
|
|
7598
8137
|
},
|
|
7599
8138
|
{
|
|
7600
8139
|
id: "5b8c9d0e-1f2a-4d56-bcde-789012345678",
|
|
7601
8140
|
name: "Pemba",
|
|
7602
8141
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8142
|
+
validUntil: null,
|
|
7603
8143
|
externalId: "ZnUWsbONIaH"
|
|
7604
8144
|
},
|
|
7605
8145
|
{
|
|
7606
8146
|
id: "6c9d0e1f-2a3b-4e67-8def-890123456789",
|
|
7607
8147
|
name: "Quanza",
|
|
7608
8148
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8149
|
+
validUntil: null,
|
|
7609
8150
|
externalId: "fDZycvQTa7l"
|
|
7610
8151
|
},
|
|
7611
8152
|
{
|
|
7612
8153
|
id: "7d0e1f2a-3b4c-4f78-8efa-901234567890",
|
|
7613
8154
|
name: "Rivka",
|
|
7614
8155
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8156
|
+
validUntil: null,
|
|
7615
8157
|
externalId: "KqswxCGTELa"
|
|
7616
8158
|
},
|
|
7617
8159
|
// Villages under Isamba (967032fd-3f81-478a-826c-30cb8fe121bd)
|
|
@@ -7619,30 +8161,35 @@ var MOCK_ADMINISTRATIVE_AREAS_BASE = [
|
|
|
7619
8161
|
id: "8e1f2a3b-4c5d-4089-8fab-012345678901",
|
|
7620
8162
|
name: "Mbula",
|
|
7621
8163
|
parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8164
|
+
validUntil: null,
|
|
7622
8165
|
externalId: "osEbKjRc9Kg"
|
|
7623
8166
|
},
|
|
7624
8167
|
{
|
|
7625
8168
|
id: "9f2a3b4c-5d6e-4190-8abf-123456789012",
|
|
7626
8169
|
name: "Ndoki",
|
|
7627
8170
|
parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8171
|
+
validUntil: null,
|
|
7628
8172
|
externalId: "aq4daBUAGr3"
|
|
7629
8173
|
},
|
|
7630
8174
|
{
|
|
7631
8175
|
id: "0a3b4c5d-6e7f-4201-abcd-234567890123",
|
|
7632
8176
|
name: "Tsanga",
|
|
7633
8177
|
parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8178
|
+
validUntil: null,
|
|
7634
8179
|
externalId: "cqis6Y8trbJ"
|
|
7635
8180
|
},
|
|
7636
8181
|
{
|
|
7637
8182
|
id: "1b4c5d6e-7f8a-4312-bcde-345678901234",
|
|
7638
8183
|
name: "Waziri",
|
|
7639
8184
|
parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8185
|
+
validUntil: null,
|
|
7640
8186
|
externalId: "LMijHPyyx6d"
|
|
7641
8187
|
},
|
|
7642
8188
|
{
|
|
7643
8189
|
id: "2c5d6e7f-8a9b-4423-8def-456789012345",
|
|
7644
8190
|
name: "Zimbi",
|
|
7645
8191
|
parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8192
|
+
validUntil: null,
|
|
7646
8193
|
externalId: "pcQYbPuKGZ7"
|
|
7647
8194
|
},
|
|
7648
8195
|
// Villages under Itambo (89a33893-b17d-481d-a26d-6461e7ac1651)
|
|
@@ -7650,59 +8197,67 @@ var MOCK_ADMINISTRATIVE_AREAS_BASE = [
|
|
|
7650
8197
|
id: "3d6e7f8a-9b0c-4534-8efa-567890123456",
|
|
7651
8198
|
name: "Felani",
|
|
7652
8199
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8200
|
+
validUntil: null,
|
|
7653
8201
|
externalId: "gSqpoCGdMXp"
|
|
7654
8202
|
},
|
|
7655
8203
|
{
|
|
7656
8204
|
id: "4e7f8a9b-0c1d-4645-8fab-678901234567",
|
|
7657
8205
|
name: "Goroma",
|
|
7658
8206
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8207
|
+
validUntil: null,
|
|
7659
8208
|
externalId: "KvAAIaNqVrp"
|
|
7660
8209
|
},
|
|
7661
8210
|
{
|
|
7662
8211
|
id: "5f8a9b0c-1d2e-4756-8abc-789012345678",
|
|
7663
8212
|
name: "Halifu",
|
|
7664
8213
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8214
|
+
validUntil: null,
|
|
7665
8215
|
externalId: "qe4UnEVt1hv"
|
|
7666
8216
|
},
|
|
7667
8217
|
{
|
|
7668
8218
|
id: "6a9b0c1d-2e3f-4867-abcd-890123456789",
|
|
7669
8219
|
name: "Jabari",
|
|
7670
8220
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8221
|
+
validUntil: null,
|
|
7671
8222
|
externalId: "yHH9Nz4rLOt"
|
|
7672
8223
|
},
|
|
7673
8224
|
{
|
|
7674
8225
|
id: "7b0c1d2e-3f4a-4978-bcde-901234567890",
|
|
7675
8226
|
name: "Kifani",
|
|
7676
8227
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8228
|
+
validUntil: null,
|
|
7677
8229
|
externalId: "eSWmXIGeu1I"
|
|
7678
8230
|
},
|
|
7679
8231
|
{
|
|
7680
8232
|
id: "8c1d2e3f-4a5b-4089-8def-012345678901",
|
|
7681
8233
|
name: "Lumela",
|
|
7682
8234
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8235
|
+
validUntil: null,
|
|
7683
8236
|
externalId: "bh0b3aI1uP3"
|
|
7684
8237
|
}
|
|
7685
8238
|
];
|
|
7686
|
-
var
|
|
7687
|
-
var MOCK_LOCATIONS_BASE = [
|
|
8239
|
+
var V2_DEFAULT_MOCK_LOCATIONS = [
|
|
7688
8240
|
{
|
|
7689
8241
|
id: "6f6186ce-cd5f-4a5f-810a-2d99e7c4ba12",
|
|
7690
8242
|
name: "Central Provincial Office",
|
|
7691
8243
|
locationType: "CRVS_OFFICE",
|
|
7692
8244
|
administrativeAreaId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8245
|
+
validUntil: null,
|
|
7693
8246
|
externalId: "Xr3Df8WpK6Ys"
|
|
7694
8247
|
},
|
|
7695
8248
|
{
|
|
7696
8249
|
id: "b1c2d3e4-f5a6-7890-bcde-f12345678901",
|
|
7697
8250
|
name: "Central Health Post",
|
|
7698
8251
|
locationType: "HEALTH_FACILITY",
|
|
7699
|
-
administrativeAreaId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c"
|
|
8252
|
+
administrativeAreaId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8253
|
+
validUntil: null
|
|
7700
8254
|
},
|
|
7701
8255
|
{
|
|
7702
8256
|
id: "028d2c85-ca31-426d-b5d1-2cef545a4902",
|
|
7703
8257
|
name: "Ibombo District Office",
|
|
7704
8258
|
locationType: "CRVS_OFFICE",
|
|
7705
8259
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8260
|
+
validUntil: null,
|
|
7706
8261
|
externalId: "Sm4Nw7GrD2Vy"
|
|
7707
8262
|
},
|
|
7708
8263
|
{
|
|
@@ -7710,6 +8265,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7710
8265
|
name: "Isamba District Office",
|
|
7711
8266
|
locationType: "CRVS_OFFICE",
|
|
7712
8267
|
administrativeAreaId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8268
|
+
validUntil: null,
|
|
7713
8269
|
externalId: "Vg1Bq5XeH9Lt"
|
|
7714
8270
|
},
|
|
7715
8271
|
{
|
|
@@ -7717,6 +8273,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7717
8273
|
name: "Isango District Office",
|
|
7718
8274
|
locationType: "CRVS_OFFICE",
|
|
7719
8275
|
administrativeAreaId: "27160bbd-32d1-4625-812f-860226bfb92a",
|
|
8276
|
+
validUntil: null,
|
|
7720
8277
|
externalId: "Je7Lm2XqN9Vz"
|
|
7721
8278
|
},
|
|
7722
8279
|
{
|
|
@@ -7724,6 +8281,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7724
8281
|
name: "Sulaka Provincial Office",
|
|
7725
8282
|
locationType: "CRVS_OFFICE",
|
|
7726
8283
|
administrativeAreaId: "c599b691-fd2d-45e1-abf4-d185de727fb5",
|
|
8284
|
+
validUntil: null,
|
|
7727
8285
|
externalId: "Ht2Wp9KcX5Qv"
|
|
7728
8286
|
},
|
|
7729
8287
|
{
|
|
@@ -7731,6 +8289,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7731
8289
|
name: "Ilanga District Office",
|
|
7732
8290
|
locationType: "CRVS_OFFICE",
|
|
7733
8291
|
administrativeAreaId: "8fbd09d2-212b-47f4-beb3-5e1694931d9f",
|
|
8292
|
+
validUntil: null,
|
|
7734
8293
|
externalId: "Yp6Ds1WqN3Xz"
|
|
7735
8294
|
},
|
|
7736
8295
|
{
|
|
@@ -7738,6 +8297,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7738
8297
|
name: "Chamakubi Health Post",
|
|
7739
8298
|
locationType: "HEALTH_FACILITY",
|
|
7740
8299
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8300
|
+
validUntil: null,
|
|
7741
8301
|
externalId: "M1nFr8LbC2Qy"
|
|
7742
8302
|
},
|
|
7743
8303
|
{
|
|
@@ -7745,6 +8305,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7745
8305
|
name: "Ibombo Rural Health Centre",
|
|
7746
8306
|
locationType: "HEALTH_FACILITY",
|
|
7747
8307
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8308
|
+
validUntil: null,
|
|
7748
8309
|
externalId: "bT7pV6YrW0Xc"
|
|
7749
8310
|
},
|
|
7750
8311
|
{
|
|
@@ -7752,6 +8313,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7752
8313
|
name: "Chikobo Rural Health Centre",
|
|
7753
8314
|
locationType: "HEALTH_FACILITY",
|
|
7754
8315
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8316
|
+
validUntil: null,
|
|
7755
8317
|
externalId: "zE4qPn2SgJ5d"
|
|
7756
8318
|
},
|
|
7757
8319
|
{
|
|
@@ -7759,6 +8321,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7759
8321
|
name: "Chilochabalenje Health Post",
|
|
7760
8322
|
locationType: "HEALTH_FACILITY",
|
|
7761
8323
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8324
|
+
validUntil: null,
|
|
7762
8325
|
externalId: "H8vDs1MqR4Uf"
|
|
7763
8326
|
},
|
|
7764
8327
|
{
|
|
@@ -7766,6 +8329,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7766
8329
|
name: "Chipeso Rural Health Centre",
|
|
7767
8330
|
locationType: "HEALTH_FACILITY",
|
|
7768
8331
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8332
|
+
validUntil: null,
|
|
7769
8333
|
externalId: "Qw3uZ9KfX6Lm"
|
|
7770
8334
|
},
|
|
7771
8335
|
{
|
|
@@ -7773,6 +8337,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7773
8337
|
name: "Chisamba Rural Health Centre",
|
|
7774
8338
|
locationType: "HEALTH_FACILITY",
|
|
7775
8339
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8340
|
+
validUntil: null,
|
|
7776
8341
|
externalId: "Yr0pCg8LdM2s"
|
|
7777
8342
|
},
|
|
7778
8343
|
{
|
|
@@ -7780,6 +8345,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7780
8345
|
name: "Chitanda Rural Health Centre",
|
|
7781
8346
|
locationType: "HEALTH_FACILITY",
|
|
7782
8347
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8348
|
+
validUntil: null,
|
|
7783
8349
|
externalId: "tS9gJ4PwB1Qx"
|
|
7784
8350
|
},
|
|
7785
8351
|
{
|
|
@@ -7787,6 +8353,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7787
8353
|
name: "Golden Valley Rural Health Centre",
|
|
7788
8354
|
locationType: "HEALTH_FACILITY",
|
|
7789
8355
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8356
|
+
validUntil: null,
|
|
7790
8357
|
externalId: "Ld7Qm3XsA8Vr"
|
|
7791
8358
|
},
|
|
7792
8359
|
{
|
|
@@ -7794,6 +8361,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7794
8361
|
name: "Ipongo Rural Health Centre",
|
|
7795
8362
|
locationType: "HEALTH_FACILITY",
|
|
7796
8363
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8364
|
+
validUntil: null,
|
|
7797
8365
|
externalId: "kF2sW9DmH0Bt"
|
|
7798
8366
|
},
|
|
7799
8367
|
{
|
|
@@ -7801,6 +8369,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7801
8369
|
name: "Itumbwe Health Post",
|
|
7802
8370
|
locationType: "HEALTH_FACILITY",
|
|
7803
8371
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8372
|
+
validUntil: null,
|
|
7804
8373
|
externalId: "Ue5Xb3VaC7Pq"
|
|
7805
8374
|
},
|
|
7806
8375
|
{
|
|
@@ -7808,6 +8377,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7808
8377
|
name: "Kabangalala Rural Health Centre",
|
|
7809
8378
|
locationType: "HEALTH_FACILITY",
|
|
7810
8379
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8380
|
+
validUntil: null,
|
|
7811
8381
|
externalId: "Pz8Kc1TqH6Jn"
|
|
7812
8382
|
},
|
|
7813
8383
|
// Village offices
|
|
@@ -7816,10 +8386,10 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7816
8386
|
name: "Klow Village Office",
|
|
7817
8387
|
locationType: "CRVS_OFFICE",
|
|
7818
8388
|
administrativeAreaId: "1d4e5f6a-7b8c-4912-8efa-345678901234",
|
|
8389
|
+
validUntil: null,
|
|
7819
8390
|
externalId: "PmAyxAJkxiJ"
|
|
7820
8391
|
}
|
|
7821
8392
|
];
|
|
7822
|
-
var V2_DEFAULT_MOCK_LOCATIONS = MOCK_LOCATIONS_BASE.map(withVersionFields);
|
|
7823
8393
|
var V2_DEFAULT_MOCK_LOCATIONS_MAP = new Map(
|
|
7824
8394
|
V2_DEFAULT_MOCK_LOCATIONS.map((l) => [l.id, l])
|
|
7825
8395
|
);
|