001package ca.cdr.api.model.enm;
002
003/*
004 * #%L
005 * Smile CDR - CDR
006 * %%
007 * Copyright (C) 2016 - 2026 Smile CDR, Inc.
008 * %%
009 * All rights reserved.
010 * #L%
011 */
012
013import ca.cdr.api.security.permission.PermissionArgumentFormat;
014import ca.cdr.api.security.permission.PermissionArgumentFormats;
015import jakarta.annotation.Nonnull;
016import org.apache.commons.text.StringTokenizer;
017
018import java.util.ArrayList;
019import java.util.Arrays;
020import java.util.Collection;
021import java.util.Collections;
022import java.util.EnumSet;
023import java.util.List;
024import java.util.Locale;
025import java.util.Optional;
026import java.util.Set;
027import java.util.stream.Collectors;
028
029import static org.apache.commons.lang3.StringUtils.isBlank;
030import static org.apache.commons.lang3.StringUtils.isNotBlank;
031import static org.apache.commons.lang3.StringUtils.trim;
032
033public enum PermissionEnum {
034
035        /*
036         * Sorting agnostic, but don't change which one is first because swagger uses it as an example.
037         */
038
039        /**
040         * User has permission to change password
041         */
042        CHANGE_OWN_PASSWORD(PermissionCategoryEnum.USER_MANAGER),
043
044        /**
045         * User can log in to EasyShare
046         */
047        ACCESS_EASYSHARE(PermissionCategoryEnum.EASYSHARE),
048
049        /**
050         * User can create a SMART Health Link using EasyShare
051         */
052        EASYSHARE_CREATE_SMART_HEALTH_LINK(PermissionCategoryEnum.EASYSHARE, PermissionEnum.ACCESS_EASYSHARE),
053
054        //      TODO: add this once this UI is created
055        //      /**
056        //       * User can manage SMART Health Links in EasyShare
057        //       */
058        //      EASYSHARE_MANAGE_ALL_SMART_HEALTH_LINKS(
059        //                      PermissionCategoryEnum.EASYSHARE, new PermissionEnum[] {PermissionEnum.ACCESS_EASYSHARE}),
060
061        /**
062         * User can update their own launch contexts
063         */
064        CHANGE_OWN_DEFAULT_LAUNCH_CONTEXTS(PermissionCategoryEnum.USER_MANAGER),
065
066        /**
067         * User can change their own TFA key
068         */
069        CHANGE_OWN_TFA_KEY(PermissionCategoryEnum.USER_MANAGER),
070
071        /**
072         * User is allowed to log into the web admin console
073         */
074        ACCESS_ADMIN_WEB(PermissionCategoryEnum.ADMIN, CHANGE_OWN_PASSWORD),
075
076        /**
077         * User is allowed to use the JSON Admin API services
078         */
079        ACCESS_ADMIN_JSON(PermissionCategoryEnum.ADMIN),
080
081        /**
082         * User is allowed to access FHIR services
083         */
084        ACCESS_FHIR_ENDPOINT(PermissionCategoryEnum.FHIR_CLIENT),
085
086        /**
087         * User has permission to log into the FHIRWeb console
088         */
089        ACCESS_FHIRWEB(PermissionCategoryEnum.ADMIN),
090
091        /**
092         * User can access internal metrics API, including thread dump API
093         */
094        VIEW_METRICS(PermissionCategoryEnum.ADMIN),
095
096        /**
097         * User can see (but not change) status information about modules. This includes running/stopped status, health checks, etc., but does not give access to more sensitive details such as logs.
098         */
099        VIEW_MODULE_STATUS(PermissionCategoryEnum.ADMIN),
100
101        /**
102         * User can see (but not change) module configuration information (not including database passwords)
103         */
104        VIEW_MODULE_CONFIG(PermissionCategoryEnum.ADMIN, VIEW_MODULE_STATUS),
105
106        /**
107         * User can archive module
108         */
109        ARCHIVE_MODULE(PermissionCategoryEnum.ADMIN, VIEW_MODULE_CONFIG),
110
111        /**
112         * User can reinstate module
113         */
114        REINSTATE_MODULE(PermissionCategoryEnum.ADMIN, VIEW_MODULE_CONFIG),
115
116        /**
117         * User is allowed to view existing OpenID Connect client list
118         */
119        OPENID_CONNECT_VIEW_CLIENT_LIST(PermissionCategoryEnum.ADMIN),
120
121        /**
122         * User is allowed to view existing OpenID Connect server list
123         */
124        OPENID_CONNECT_VIEW_SERVER_LIST(PermissionCategoryEnum.ADMIN),
125
126        /**
127         * User is allowed to create OpenID Connect clients
128         */
129        OPENID_CONNECT_ADD_CLIENT(PermissionCategoryEnum.ADMIN),
130
131        /**
132         * User is allowed to create OpenID Connect clients with pre-set permissions
133         */
134        OIDC_CLIENT_PRESET_PERMISSION(
135                        PermissionCategoryEnum.ADMIN,
136                        OPENID_CONNECT_ADD_CLIENT,
137                        TakesArgumentEnum.YES,
138                        PermissionArgumentFormats.NO_ARGUMENT_FORMAT),
139
140        /**
141         * User is allowed to add OpenID Connect servers
142         */
143        OPENID_CONNECT_ADD_SERVER(PermissionCategoryEnum.ADMIN),
144
145        /**
146         * User is allowed to edit OpenID Connect servers
147         */
148        OPENID_CONNECT_EDIT_SERVER(PermissionCategoryEnum.ADMIN),
149
150        /**
151         * User is allowed to edit existing OpenID Connect clients
152         */
153        OPENID_CONNECT_EDIT_CLIENT(PermissionCategoryEnum.ADMIN),
154
155        /**
156         * User is allows to manage other users' OIDC sessions (view active sessions and revoke them).
157         */
158        OPENID_CONNECT_MANAGE_GLOBAL_SESSIONS(PermissionCategoryEnum.ADMIN),
159
160        /**
161         * User is allowed to manage (view/create/update/delete) OIDC Keystore definitions
162         */
163        OPENID_CONNECT_MANAGE_KEYSTORES(PermissionCategoryEnum.ADMIN),
164
165        /**
166         * User can create other users
167         */
168        CREATE_USER(PermissionCategoryEnum.USER_MANAGER),
169
170        /**
171         * User can update existing users other than themself
172         */
173        UPDATE_USER(PermissionCategoryEnum.USER_MANAGER),
174
175        /**
176         * User can view list of users
177         */
178        VIEW_USERS(PermissionCategoryEnum.USER_MANAGER),
179
180        /**
181         * User can view, create, and update users
182         */
183        SAVE_USER(PermissionCategoryEnum.USER_MANAGER, CREATE_USER, UPDATE_USER, VIEW_USERS),
184
185        /**
186         * User is allowed to use a FHIR client
187         */
188        ROLE_FHIR_CLIENT(PermissionCategoryEnum.FHIR_CLIENT, ACCESS_FHIR_ENDPOINT),
189
190        /**
191         * Actions performed by the system itself.
192         * Implied permissions are populated internally and not explicitly defined in the constructor.
193         */
194        ROLE_SYSTEM(PermissionCategoryEnum.SYSTEM),
195
196        /**
197         * Actions performed by the system itself during initialization
198         */
199        ROLE_SYSTEM_INITIALIZATION(PermissionCategoryEnum.SYSTEM, ROLE_SYSTEM),
200
201        /**
202         * User is allowed to view the audit log
203         */
204        VIEW_AUDIT_LOG(PermissionCategoryEnum.ADMIN),
205
206        /**
207         * User is allowed to view the transaction log
208         */
209        VIEW_TRANSACTION_LOG(PermissionCategoryEnum.ADMIN),
210
211        /**
212         * User is allowed to view entries in the transaction log
213         */
214        VIEW_TRANSACTION_LOG_EVENT(PermissionCategoryEnum.ADMIN),
215
216        /**
217         * User is allowed to configure troubleshooting loggers (attach the troubleshooting appender and change
218         * log levels) and to include log files in a downloaded system configuration bundle.
219         */
220        MANAGE_TROUBLESHOOTING_LOGGING(PermissionCategoryEnum.ADMIN, VIEW_MODULE_CONFIG),
221
222        /**
223         * User is allowed to modify a module's configuration
224         */
225        UPDATE_MODULE_CONFIG(PermissionCategoryEnum.ADMIN, VIEW_MODULE_CONFIG),
226
227        /**
228         * User is allowed to start/stop modules
229         */
230        START_STOP_MODULE(PermissionCategoryEnum.ADMIN),
231
232        /**
233         * User can start/stop/restart modules
234         */
235        CONTROL_MODULE(PermissionCategoryEnum.ADMIN, VIEW_MODULE_CONFIG, START_STOP_MODULE),
236
237        /**
238         * User is allowed to create new modules
239         */
240        CREATE_MODULE(PermissionCategoryEnum.ADMIN, VIEW_MODULE_CONFIG),
241
242        /**
243         * User is allowed to create, reconfigure and start/stop modules
244         */
245        MODULE_ADMIN(
246                        PermissionCategoryEnum.ADMIN,
247                        CREATE_MODULE,
248                        UPDATE_MODULE_CONFIG,
249                        CONTROL_MODULE,
250                        REINSTATE_MODULE,
251                        ARCHIVE_MODULE,
252                        START_STOP_MODULE,
253                        VIEW_MODULE_CONFIG),
254
255        /**
256         * User is allowed to access (includes both read and write operations) data in all
257         * partitions. Note that this permission does not actually authorize any specific read/write
258         * operations, it simply implies access to the partitions.
259         */
260        FHIR_ACCESS_PARTITION_ALL(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
261
262        /**
263         * User is allowed to access (includes both read and write operations) data in the given
264         * partition. Note that this permission does not actually authorize any specific read/write
265         * operations, it simply implies access to the given partition.
266         */
267        FHIR_ACCESS_PARTITION_NAME(
268                        PermissionCategoryEnum.FHIR_CLIENT,
269                        ROLE_FHIR_CLIENT,
270                        TakesArgumentEnum.YES,
271                        PermissionArgumentFormats.NO_ARGUMENT_FORMAT),
272
273        /**
274         * User is allowed to invoke the ConceptMap/$hapi.fhir.add-mapping and
275         * ConceptMap/$hapi.fhir.remove-mapping operations
276         */
277        FHIR_OP_ADD_AND_REMOVE_CONCEPT_MAPPING(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
278
279        /**
280         * User is allowed to invoke the $binary-access-XXX operation (note that the user
281         * will also need permission to read/write the individual resource that is
282         * actually being accessed)
283         */
284        FHIR_OP_BINARY_ACCESS_READ(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
285
286        /**
287         * User is allowed to invoke the $binary-access-XXX operation (note that the user
288         * will also need permission to read/write the individual resource that is
289         * actually being accessed)
290         */
291        FHIR_OP_BINARY_ACCESS_WRITE(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
292
293        /**
294         * User is allowed to invoke the $hapi.fhir.bulk-patch operation. This is a potentially destructive
295         * operation, so this permission should only be granted to trusted administrative
296         * users. The Bulk Patch operation must also be enabled in the FHIR Storage module
297         * configuration to use this operation.
298         */
299        FHIR_OP_BULK_PATCH(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
300
301        /**
302         * User is allowed to invoke the $hapi.fhir.bulk-patch-rewrite-history operation. This is a potentially destructive
303         * operation, so this permission should only be granted to trusted administrative
304         * users. The Bulk Patch operation must also be enabled in the FHIR Storage module
305         * configuration to use this operation.
306         */
307        FHIR_OP_BULK_PATCH_REWRITE_HISTORY(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
308
309        /**
310         * User is allowed to initiate a bulk data export using the $export operation
311         */
312        FHIR_OP_INITIATE_BULK_DATA_EXPORT(
313                        PermissionCategoryEnum.FHIR_CLIENT,
314                        ROLE_FHIR_CLIENT,
315                        TakesArgumentEnum.OPTIONAL,
316                        PermissionArgumentFormats.EXPORT_RESOURCE_TYPES_FORMAT),
317
318        /**
319         * User is allowed to initiate a bulk data import using the $import operation
320         */
321        FHIR_OP_INITIATE_BULK_DATA_IMPORT(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
322
323        /**
324         * Bulk export - group Level
325         */
326        FHIR_OP_INITIATE_BULK_DATA_EXPORT_GROUP(
327                        PermissionCategoryEnum.FHIR_CLIENT,
328                        ROLE_FHIR_CLIENT,
329                        TakesArgumentEnum.YES,
330                        PermissionArgumentFormats.COMPARTMENT_WITH_EXPORT_RESOURCE_TYPES_FORMAT),
331
332        /**
333         * Bulk export - Group level, query the permitted Group compartment(s) by FHIR query
334         */
335        FHIR_OP_INITIATE_BULK_DATA_EXPORT_GROUPS_MATCHING(
336                        PermissionCategoryEnum.FHIR_CLIENT,
337                        ROLE_FHIR_CLIENT,
338                        TakesArgumentEnum.YES,
339                        PermissionArgumentFormats
340                                        .COMPARTMENT_BY_MATCHING_QUERY_WITH_EXPORT_RESOURCE_TYPES_PERMISSION_ARGUMENT_FORMAT),
341
342        /**
343         * Bulk export - Patient Level
344         *
345         * @deprecated In favour of FHIR_OP_INITIATE_BULK_DATA_EXPORT_PATIENTS and FHIR_OP_INITIATE_BULK_DATA_EXPORT_ALL_PATIENTS
346         */
347        @Deprecated
348        FHIR_OP_INITIATE_BULK_DATA_EXPORT_PATIENT(
349                        PermissionCategoryEnum.FHIR_CLIENT,
350                        ROLE_FHIR_CLIENT,
351                        TakesArgumentEnum.OPTIONAL,
352                        PermissionArgumentFormats.COMPARTMENT_WITH_EXPORT_RESOURCE_TYPES_FORMAT),
353
354        /**
355         * Bulk Export for a list of patient IDs and resource types
356         */
357        FHIR_OP_INITIATE_BULK_DATA_EXPORT_PATIENTS(
358                        PermissionCategoryEnum.FHIR_CLIENT,
359                        ROLE_FHIR_CLIENT,
360                        TakesArgumentEnum.OPTIONAL,
361                        PermissionArgumentFormats.COMPARTMENTS_WITH_EXPORT_RESOURCE_TYPES_FORMAT),
362
363        /**
364         * Bulk export - Patient level, query the permitted Patient compartment(s) by FHIR query
365         */
366        FHIR_OP_INITIATE_BULK_DATA_EXPORT_PATIENTS_MATCHING(
367                        PermissionCategoryEnum.FHIR_CLIENT,
368                        ROLE_FHIR_CLIENT,
369                        TakesArgumentEnum.YES,
370                        PermissionArgumentFormats
371                                        .COMPARTMENT_BY_MATCHING_QUERY_WITH_EXPORT_RESOURCE_TYPES_PERMISSION_ARGUMENT_FORMAT),
372
373        /**
374         * Bulk Export for all patients
375         */
376        FHIR_OP_INITIATE_BULK_DATA_EXPORT_ALL_PATIENTS(
377                        PermissionCategoryEnum.FHIR_CLIENT,
378                        ROLE_FHIR_CLIENT,
379                        TakesArgumentEnum.NO,
380                        PermissionArgumentFormats.OPTIONAL_FILTER_FORMAT),
381
382        /**
383         * Bulk export - System Level
384         */
385        FHIR_OP_INITIATE_BULK_DATA_EXPORT_SYSTEM(
386                        PermissionCategoryEnum.FHIR_CLIENT,
387                        ROLE_FHIR_CLIENT,
388                        TakesArgumentEnum.OPTIONAL,
389                        PermissionArgumentFormats.EXPORT_RESOURCE_TYPES_FORMAT),
390
391        /**
392         * User is allowed to invoke the server-level $reindex operation.
393         */
394        FHIR_OP_REINDEX(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
395
396        /**
397         * Permission required to run mdm dedpulicate operation
398         * and view the results.
399         */
400        FHIR_OP_MDM_DEDUPLICATE(PermissionCategoryEnum.MDM),
401
402        /**
403         * User is allowed to read search parameters
404         */
405        FHIR_READ_SEARCH_PARAMETERS(
406                        PermissionCategoryEnum.FHIR_CLIENT,
407                        new PermissionEnum[] {
408                                // does not imply FHIR_CLIENT since this can be used for JSON Admin functions too
409                        }),
410
411        /**
412         * User is allowed to create, update, and delete search parameters
413         */
414        FHIR_MODIFY_SEARCH_PARAMETERS(
415                        PermissionCategoryEnum.FHIR_CLIENT,
416                        new PermissionEnum[] {
417                                // does not imply FHIR_CLIENT since this can be used for JSON Admin functions too
418                        }),
419
420        /**
421         * User is allowed to read any resources in the given compartment
422         */
423        FHIR_READ_ALL_IN_COMPARTMENT(
424                        PermissionCategoryEnum.FHIR_CLIENT,
425                        ROLE_FHIR_CLIENT,
426                        TakesArgumentEnum.YES,
427                        PermissionArgumentFormats.COMPARTMENT_WITH_OPTIONAL_FILTER_FORMAT),
428
429        /**
430         * User is allowed to write any resources in the given compartment
431         */
432        FHIR_WRITE_ALL_IN_COMPARTMENT(
433                        PermissionCategoryEnum.FHIR_CLIENT,
434                        ROLE_FHIR_CLIENT,
435                        TakesArgumentEnum.YES,
436                        PermissionArgumentFormats.COMPARTMENT_WITH_OPTIONAL_FILTER_FORMAT),
437
438        /**
439         * User is allowed to read any resources of the given type in the given compartment
440         */
441        FHIR_READ_TYPE_IN_COMPARTMENT(
442                        PermissionCategoryEnum.FHIR_CLIENT,
443                        ROLE_FHIR_CLIENT,
444                        TakesArgumentEnum.YES,
445                        PermissionArgumentFormats.TYPE_IN_COMPARTMENT_WITH_OPTIONAL_FILTER_FORMAT),
446
447        /**
448         * User is allowed to write any resources of the given type in the given compartment
449         */
450        FHIR_WRITE_TYPE_IN_COMPARTMENT(
451                        PermissionCategoryEnum.FHIR_CLIENT,
452                        ROLE_FHIR_CLIENT,
453                        TakesArgumentEnum.YES,
454                        PermissionArgumentFormats.TYPE_IN_COMPARTMENT_WITH_OPTIONAL_FILTER_FORMAT),
455
456        /**
457         * User is allowed to read any resources of the given type
458         */
459        FHIR_READ_ALL_OF_TYPE(
460                        PermissionCategoryEnum.FHIR_CLIENT,
461                        ROLE_FHIR_CLIENT,
462                        TakesArgumentEnum.YES,
463                        PermissionArgumentFormats.RESOURCE_TYPE_OPTIONAL_FILTER_FORMAT),
464
465        /**
466         * User is allowed to write any resources of the given type
467         */
468        FHIR_WRITE_ALL_OF_TYPE(
469                        PermissionCategoryEnum.FHIR_CLIENT,
470                        ROLE_FHIR_CLIENT,
471                        TakesArgumentEnum.YES,
472                        PermissionArgumentFormats.RESOURCE_TYPE_OPTIONAL_FILTER_FORMAT),
473
474        /**
475         * User is allowed to read a specific resource instance by ID
476         */
477        FHIR_READ_INSTANCE(
478                        PermissionCategoryEnum.FHIR_CLIENT,
479                        ROLE_FHIR_CLIENT,
480                        TakesArgumentEnum.YES,
481                        PermissionArgumentFormats.INSTANCE_WITH_OPTIONAL_FILTER_FORMAT),
482
483        /**
484         * User is allowed to write a specific resource instance by ID
485         */
486        FHIR_WRITE_INSTANCE(
487                        PermissionCategoryEnum.FHIR_CLIENT,
488                        ROLE_FHIR_CLIENT,
489                        TakesArgumentEnum.YES,
490                        PermissionArgumentFormats.INSTANCE_WITH_OPTIONAL_FILTER_FORMAT),
491
492        /**
493         * User may read a resource only if its code is in the given ValueSet.
494         */
495        BLOCK_FHIR_READ_UNLESS_CODE_IN_VS(
496                        PermissionCategoryEnum.FHIR_CLIENT,
497                        TakesArgumentEnum.YES,
498                        true,
499                        PermissionArgumentFormats.CODE_IN_VALUE_SET_FILTER_FORMAT,
500                        new PermissionEnum[] {ROLE_FHIR_CLIENT}),
501
502        /**
503         * User may read a resource only if its code is not in the given ValueSet.
504         */
505        BLOCK_FHIR_READ_UNLESS_CODE_NOT_IN_VS(
506                        PermissionCategoryEnum.FHIR_CLIENT,
507                        TakesArgumentEnum.YES,
508                        true,
509                        PermissionArgumentFormats.CODE_IN_VALUE_SET_FILTER_FORMAT,
510                        new PermissionEnum[] {ROLE_FHIR_CLIENT}),
511
512        /**
513         * User is permitted to invoke the $expunge operation with expungeDeletedResources=true
514         */
515        FHIR_EXPUNGE_DELETED(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
516
517        /**
518         * User is permitted to invoke the $expunge operation with expungePreviousVersions=true
519         */
520        FHIR_EXPUNGE_PREVIOUS_VERSIONS(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
521
522        /**
523         * User is permitted to invoke the $expunge operation with expungeEverything=true
524         */
525        FHIR_EXPUNGE_EVERYTHING(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
526
527        /**
528         * User is permitted to invoke the $delete-expunge operation
529         */
530        FHIR_DELETE_EXPUNGE(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
531
532        /**
533         * User is permitted to invoke the $livebundle-watchlist-add, $livebundle-watchlist-delete, $livebundle-watchlist, and $livebundle operations
534         */
535        FHIR_LIVEBUNDLE(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
536
537        /**
538         * User is permitted to invoke the operations
539         * $partition-management-create-partition,
540         * $partition-management-read-partition,
541         * $partition-management-update-partition,
542         * $partition-management-delete-partition,
543         * $partition-management-list-partitions,
544         */
545        FHIR_MANAGE_PARTITIONS(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
546
547        /**
548         * User is permitted to create or update Subscription resources. Write
549         * permission on the Subscription resource type is not sufficient. This permission is
550         * never implied by the superuser roles and must be granted explicitly.
551         */
552        FHIR_MANAGE_SUBSCRIPTIONS(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
553
554        /**
555         * User is permitted to invoke the $meta, $meta-add, and $meta-delete operations on
556         * any resource.
557         */
558        FHIR_META_OPERATIONS_SUPERUSER(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
559
560        /**
561         * User may invoke any kind of operation
562         */
563        FHIR_EXTENDED_OPERATION_SUPERUSER(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
564
565        /**
566         * User may invoke operation with name specified by argument (e.g. $fooOperation)
567         */
568        FHIR_EXTENDED_OPERATION_ON_SERVER(
569                        PermissionCategoryEnum.FHIR_CLIENT,
570                        ROLE_FHIR_CLIENT,
571                        TakesArgumentEnum.YES,
572                        PermissionArgumentFormats.OPERATION_FORMAT),
573
574        /**
575         * User may invoke operation at the type level with type and name specified by argument (e.g. Patient/$fooOperation)
576         */
577        FHIR_EXTENDED_OPERATION_ON_TYPE(
578                        PermissionCategoryEnum.FHIR_CLIENT,
579                        ROLE_FHIR_CLIENT,
580                        TakesArgumentEnum.YES,
581                        PermissionArgumentFormats.OPERATION_ON_RESOURCE_TYPE_FORMAT),
582
583        /**
584         * User may invoke operation at the instance level for any type with name specified by argument (e.g. $fooOperation)
585         */
586        FHIR_EXTENDED_OPERATION_ON_ANY_INSTANCE(
587                        PermissionCategoryEnum.FHIR_CLIENT,
588                        ROLE_FHIR_CLIENT,
589                        TakesArgumentEnum.YES,
590                        PermissionArgumentFormats.OPERATION_ON_ANY_INSTANCE_FORMAT),
591
592        /**
593         * User may invoke operation at the instance level with type and name specified by argument (e.g. Patient/$fooOperation)
594         */
595        FHIR_EXTENDED_OPERATION_ON_ANY_INSTANCE_OF_TYPE(
596                        PermissionCategoryEnum.FHIR_CLIENT,
597                        ROLE_FHIR_CLIENT,
598                        TakesArgumentEnum.YES,
599                        PermissionArgumentFormats.OPERATION_ON_ANY_INSTANCE_OF_TYPE),
600
601        /**
602         * User may invoke the MDM $match operation on a Patient
603         */
604        FHIR_OP_PATIENT_MATCH(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
605
606        /**
607         * User may invoke the $sdh.mdm-bundle-match operation on a Bundle
608         */
609        FHIR_OP_MDM_BUNDLE_MATCH(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
610
611        /**
612         * User may invoke the MDM $mdm-merge-golden-resources operation on Golden Resources
613         */
614        FHIR_OP_MDM_MERGE_GOLDEN_RESOURCES(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
615
616        /**
617         * User may invoke the MDM $mdm-update-link operation on a Golden Resource
618         */
619        FHIR_OP_MDM_UPDATE_LINK(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
620
621        /**
622         * User may invoke the MDM $mdm-create-link operation on a Golden Resource
623         */
624        FHIR_OP_MDM_CREATE_LINK(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
625
626        /**
627         * User may invoke the MDM $mdm-query-links operation
628         */
629        FHIR_OP_MDM_QUERY_LINKS(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
630
631        /**
632         * User may invoke the MDM $mdm-query-links operation
633         */
634        FHIR_OP_MDM_LINK_HISTORY(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
635
636        /**
637         * User may invoke the MDM $mdm-duplicate-golden-resources
638         */
639        FHIR_OP_MDM_DUPLICATE_GOLDEN_RESOURCES(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
640
641        /**
642         * User may invoke the MDM $mdm-not-duplicate
643         */
644        FHIR_OP_MDM_NOT_DUPLICATE(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
645
646        /**
647         * User may invoke the MDM $mdm-clear Operation
648         */
649        FHIR_OP_MDM_CLEAR(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
650
651        /**
652         * User may invoke the MDM $mdm-submit operation
653         */
654        FHIR_OP_MDM_SUBMIT(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
655
656        /**
657         * User may perform all MDM operations
658         */
659        FHIR_MDM_ADMIN(
660                        PermissionCategoryEnum.FHIR_CLIENT,
661                        FHIR_OP_MDM_SUBMIT,
662                        FHIR_OP_MDM_CLEAR,
663                        FHIR_OP_MDM_DUPLICATE_GOLDEN_RESOURCES,
664                        FHIR_OP_MDM_NOT_DUPLICATE,
665                        FHIR_OP_MDM_MERGE_GOLDEN_RESOURCES,
666                        FHIR_OP_MDM_QUERY_LINKS,
667                        FHIR_OP_MDM_LINK_HISTORY,
668                        FHIR_OP_MDM_UPDATE_LINK,
669                        FHIR_OP_MDM_CREATE_LINK),
670
671        /**
672         * Legacy permission for backward compatibility. Use corresponding MDM permission instead.
673         */
674        FHIR_OP_EMPI_MERGE_PERSONS(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
675
676        /**
677         * Legacy permission for backward compatibility. Use corresponding MDM permission instead.
678         */
679        FHIR_OP_EMPI_UPDATE_LINK(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
680
681        /**
682         * Legacy permission for backward compatibility. Use corresponding MDM permission instead.
683         */
684        FHIR_OP_EMPI_QUERY_LINKS(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
685
686        /**
687         * Legacy permission for backward compatibility. Use corresponding MDM permission instead.
688         */
689        FHIR_OP_EMPI_DUPLICATE_PERSONS(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
690
691        /**
692         * Legacy permission for backward compatibility. Use corresponding MDM permission instead.
693         */
694        FHIR_OP_EMPI_CLEAR(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
695
696        /**
697         * Legacy permission for backward compatibility. Use corresponding MDM permission instead.
698         */
699        FHIR_OP_EMPI_SUBMIT(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
700
701        /**
702         * Legacy permission for backward compatibility. Use corresponding MDM permission instead.
703         */
704        FHIR_EMPI_ADMIN(
705                        PermissionCategoryEnum.FHIR_CLIENT,
706                        FHIR_OP_EMPI_SUBMIT,
707                        FHIR_OP_EMPI_CLEAR,
708                        FHIR_OP_EMPI_DUPLICATE_PERSONS,
709                        FHIR_OP_EMPI_MERGE_PERSONS,
710                        FHIR_OP_EMPI_QUERY_LINKS,
711                        FHIR_OP_EMPI_UPDATE_LINK),
712
713        /**
714         * CQL Permission for evaluate-measure operation.
715         */
716        FHIR_OP_EVALUATE_MEASURE(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
717        /**
718         * Permission for submit-data operation.
719         */
720        FHIR_OP_SUBMIT_DATA(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
721        /**
722         * Permission for care-gaps operation.
723         */
724        FHIR_OP_CARE_GAPS(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
725        /**
726         * Permission for evaluate operation.
727         */
728        FHIR_OP_EVALUATE(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
729        /**
730         * Permission for $collect-data operation.
731         */
732        FHIR_OP_COLLECTDATA(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
733        /**
734         * Permission for $data-requirements operation.
735         */
736        FHIR_OP_DATAREQUIREMENTS(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
737        /**
738         * Permission for cql operation.
739         */
740        FHIR_OP_CQL(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
741        /**
742         * Permission for evaluate-measures operation.
743         */
744        FHIR_OP_EVALUATE_MEASURES(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
745        /**
746         * Permission for qpp-build operation.
747         */
748        DQM_QPP_BUILD(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
749        /**
750         * Permission for job-analytics operation
751         */
752        BATCH_JOB_ANALYTICS(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
753
754        /**
755         * User is permitted to call the $apply operation
756         */
757        FHIR_OP_APPLY(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
758
759        /**
760         * User is permitted to call the $prepopulate operation
761         */
762        FHIR_OP_PREPOPULATE(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
763
764        /**
765         * User is permitted to call the $populate operation
766         */
767        FHIR_OP_POPULATE(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
768
769        /**
770         * User is permitted to call the $extract operation
771         */
772        FHIR_OP_EXTRACT(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
773
774        /**
775         * User is permitted to call the $package operation
776         */
777        FHIR_OP_PACKAGE(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
778
779        /**
780         * User is permitted to call the $hapi.fhir.replace-references operation
781         */
782        FHIR_OP_REPLACE_REFERENCES(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
783
784        /**
785         * User is permitted to call the $merge operation
786         */
787        FHIR_OP_MERGE(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
788
789        /**
790         * User may perform all DTR operations
791         */
792        FHIR_DTR_USER(PermissionCategoryEnum.FHIR_CLIENT, FHIR_OP_PACKAGE, FHIR_OP_POPULATE),
793
794        /**
795         * User is allowed to perform any FHIR read/access-to-data operation, e.g. `read`, `search`, `history`, etc
796         */
797        FHIR_ALL_READ(
798                        PermissionCategoryEnum.FHIR_CLIENT,
799                        TakesArgumentEnum.NO,
800                        false,
801                        PermissionArgumentFormats.OPTIONAL_FILTER_FORMAT,
802                        new PermissionEnum[] {ROLE_FHIR_CLIENT, FHIR_READ_SEARCH_PARAMETERS}),
803
804        /**
805         * User is allowed to perform FHIR transactions
806         */
807        FHIR_TRANSACTION(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
808
809        /**
810         * User is allowed to perform FHIR GraphQL Operations
811         */
812        FHIR_GRAPHQL(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
813
814        /**
815         * User is allowed to perform FHIR transactions
816         */
817        FHIR_BATCH(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
818
819        /**
820         * User is allowed to perform FHIR PATCH operations
821         *
822         * @deprecated FHIR_PATCH will be removed:  Users should instead be granted more granular write permissions that cover PATCH operations.
823         */
824        @Deprecated
825        FHIR_PATCH(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
826
827        /**
828         * User is allowed to perform any FHIR write/modify operation, e.g. `create`, `update`, etc
829         */
830        FHIR_ALL_WRITE(
831                        PermissionCategoryEnum.FHIR_CLIENT,
832                        TakesArgumentEnum.NO,
833                        false,
834                        PermissionArgumentFormats.OPTIONAL_FILTER_FORMAT,
835                        new PermissionEnum[] {ROLE_FHIR_CLIENT, FHIR_MODIFY_SEARCH_PARAMETERS, FHIR_META_OPERATIONS_SUPERUSER}),
836
837        /**
838         * User is allowed to perform any FHIR delete operation
839         */
840        FHIR_ALL_DELETE(
841                        PermissionCategoryEnum.FHIR_CLIENT,
842                        TakesArgumentEnum.OPTIONAL,
843                        false,
844                        PermissionArgumentFormats.OPTIONAL_FILTER_FORMAT,
845                        new PermissionEnum[] {ROLE_FHIR_CLIENT}),
846
847        /**
848         * User is allowed to perform any FHIR delete operation on the given type
849         */
850        FHIR_DELETE_ALL_OF_TYPE(
851                        PermissionCategoryEnum.FHIR_CLIENT,
852                        ROLE_FHIR_CLIENT,
853                        TakesArgumentEnum.YES,
854                        PermissionArgumentFormats.RESOURCE_TYPE_OPTIONAL_FILTER_FORMAT),
855
856        /**
857         * User is allowed to perform any FHIR delete operation on a given compartment
858         */
859        FHIR_DELETE_ALL_IN_COMPARTMENT(
860                        PermissionCategoryEnum.FHIR_CLIENT,
861                        ROLE_FHIR_CLIENT,
862                        TakesArgumentEnum.YES,
863                        PermissionArgumentFormats.COMPARTMENT_WITH_OPTIONAL_FILTER_FORMAT),
864
865        /**
866         * User is allowed to perform any FHIR delete operation on a given compartment
867         */
868        FHIR_DELETE_TYPE_IN_COMPARTMENT(
869                        PermissionCategoryEnum.FHIR_CLIENT,
870                        ROLE_FHIR_CLIENT,
871                        TakesArgumentEnum.YES,
872                        PermissionArgumentFormats.TYPE_IN_COMPARTMENT_WITH_OPTIONAL_FILTER_FORMAT),
873
874        /**
875         * Any delete permissions granted to the user may be applied to cascaded deletes
876         * as well as normal deletes. Note that this permission allows cascaded deletes
877         * to occur, but does not actually grant any permission to delete resources in
878         * the first place. This permission must be combined with other permissions that
879         * grant the ability to cascade deletes.
880         */
881        FHIR_DELETE_CASCADE_ALLOWED(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
882
883        /**
884         * User is allowed to access the server capability statement
885         */
886        FHIR_CAPABILITIES(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
887
888        /**
889         * User is allowed to invoke the `$validate` operation to validate resources
890         */
891        FHIR_MANUAL_VALIDATION(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
892
893        /**
894         * User is allowed to invoke the `$semantic-uplift` operation to uplift resources
895         */
896        FHIR_SEMANTIC_UPLIFT(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
897
898        /**
899         * User is allowed to invoke the `$process-message` operation to accept a message
900         */
901        FHIR_PROCESS_MESSAGE(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
902
903        /**
904         * User is allowed to invoke the <code>$invalidate-valueset</code> operation
905         */
906        FHIR_OP_TERMINOLOGY_INVALIDATE_VALUESET(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
907
908        /**
909         * User is permitted to upload external code systems
910         */
911        FHIR_UPLOAD_EXTERNAL_TERMINOLOGY(
912                        PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT, FHIR_OP_TERMINOLOGY_INVALIDATE_VALUESET),
913
914        /**
915         * User is permitted to call the $get-resource-counts operation
916         */
917        FHIR_GET_RESOURCE_COUNTS(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
918
919        /**
920         * User is allowed to invoke the $trigger-subscription operation
921         */
922        FHIR_TRIGGER_SUBSCRIPTION(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
923
924        /**
925         * User is permitted to call read-only terminology methods, such as
926         * $lookup, $validate-code
927         */
928        ROLE_FHIR_TERMINOLOGY_READ_CLIENT(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
929
930        /**
931         * User is allowed to perform the patient $everything operation
932         */
933        FHIR_OP_PATIENT_EVERYTHING(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
934
935        /**
936         * User is allowed to perform the patient $everything operation with `Access All` permission
937         */
938        FHIR_OP_PATIENT_EVERYTHING_ACCESS_ALL(
939                        PermissionCategoryEnum.FHIR_CLIENT,
940                        ROLE_FHIR_CLIENT,
941                        TakesArgumentEnum.YES,
942                        PermissionArgumentFormats.INSTANCE_WITH_OPTIONAL_FILTER_FORMAT),
943
944        /**
945         * User is allowed to perform the patient $summary operation
946         */
947        FHIR_OP_PATIENT_SUMMARY(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
948
949        /**
950         * User is allowed to perform the encounter $everything operation
951         */
952        FHIR_OP_ENCOUNTER_EVERYTHING(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
953
954        /**
955         * User is allowed to perform the $snapshot operation
956         */
957        FHIR_OP_STRUCTUREDEFINITION_SNAPSHOT(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
958
959        /**
960         * User is allowed to perform the $member-match operation
961         */
962        FHIR_OP_MEMBER_MATCH(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
963
964        /**
965         * User is allowed to execute HFQL queries
966         */
967        HFQL_EXECUTE(),
968
969        /**
970         * Any read functions
971         */
972        ROLE_FHIR_CLIENT_SUPERUSER_RO(
973                        PermissionCategoryEnum.FHIR_CLIENT,
974                        FHIR_CAPABILITIES,
975                        FHIR_ALL_READ,
976                        FHIR_TRANSACTION,
977                        FHIR_GRAPHQL,
978                        FHIR_BATCH,
979                        FHIR_OP_ENCOUNTER_EVERYTHING,
980                        FHIR_OP_PATIENT_EVERYTHING,
981                        FHIR_OP_PATIENT_SUMMARY,
982                        FHIR_OP_BINARY_ACCESS_READ,
983                        FHIR_GET_RESOURCE_COUNTS,
984                        ROLE_FHIR_TERMINOLOGY_READ_CLIENT,
985                        FHIR_OP_INITIATE_BULK_DATA_EXPORT),
986
987        /**
988         * User has permission to perform any standard FHIR client operation (does not imply superuser status for other parts of the CDR, e.g. user management, FHIR search parameter modification, etc)
989         * Implied permissions are populated internally and not explicitly defined in the constructor.
990         */
991        ROLE_FHIR_CLIENT_SUPERUSER(PermissionCategoryEnum.FHIR_CLIENT),
992
993        /**
994         * User has all permissions to do anything
995         * Implied permissions are populated internally and not explicitly defined in the constructor.
996         */
997        ROLE_SUPERUSER(PermissionCategoryEnum.ADMIN),
998
999        /**
1000         * User is not logged in or has not supplied credentials
1001         */
1002        ROLE_ANONYMOUS(),
1003
1004        /**
1005         * User is allowed to initiate processing an ETL job
1006         */
1007        ETL_IMPORT_PROCESS_FILE(),
1008
1009        /**
1010         * User is allowed to view CDA Document Templates
1011         */
1012        VIEW_CDA_TEMPLATE(PermissionCategoryEnum.CDA),
1013
1014        /**
1015         * User is allowed to create new CDA Document Templates
1016         */
1017        CREATE_CDA_TEMPLATE(PermissionCategoryEnum.CDA, PermissionEnum.VIEW_CDA_TEMPLATE),
1018
1019        /**
1020         * User is allowed to delete CDA Document Templates
1021         */
1022        DELETE_CDA_TEMPLATE(PermissionCategoryEnum.CDA, PermissionEnum.VIEW_CDA_TEMPLATE),
1023
1024        /**
1025         * User is allowed to use CDA Document Templates,
1026         * potentially persisting a Composition, Bundle, and returning sensitive information in the resultant XML
1027         */
1028        USE_CDA_TEMPLATE(PermissionCategoryEnum.CDA, PermissionEnum.VIEW_CDA_TEMPLATE),
1029
1030        /**
1031         * User can set/update MDM match rules
1032         */
1033        MDM_UPDATE_MATCH_RULES(PermissionCategoryEnum.MDM),
1034
1035        /**
1036         * User can see MDM match rules
1037         */
1038        MDM_VIEW_MATCH_RULES(PermissionCategoryEnum.MDM),
1039
1040        /**
1041         * User can perform any MDM operations
1042         */
1043        MDM_ADMIN(PermissionCategoryEnum.MDM, PermissionEnum.MDM_VIEW_MATCH_RULES, PermissionEnum.MDM_UPDATE_MATCH_RULES),
1044
1045        /**
1046         * User will have MDM expansion performed automatically on all queries
1047         */
1048        FHIR_AUTO_MDM(PermissionCategoryEnum.MDM),
1049
1050        /**
1051         * Legacy permission for backward compatibility. Use corresponding MDM permission instead.
1052         */
1053        EMPI_UPDATE_MATCH_RULES(PermissionCategoryEnum.EMPI),
1054
1055        /**
1056         * Legacy permission for backward compatibility. Use corresponding MDM permission instead.
1057         */
1058        EMPI_VIEW_MATCH_RULES(PermissionCategoryEnum.EMPI),
1059
1060        /**
1061         * Legacy permission for backward compatibility. Use corresponding MDM permission instead.
1062         */
1063        EMPI_ADMIN(
1064                        PermissionCategoryEnum.EMPI, PermissionEnum.EMPI_VIEW_MATCH_RULES, PermissionEnum.EMPI_UPDATE_MATCH_RULES),
1065
1066        /**
1067         * User can perform read operations from the package registry
1068         */
1069        PACKAGE_REGISTRY_READ(PermissionCategoryEnum.PACKAGE_REGISTRY),
1070
1071        /**
1072         * User can perform read operations from the package registry
1073         */
1074        PACKAGE_REGISTRY_WRITE(PermissionCategoryEnum.PACKAGE_REGISTRY),
1075
1076        /**
1077         * User can call CDS Hooks
1078         */
1079        INVOKE_CDS_HOOKS(PermissionCategoryEnum.CDS_HOOKS),
1080
1081        /**
1082         * User can perform read operations from the appSphere Admin Console
1083         */
1084        AG_ADMIN_CONSOLE_READ(PermissionCategoryEnum.AG_ADMIN_CONSOLE),
1085
1086        /**
1087         * User can perform write operations from the appSphere Admin Console
1088         */
1089        AG_ADMIN_CONSOLE_WRITE(PermissionCategoryEnum.AG_ADMIN_CONSOLE),
1090
1091        /**
1092         * User can perform read operations from the appSphere Developer Portal
1093         */
1094        AG_DEV_PORTAL_READ(PermissionCategoryEnum.AG_DEV_PORTAL),
1095
1096        /**
1097         * User can perform write operations from the appSphere Developer Portal
1098         */
1099        AG_DEV_PORTAL_WRITE(PermissionCategoryEnum.AG_DEV_PORTAL),
1100
1101        /**
1102         * User has permission to view batch jobs
1103         */
1104        VIEW_BATCH_JOBS(PermissionCategoryEnum.ADMIN),
1105
1106        /**
1107         * User has permission to manage (modify) batch jobs
1108         */
1109        MANAGE_BATCH_JOBS(PermissionCategoryEnum.ADMIN),
1110
1111        /**
1112         * User can perform a docref operation
1113         */
1114        DOCREF(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
1115
1116        /**
1117         * User can perform a CDA Import operation
1118         */
1119        CDA_IMPORT(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
1120
1121        /**
1122         * User can perform the $sdh.cda-to-fhir operation
1123         */
1124        SDH_CDA_TO_FHIR(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
1125
1126        /**
1127         * User can perform the $sdh.generate-cda operation
1128         */
1129        SMILE_GENERATE_CDA(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
1130
1131        /**
1132         * User can perform an update on the historical version of a resource
1133         */
1134        FHIR_UPDATE_REWRITE_HISTORY(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
1135
1136        SUBMIT_ATTACHMENT(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
1137
1138        /**
1139         * User can see (but not change) module configuration information (not including database passwords)
1140         * for a specific module id for a node id
1141         */
1142        VIEW_MODULE_CONFIG_FOR_MODULE(
1143                        PermissionCategoryEnum.ADMIN,
1144                        TakesArgumentEnum.YES,
1145                        false,
1146                        PermissionArgumentFormats.NODE_AND_MODULE_ID_PERMISSION_ARGUMENT_FORMAT,
1147                        new PermissionEnum[] {VIEW_MODULE_STATUS}),
1148        /**
1149         * User is allowed to modify a specific module id's configuration for a node id
1150         */
1151        UPDATE_MODULE_CONFIG_FOR_MODULE(
1152                        PermissionCategoryEnum.ADMIN,
1153                        TakesArgumentEnum.YES,
1154                        false,
1155                        PermissionArgumentFormats.NODE_AND_MODULE_ID_PERMISSION_ARGUMENT_FORMAT,
1156                        new PermissionEnum[] {VIEW_MODULE_CONFIG_FOR_MODULE}),
1157        /**
1158         * User is allowed to start/stop a specific module id for a node id
1159         */
1160        START_STOP_MODULE_FOR_MODULE(
1161                        PermissionCategoryEnum.ADMIN,
1162                        TakesArgumentEnum.YES,
1163                        false,
1164                        PermissionArgumentFormats.NODE_AND_MODULE_ID_PERMISSION_ARGUMENT_FORMAT,
1165                        new PermissionEnum[] {}),
1166        /**
1167         * User can start/stop/restart a specific module id for a node id
1168         */
1169        CONTROL_MODULE_FOR_MODULE(
1170                        PermissionCategoryEnum.ADMIN,
1171                        TakesArgumentEnum.YES,
1172                        false,
1173                        PermissionArgumentFormats.NODE_AND_MODULE_ID_PERMISSION_ARGUMENT_FORMAT,
1174                        new PermissionEnum[] {VIEW_MODULE_CONFIG_FOR_MODULE, START_STOP_MODULE_FOR_MODULE}),
1175
1176        /**
1177         * User is allowed to reconfigure and start/stop a specific module id for a node id
1178         */
1179        MODULE_ADMIN_FOR_MODULE(
1180                        PermissionCategoryEnum.ADMIN,
1181                        TakesArgumentEnum.YES,
1182                        false,
1183                        PermissionArgumentFormats.NODE_AND_MODULE_ID_PERMISSION_ARGUMENT_FORMAT,
1184                        new PermissionEnum[] {
1185                                UPDATE_MODULE_CONFIG_FOR_MODULE,
1186                                CONTROL_MODULE_FOR_MODULE,
1187                                START_STOP_MODULE_FOR_MODULE,
1188                                VIEW_MODULE_CONFIG_FOR_MODULE
1189                        }),
1190        ROLE_MDMUI_DATASTEWARD_FHIR(
1191                        PermissionCategoryEnum.FHIR_CLIENT,
1192                        FHIR_ALL_READ,
1193                        FHIR_BATCH,
1194                        FHIR_TRANSACTION,
1195                        FHIR_OP_MDM_DUPLICATE_GOLDEN_RESOURCES,
1196                        FHIR_OP_MDM_LINK_HISTORY,
1197                        FHIR_OP_MDM_MERGE_GOLDEN_RESOURCES,
1198                        FHIR_OP_MDM_NOT_DUPLICATE,
1199                        FHIR_OP_MDM_QUERY_LINKS,
1200                        FHIR_OP_MDM_UPDATE_LINK,
1201                        ROLE_FHIR_TERMINOLOGY_READ_CLIENT),
1202        ROLE_MDMUI_ADMIN_FHIR(
1203                        PermissionCategoryEnum.FHIR_CLIENT, ROLE_MDMUI_DATASTEWARD_FHIR, FHIR_OP_MDM_CLEAR, FHIR_OP_MDM_SUBMIT),
1204
1205        /** User will be assigned roles by giving permission APP_ROLE/MDM_UI_DATA_STEWARD */
1206        APP_ROLE(
1207                        PermissionCategoryEnum.ROLE,
1208                        TakesArgumentEnum.YES,
1209                        false,
1210                        PermissionArgumentFormats.ROLE_NAME_FORMAT,
1211                        new PermissionEnum[] {}),
1212
1213        CUSTOM_ROLE(
1214                        PermissionCategoryEnum.ROLE,
1215                        TakesArgumentEnum.YES,
1216                        false,
1217                        PermissionArgumentFormats.ROLE_NAME_FORMAT,
1218                        new PermissionEnum[] {}),
1219
1220        FHIR_OP_UPDATE_TOKENIZATION(PermissionCategoryEnum.FHIR_CLIENT, ROLE_FHIR_CLIENT),
1221
1222        /**
1223         * User is allowed to see all Smile Portal applications
1224         */
1225        SMILE_PORTAL_ALL(PermissionCategoryEnum.SMILE_PORTAL),
1226
1227        /**
1228         * User is allowed to see a specific Smile Portal application(s)
1229         */
1230        SMILE_PORTAL_OF_TYPE(
1231                        PermissionCategoryEnum.SMILE_PORTAL,
1232                        TakesArgumentEnum.YES,
1233                        false,
1234                        PermissionArgumentFormats.SMILE_PORTAL_APPLICATION_TYPE_FORMAT,
1235                        new PermissionEnum[] {}),
1236
1237        /**
1238         * User is allowed to access the Camel HTTP Endpoint
1239         */
1240        ACCESS_CAMEL_HTTP_ENDPOINT(PermissionCategoryEnum.FHIR_CLIENT),
1241
1242        INVOKE_ANY_CAMEL_HTTP_ENDPOINT(PermissionCategoryEnum.FHIR_CLIENT, ACCESS_CAMEL_HTTP_ENDPOINT),
1243        INVOKE_ALL_CAMEL_HTTP_ENDPOINTS_ON_MODULE(
1244                        PermissionCategoryEnum.FHIR_CLIENT,
1245                        ACCESS_CAMEL_HTTP_ENDPOINT,
1246                        TakesArgumentEnum.YES,
1247                        PermissionArgumentFormats.MODULE_ID_PERMISSION_ARGUMENT_FORMAT),
1248        INVOKE_CAMEL_HTTP_ENDPOINT(
1249                        PermissionCategoryEnum.FHIR_CLIENT,
1250                        ACCESS_CAMEL_HTTP_ENDPOINT,
1251                        TakesArgumentEnum.YES,
1252                        PermissionArgumentFormats.MODULE_ID_AND_MAPPING_PERMISSION_ARGUMENT_FORMAT),
1253
1254        /**
1255         * Permission to read CustomScheduledJobExecutionDetails.
1256         */
1257        READ_ANY_SCHEDULED_JOB_HISTORY(PermissionCategoryEnum.SYSTEM),
1258
1259        /**
1260         * Permission to read CustomScheduledJobDetails
1261         */
1262        READ_ANY_SCHEDULED_JOB(PermissionCategoryEnum.SYSTEM, READ_ANY_SCHEDULED_JOB_HISTORY),
1263
1264        /**
1265         * Permissions required to trigger an existing CustomScheduledJob
1266         */
1267        TRIGGER_ANY_SCHEDULED_JOB(PermissionCategoryEnum.SYSTEM, READ_ANY_SCHEDULED_JOB),
1268
1269        /**
1270         * Permission required to create a CustomScheduledJob.
1271         */
1272        CREATE_ANY_SCHEDULED_JOB(PermissionCategoryEnum.SYSTEM, READ_ANY_SCHEDULED_JOB, TRIGGER_ANY_SCHEDULED_JOB),
1273
1274        /**
1275         * Permission required to update a CustomScheduled Job
1276         */
1277        UPDATE_ANY_SCHEDULED_JOB(PermissionCategoryEnum.SYSTEM, READ_ANY_SCHEDULED_JOB, TRIGGER_ANY_SCHEDULED_JOB),
1278
1279        /**
1280         * Permissions required to delete an existing CustomScheduledJob
1281         */
1282        DELETE_ANY_SCHEDULED_JOB(PermissionCategoryEnum.SYSTEM, READ_ANY_SCHEDULED_JOB),
1283
1284        /**
1285         * Permission required to trigger a repartition operation ($sdh.repartition-by-reference)
1286         */
1287        FHIR_REPARTITION_BY_REFERENCE;
1288
1289        private static final Set<PermissionEnum> ROLES = getRoles();
1290
1291        static {
1292                ROLE_SYSTEM.myImplies = getAllPermissions();
1293                ROLE_SUPERUSER.myImplies = getAllSuperuserPermissions();
1294                ROLE_FHIR_CLIENT_SUPERUSER.myImplies = getAllFhirSuperuserPermissions();
1295
1296                /*
1297                 * Creating EnumSet with enum elements that have not been initialized fails (not a bug).
1298                 * Use a static block to replace Set with EnumSet once everything is initialized.
1299                 * {@link https://bugs.openjdk.org/browse/JDK-8211749}.
1300                 */
1301                for (PermissionEnum next : values()) {
1302                        next.myImplies = unmodifiableEnumSet(next.myImplies.toArray(new PermissionEnum[0]));
1303                }
1304        }
1305
1306        private final TakesArgumentEnum myTakesArgument;
1307        private final boolean myNegativePermission;
1308        private Set<PermissionEnum> myImplies;
1309        private final PermissionCategoryEnum myCategory;
1310        /**
1311         * The format for the argument - defaults to no argument
1312         */
1313        private final PermissionArgumentFormat<?> myFormat;
1314
1315        /**
1316         * Constructor for permissions with just a name
1317         */
1318        PermissionEnum() {
1319                this(null);
1320        }
1321
1322        /**
1323         * Constructor for permissions with an assigned category
1324         */
1325        PermissionEnum(PermissionCategoryEnum theCategory) {
1326                this(theCategory, new PermissionEnum[] {});
1327        }
1328
1329        /**
1330         * Constructor for permissions that have implied (underlying) permissions
1331         */
1332        PermissionEnum(PermissionCategoryEnum theCategory, PermissionEnum... theImplies) {
1333                this(theCategory, TakesArgumentEnum.NO, false, PermissionArgumentFormats.NO_ARGUMENT_FORMAT, theImplies);
1334        }
1335
1336        /**
1337         * Constructor for permissions with arguments.
1338         */
1339        PermissionEnum(
1340                        PermissionCategoryEnum theCategory,
1341                        PermissionEnum theImplied,
1342                        TakesArgumentEnum theTakesArgument,
1343                        PermissionArgumentFormat<?> theFormat) {
1344                this(theCategory, theTakesArgument, false, theFormat, new PermissionEnum[] {theImplied});
1345        }
1346
1347        /**
1348         * Constructor for permissions with implied (underlying) permissions and/or with arguments.
1349         */
1350        PermissionEnum(
1351                        PermissionCategoryEnum theCategory,
1352                        TakesArgumentEnum theTakesArgument,
1353                        boolean theNegativePermission,
1354                        PermissionArgumentFormat<?> theFormat,
1355                        PermissionEnum[] theImplies) {
1356                assert theTakesArgument != null;
1357                assert !theNegativePermission || name().startsWith("BLOCK_");
1358                myImplies = Set.of(theImplies);
1359                myCategory = theCategory;
1360                myTakesArgument = theTakesArgument;
1361                myNegativePermission = theNegativePermission;
1362                myFormat = theFormat;
1363                validateInheritedPermissionsFormat(theImplies, theFormat);
1364        }
1365
1366        public static void validateInheritedPermissionsFormat(
1367                        PermissionEnum[] theImplies, PermissionArgumentFormat<?> theFormat) {
1368                if (Arrays.stream(theImplies).anyMatch(x -> x.isRequiresArgument() && (x.getFormat() != theFormat))) {
1369                        throw new IllegalArgumentException(
1370                                        "Implied Permissions with arguments must accept the same argument format as Parent permission. "
1371                                                        + theFormat);
1372                }
1373        }
1374
1375        @Deprecated(since = "7.2.0")
1376        public Set<PermissionCategoryEnum> getCategories() {
1377                return Set.of(myCategory);
1378        }
1379
1380        public PermissionCategoryEnum getCategory() {
1381                return myCategory;
1382        }
1383
1384        public Set<PermissionEnum> getImplies() {
1385                return myImplies;
1386        }
1387
1388        public boolean isSystemPermission() {
1389                return this == ROLE_SYSTEM_INITIALIZATION || this == ROLE_SYSTEM;
1390        }
1391
1392        public boolean isTakesArgument() {
1393                return myTakesArgument != TakesArgumentEnum.NO;
1394        }
1395
1396        public boolean isRequiresArgument() {
1397                return myTakesArgument == TakesArgumentEnum.YES;
1398        }
1399
1400        public boolean isArgumentOptional() {
1401                return myTakesArgument == TakesArgumentEnum.OPTIONAL;
1402        }
1403
1404        public boolean isNegative() {
1405                return myNegativePermission;
1406        }
1407
1408        /**
1409         * The format for the argument - defaults to NoArgument format
1410         */
1411        public PermissionArgumentFormat<?> getFormat() {
1412                return myFormat;
1413        }
1414
1415        private enum TakesArgumentEnum {
1416                YES,
1417                NO,
1418                OPTIONAL
1419        }
1420
1421        @Nonnull
1422        public static Optional<PermissionEnum> find(String thePermission) {
1423                try {
1424                        return Optional.of(PermissionEnum.valueOf(thePermission.toUpperCase(Locale.ROOT)));
1425                } catch (NullPointerException | IllegalArgumentException e) {
1426                        return Optional.empty();
1427                }
1428        }
1429
1430        @Nonnull
1431        public static List<PermissionEnum> findAll(List<String> thePermissions) {
1432                return Optional.ofNullable(thePermissions).stream()
1433                                .flatMap(Collection::stream)
1434                                .map(PermissionEnum::find)
1435                                .filter(Optional::isPresent)
1436                                .map(Optional::get)
1437                                .collect(Collectors.toList());
1438        }
1439
1440        private static <T extends Enum<T>> Set<T> unmodifiableEnumSet(T[] theValues) {
1441                if (theValues.length == 0) {
1442                        return Collections.emptySet();
1443                }
1444                Set<T> set = EnumSet.of(theValues[0], theValues);
1445                return Collections.unmodifiableSet(set);
1446        }
1447
1448        @Deprecated(since = "7.2.0")
1449        public static Set<PermissionEnum> roles() {
1450                return ROLES;
1451        }
1452
1453        public static String extractFirstSpaceSeparatedArgument(String theArgument) {
1454                if (isNotBlank(theArgument)) {
1455                        int spaceIdx = theArgument.indexOf(' ');
1456                        if (spaceIdx != -1) {
1457                                return trim(theArgument.substring(0, spaceIdx));
1458                        } else {
1459                                return theArgument;
1460                        }
1461                }
1462                return null;
1463        }
1464
1465        public static Collection<String> extractSpaceSeparatedResourceTypesFromArgument(String theArgument) {
1466                return extractSpaceSeparatedResourceTypesFromArgument(theArgument, 0);
1467        }
1468
1469        public static Collection<String> extractSpaceSeparatedResourceTypesFromArgument(
1470                        String theArgument, int theFromOffsetIndex) {
1471                if (isBlank(theArgument)) {
1472                        return null;
1473                }
1474                StringTokenizer tok = new StringTokenizer(theArgument, " ");
1475                List<String> retVal = new ArrayList<>();
1476                while (tok.hasNext()) {
1477                        String next = tok.next();
1478                        next = trim(next);
1479                        if (isNotBlank(next)) {
1480                                if (theFromOffsetIndex > 0) {
1481                                        theFromOffsetIndex--;
1482                                        continue;
1483                                }
1484                                retVal.add(next);
1485                        }
1486                }
1487                return retVal;
1488        }
1489
1490        private static Set<PermissionEnum> getAllPermissions() {
1491                return Arrays.stream(values())
1492                                .filter(p -> !p.isRole())
1493                                .filter(p -> !p.isRequiresArgument())
1494                                .collect(Collectors.toSet());
1495        }
1496
1497        private static Set<PermissionEnum> getAllSuperuserPermissions() {
1498                return Arrays.stream(values())
1499                                .filter(p -> !p.isRole())
1500                                .filter(p -> !p.isExpungePermission())
1501                                .filter(p -> !p.isExplicitGrantOnly())
1502                                .filter(p -> !p.isRequiresArgument())
1503                                .collect(Collectors.toSet());
1504        }
1505
1506        private static Set<PermissionEnum> getAllFhirSuperuserPermissions() {
1507                Set<PermissionEnum> permissions = getAllSuperuserPermissions().stream()
1508                                .filter(PermissionEnum::isFhirPermission)
1509                                .collect(Collectors.toSet());
1510                permissions.add(ACCESS_FHIRWEB);
1511                return permissions;
1512        }
1513
1514        private static Set<PermissionEnum> getRoles() {
1515                Set<PermissionEnum> roles = Arrays.stream(values())
1516                                .filter(PermissionEnum::isRole)
1517                                .collect(Collectors.toCollection(() -> EnumSet.noneOf(PermissionEnum.class)));
1518                return Collections.unmodifiableSet(roles);
1519        }
1520
1521        public boolean isRole() {
1522                // unlike other roles, the terminology role is involved in the logic that checks the access
1523                return name().startsWith("ROLE_") && this != ROLE_FHIR_TERMINOLOGY_READ_CLIENT;
1524        }
1525
1526        public boolean isExpungePermission() {
1527                return name().toLowerCase().contains("expunge");
1528        }
1529
1530        /**
1531         * Permissions that are never implied by {@link #ROLE_SUPERUSER} or {@link #ROLE_FHIR_CLIENT_SUPERUSER}
1532         * and must be granted explicitly. {@link #ROLE_SYSTEM} still implies them.
1533         *
1534         * @return true if this permission must be granted explicitly
1535         */
1536        public boolean isExplicitGrantOnly() {
1537                return this == FHIR_MANAGE_SUBSCRIPTIONS;
1538        }
1539
1540        /**
1541         * Determines if this is a FHIR delete permission.
1542         *
1543         * @return true if FHIR delete, false otherwise
1544         */
1545        public boolean isSuperuser() {
1546                return name().toLowerCase().contains("superuser");
1547        }
1548
1549        /**
1550         * Determines if this is a FHIR related permission.
1551         *
1552         * @return true if FHIR permission, false otherwise
1553         */
1554        public boolean isFhirPermission() {
1555                return PermissionCategoryEnum.FHIR_CLIENT.equals(myCategory);
1556        }
1557}