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}