Updated project build and dependencies

- Kotlin 1.3 -> 1.8
- Java 8 -> 17
- Gradle 6 -> 8
- Github Actions latest versions (removing deprecated Node 12 calls)
- Spring 5 -> 6
- Added several build features
  - ktlint for linting
  - dependencyUpdates for easier updating
  - dokka Javadoc-compatible documentation

Author: blootsvoets

.editorconfig

@@ -8,7 +8,6 @@ root = true
 # Change these settings to your own preference
 indent_style = space
 indent_size = 4
-continuation_indent_size = 8
 
 # We recommend you to keep these unchanged
 end_of_line = lf
@@ -22,4 +21,8 @@ trim_trailing_whitespace = false
 [*.{json,yaml,yml}]
 indent_style = space
 indent_size = 2
-continuation_indent_size = 4
+continuation_indent_size = 4
+
+[*.{kt,kts}]
+ktlint_standard_trailing-comma-on-call-site=disabled
+ktlint_standard_trailing-comma-on-declaration-site=disabled

.github/workflows/main.yml

@@ -17,24 +17,14 @@ jobs:
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
-      - uses: actions/setup-java@v1
+      - uses: actions/setup-java@v3
         with:
-          java-version: 11
+          java-version: 17
+          distribution: temurin
 
-      - name: Cache
-        uses: actions/[email protected]
-        with:
-          # Cache gradle directories
-          path: |
-            ~/.gradle/caches/jars-3
-            ~/.gradle/caches/modules-2/files-2.1/
-            ~/.gradle/caches/modules-2/metadata-2.96/
-            ~/.gradle/native
-            ~/.gradle/wrapper
-          # Key for restoring and saving the cache
-          key: ${{ runner.os }}-gradle
+      - uses: gradle/gradle-build-action@v2
 
       # Compile the code
       - name: Compile code

.github/workflows/release.yml

@@ -13,31 +13,21 @@ jobs:
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
         with:
-          java-version: 11
+          java-version: 17
+          distribution: temurin
 
-      - name: Cache
-        uses: actions/[email protected]
-        with:
-          # A list of files, directories, and wildcard patterns to cache and restore
-          path: |
-            ~/.gradle/caches/jars-3
-            ~/.gradle/caches/modules-2/files-2.1/
-            ~/.gradle/caches/modules-2/metadata-2.96/
-            ~/.gradle/native
-            ~/.gradle/wrapper
-          # An explicit key for restoring and saving the cache
-          key: ${{ runner.os }}-gradle
+      - uses: gradle/gradle-build-action@v2
 
       # Compile code
       - name: Compile code
         run: ./gradlew assemble
 
       # Upload it to GitHub
       - name: Upload to GitHub
-        uses: AButler/[email protected]
+        uses: AButler/[email protected].2
         with:
           files: 'build/libs/*;radar-spring-auth/build/libs/*'
           repo-token: ${{ secrets.GITHUB_TOKEN }}

README.md

@@ -14,13 +14,13 @@ Since we are using this in spring applications, we can use `spring-aop`. So add
 
 ```groovy
     repositories {
-        maven { url "https://dl.bintray.com/radar-base/org.radarbase" }
+        mavenCentral()
     }
     
     dependencies {
         // AOP
-        runtimeOnly(group: 'org.springframework', name: 'spring-aop', version: '5.2.4.RELEASE')
-        api(group: 'org.radarbase', name: 'radar-spring-auth', version: '1.0.0')
+        runtimeOnly("org.springframework:spring-aop:6.0.6")
+        api("org.radarbase:radar-spring-auth:1.2.0")
     }
 ```
 
@@ -71,27 +71,26 @@ public class AuthConfig {
 }
 ```
 
-Although, we only need `AuthAspect` as a bean, we declare it's dependencies as a bean too, so they can be reused in the application using `Autowired`.
+Although, we only need `AuthAspect` as a bean, we declare its dependencies as a bean too, so they can be reused in the application using `Autowired`.
 
 Now, we add the `Authorized` annotation to our method that we want to authorize for (these are usually spring `Controller` methods).
 
 ```java
-  @Authorized(permission = "READ", entity = "SUBJECT", permissionOn = PermissionOn.SUBJECT)
-  @GetMapping(
-      "/"
-          + "projects"
-          + "/"
-          + "{projectId}"
-          + "/"
-          + "users"
-          + "/"
-          + "{subjectId}")
-  public ResponseEntity<FcmUserDto> getUsersUsingProjectIdAndSubjectId(
-      @Valid @PathVariable String projectId, @Valid @PathVariable String subjectId) {
-
+@Authorized(permission = "READ", entity = "SUBJECT", permissionOn = PermissionOn.SUBJECT)
+@GetMapping(
+    "/"
+        + "projects"
+        + "/"
+        + "{projectId}"
+        + "/"
+        + "users"
+        + "/"
+        + "{subjectId}")
+public ResponseEntity<FcmUserDto> getUsersUsingProjectIdAndSubjectId(
+        @Valid @PathVariable String projectId, @Valid @PathVariable String subjectId) {
     return ResponseEntity.ok(
         this.userService.getUsersByProjectIdAndSubjectId(projectId, subjectId));
-  }
+}
 ```
 
 Various other conditions to verify can be provided using the `Authorized` annotation. For a full set, take a look at the [annotation class](./radar-spring-auth/src/main/kotlin/radar/spring/auth/common/Authorization.kt)
@@ -112,7 +111,7 @@ The `Authorized` annotation adds a request attribute named `radar_token` (presen
 ```java
 import java.util.Optional;
 import java.util.stream.Collectors;
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
 
 import radar.spring.auth.common.Authorization;
 import radar.spring.auth.common.Authorized;
@@ -131,47 +130,47 @@ import org.springframework.http.ResponseEntity;
 
 @RestController
 public class RadarProjectController {
-  // Your project Service
-  private transient ProjectService projectService;
+    // Your project Service
+    private transient ProjectService projectService;
 
-  private transient Authorization<RadarToken> authorization;
+    private transient Authorization<RadarToken> authorization;
 
-  public RadarProjectController(
-      ProjectService projectService, Optional<Authorization<RadarToken>> authorization) {
-    this.projectService = projectService;
-    this.authorization = authorization.orElse(null);
-  }
+    public RadarProjectController(
+        ProjectService projectService, Optional<Authorization<RadarToken>> authorization) {
+        this.projectService = projectService;
+        this.authorization = authorization.orElse(null);
+    }
 
 
-  @Authorized(permission = "READ", entity = "PROJECT")
-  @GetMapping("/" + "projects")
-  public ResponseEntity<ProjectDtos> getAllProjects(HttpServletRequest request) {
-
-    ProjectDtos projectDtos = this.projectService.getAllProjects();
-    if (authorization != null) {
-      RadarToken token = (RadarToken) request.getAttribute(AuthAspect.TOKEN_KEY);
-      ProjectDtos finalProjectDtos =
-          new ProjectDtos()
-              .setProjects(
-                  projectDtos.getProjects().stream()
-                      .filter(
-                          project ->
-                              authorization.hasPermission(
-                                  token,
-                                  "READ",
-                                  "PROJECT",
-                                  PermissionOn.PROJECT,
-                                  project.getProjectId(),
-                                  null,
-                                  null))
-                      .collect(Collectors.toList()));
-      return ResponseEntity.ok(finalProjectDtos);
-    } else {
-      // If not authorization object if present, means authorization is disabled.
-      // Remember how we added this as a bean initially.
-      return ResponseEntity.ok(projectDtos);
+    @Authorized(permission = "READ", entity = "PROJECT")
+    @GetMapping("/" + "projects")
+    public ResponseEntity<ProjectDtos> getAllProjects(HttpServletRequest request) {
+
+        ProjectDtos projectDtos = this.projectService.getAllProjects();
+        if (authorization != null) {
+            RadarToken token = (RadarToken) request.getAttribute(AuthAspect.TOKEN_KEY);
+            ProjectDtos finalProjectDtos =
+                new ProjectDtos()
+                    .setProjects(
+                        projectDtos.getProjects().stream()
+                            .filter(
+                                project ->
+                                    authorization.hasPermission(
+                                        token,
+                                        "READ",
+                                        "PROJECT",
+                                        PermissionOn.PROJECT,
+                                        project.getProjectId(),
+                                        null,
+                                        null))
+                            .collect(Collectors.toList()));
+            return ResponseEntity.ok(finalProjectDtos);
+        } else {
+            // If not authorization object if present, means authorization is disabled.
+            // Remember how we added this as a bean initially.
+            return ResponseEntity.ok(projectDtos);
+        }
     }
-  }
 }
 ```
 
@@ -181,24 +180,21 @@ public class RadarProjectController {
 The various parts of the application can be extended as required. Take a look at [AuthValidator](./radar-spring-auth/src/main/kotlin/radar/spring/auth/common/AuthValidator.kt) and [Authorization](./radar-spring-auth/src/main/kotlin/radar/spring/auth/common/Authorization.kt) interfaces which can be used to implement a new authorization. These can then be used to instantiate the `AuthAspect` to enable them.
 You can also add another Aspect as per your requirements in your own project and add it as a Bean in spring to start using it just like the `AuthAspect` from this library.
 
-
 The [required parameter](#parameters-required) names can also be changed as per your requirements apart from the default ones mentioned above. You can even specify multiple names as an array. These will need to be added when creating the `AuthAspect`. For example,
 
 ```java
-...
-  @Bean
-  AuthAspect getAuthAspect(
-      @Autowired ManagementPortalAuthValidator authValidator,
-      @Autowired ManagementPortalAuthorization authorization) {
+@Bean
+AuthAspect getAuthAspect(
+        @Autowired ManagementPortalAuthValidator authValidator,
+        @Autowired ManagementPortalAuthorization authorization) {
     return new AuthAspect<>(
       authValidator,
       authorization, 
-      new String[]{"projectId", "projectName", "project"},
-      new String[]{"subjectId", "login"}, 
-      new String[]{"sourceId", "source"}
+      Set.of("projectId", "projectName", "project"),
+      Set.of("subjectId", "login"), 
+      Set.of("sourceId", "source")
     );
-  }
-...
+}
 ```
 
 But Note that while you can modify the name of the parameters according to you liking, their type must always be `String`.