Feature/generations

README.md

@@ -1,5 +1,5 @@
-# Website NIAEFEUP - BackEnd  
-[![codecov](https://codecov.io/gh/NIAEFEUP/website-niaefeup-backend/branch/develop/graph/badge.svg?token=4OPGXYESGP)](https://codecov.io/gh/NIAEFEUP/website-niaefeup-backend)  
+# Website NIAEFEUP - BackEnd
+[![codecov](https://codecov.io/gh/NIAEFEUP/website-niaefeup-backend/branch/develop/graph/badge.svg?token=4OPGXYESGP)](https://codecov.io/gh/NIAEFEUP/website-niaefeup-backend)
 The online platform for NIAEFEUP.
 
 ## Development setup
@@ -21,7 +21,7 @@ For automatic restart to fire up every time a source file changes, make sure tha
 Run the following command in your shell:
 
 ```bash
-gradle bootRun
+./gradlew bootRun
 ```
 
 ### Linting
@@ -35,21 +35,27 @@ Although IntelliJ does not provide linting suggestions for Kotlin out of the box
 You can fire up the analysis yourself by running in your shell:
 
 ```bash
-gradle ktlintCheck
+./gradlew ktlintCheck
+```
+
+You can fix the lint automatically by running in your shell:
+
+```bash
+./gradlew ktlintFormat
 ```
 
 #### With a git hook
 
 You can setup a local precommit [git hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) for lint analysis running a Gradle task provided by the used linting plugin:
 
 ```bash
-gradle addKtlintCheckGitPreCommitHook
+./gradlew addKtlintCheckGitPreCommitHook
 ```
 
 Or even an auto-format hook, if that is your thing:
 
 ```bash
-gradle addKtlintFormatGitPreCommitHook
+./gradlew addKtlintFormatGitPreCommitHook
 ```
 
 ### Testing
@@ -63,7 +69,7 @@ Run the test suite as usual, selecting the respective task for running.
 Run the following command in your shell:
 
 ```bash
-gradle test
+./gradlew test
 ```
 
 ## Project Details

src/main/kotlin/pt/up/fe/ni/website/backend/annotations/validation/NoDuplicateRoles.kt

@@ -0,0 +1,25 @@
+package pt.up.fe.ni.website.backend.annotations.validation
+
+import jakarta.validation.Constraint
+import jakarta.validation.ConstraintValidator
+import jakarta.validation.ConstraintValidatorContext
+import jakarta.validation.Payload
+import kotlin.reflect.KClass
+import pt.up.fe.ni.website.backend.model.Role
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.RUNTIME)
+@Constraint(validatedBy = [NoDuplicateRolesValidator::class])
+@MustBeDocumented
+annotation class NoDuplicateRoles(
+    val message: String = "{no_duplicate_roles.error}",
+    val groups: Array<KClass<*>> = [],
+    val payload: Array<KClass<Payload>> = []
+)
+
+class NoDuplicateRolesValidator : ConstraintValidator<NoDuplicateRoles, List<Role>> {
+    override fun isValid(value: List<Role>, context: ConstraintValidatorContext?): Boolean {
+        val names = value.map { it.name }
+        return names.size == names.toSet().size
+    }
+}

src/main/kotlin/pt/up/fe/ni/website/backend/annotations/validation/SchoolYear.kt

@@ -0,0 +1,32 @@
+package pt.up.fe.ni.website.backend.annotations.validation
+
+import jakarta.validation.Constraint
+import jakarta.validation.ConstraintValidator
+import jakarta.validation.ConstraintValidatorContext
+import jakarta.validation.Payload
+import kotlin.reflect.KClass
+
+@Target(AnnotationTarget.FIELD)
+@Retention(AnnotationRetention.RUNTIME)
+@Constraint(validatedBy = [SchoolYearValidator::class])
+@MustBeDocumented
+annotation class SchoolYear(
+    val message: String = "{school_year.error}",
+    val groups: Array<KClass<*>> = [],
+    val payload: Array<KClass<Payload>> = []
+)
+
+class SchoolYearValidator : ConstraintValidator<SchoolYear, String> {
+    private val regex = Regex("\\d{2}-\\d{2}")
+
+    override fun isValid(value: String, context: ConstraintValidatorContext?): Boolean {
+        if (!value.matches(regex)) return false
+
+        val years = value.split("-")
+        if (years.size != 2) return false
+
+        val firstYear = years[0].toIntOrNull() ?: return false
+        val secondYear = years[1].toIntOrNull() ?: return false
+        return secondYear == firstYear + 1
+    }
+}

src/main/kotlin/pt/up/fe/ni/website/backend/controller/AccountController.kt

@@ -25,6 +25,6 @@ class AccountController(private val service: AccountService) {
     @PostMapping("/changePassword/{id}")
     fun changePassword(@PathVariable id: Long, @RequestBody dto: ChangePasswordDto): Map<String, String> {
         service.changePassword(id, dto)
-        return mapOf()
+        return emptyMap()
     }
 }

src/main/kotlin/pt/up/fe/ni/website/backend/controller/ErrorController.kt

@@ -1,5 +1,6 @@
 package pt.up.fe.ni.website.backend.controller
 
+import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.databind.exc.InvalidFormatException
 import com.fasterxml.jackson.databind.exc.MismatchedInputException
 import com.fasterxml.jackson.module.kotlin.MissingKotlinParameterException
@@ -9,6 +10,7 @@ import org.springframework.http.HttpStatus
 import org.springframework.http.converter.HttpMessageNotReadableException
 import org.springframework.security.access.AccessDeniedException
 import org.springframework.security.core.AuthenticationException
+import org.springframework.web.bind.MethodArgumentNotValidException
 import org.springframework.web.bind.annotation.ExceptionHandler
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.ResponseStatus
@@ -26,7 +28,7 @@ data class CustomError(val errors: List<SimpleError>)
 
 @RestController
 @RestControllerAdvice
-class ErrorController : ErrorController, Logging {
+class ErrorController(private val objectMapper: ObjectMapper) : ErrorController, Logging {
 
     @RequestMapping("/**")
     @ResponseStatus(HttpStatus.NOT_FOUND)
@@ -41,7 +43,23 @@ class ErrorController : ErrorController, Logging {
                 SimpleError(
                     violation.message,
                     violation.propertyPath.toString(),
-                    violation.invalidValue
+                    violation.invalidValue.takeIf { it.isSerializable() }
+                )
+            )
+        }
+        return CustomError(errors)
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException::class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    fun invalidArguments(e: MethodArgumentNotValidException): CustomError {
+        val errors = mutableListOf<SimpleError>()
+        e.bindingResult.fieldErrors.forEach { error ->
+            errors.add(
+                SimpleError(
+                    error.defaultMessage ?: "invalid",
+                    error.field,
+                    error.rejectedValue?.takeIf { it.isSerializable() }
                 )
             )
         }
@@ -112,4 +130,11 @@ class ErrorController : ErrorController, Logging {
     fun wrapSimpleError(msg: String, param: String? = null, value: Any? = null) = CustomError(
         mutableListOf(SimpleError(msg, param, value))
     )
+
+    fun Any.isSerializable() = try {
+        objectMapper.writeValueAsString(this)
+        true
+    } catch (err: Exception) {
+        false
+    }
 }

src/main/kotlin/pt/up/fe/ni/website/backend/controller/EventController.kt

@@ -9,7 +9,7 @@ import org.springframework.web.bind.annotation.RequestBody
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RestController
 import pt.up.fe.ni.website.backend.dto.entity.EventDto
-import pt.up.fe.ni.website.backend.service.EventService
+import pt.up.fe.ni.website.backend.service.activity.EventService
 
 @RestController
 @RequestMapping("/events")
@@ -30,7 +30,10 @@ class EventController(private val service: EventService) {
     fun createEvent(@RequestBody dto: EventDto) = service.createEvent(dto)
 
     @DeleteMapping("/{id}")
-    fun deleteEventById(@PathVariable id: Long) = service.deleteEventById(id)
+    fun deleteEventById(@PathVariable id: Long): Map<String, String> {
+        service.deleteEventById(id)
+        return emptyMap()
+    }
 
     @PutMapping("/{id}")
     fun updateEventById(

src/main/kotlin/pt/up/fe/ni/website/backend/controller/GenerationController.kt

@@ -0,0 +1,61 @@
+package pt.up.fe.ni.website.backend.controller
+
+import jakarta.validation.Valid
+import org.springframework.web.bind.annotation.DeleteMapping
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PatchMapping
+import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+import pt.up.fe.ni.website.backend.dto.entity.GenerationDto
+import pt.up.fe.ni.website.backend.dto.generations.UpdateGenerationDto
+import pt.up.fe.ni.website.backend.service.GenerationService
+
+@RestController
+@RequestMapping("/generations")
+class GenerationController(private val service: GenerationService) {
+    @GetMapping
+    fun getAllGenerations() = service.getAllGenerations()
+
+    @GetMapping("/{id:\\d+}")
+    fun getGenerationById(@PathVariable id: Long) = service.getGenerationById(id)
+
+    @GetMapping("/{year:\\d{2}-\\d{2}}")
+    fun getGenerationByYear(@PathVariable year: String) = service.getGenerationByYear(year)
+
+    @GetMapping("/latest")
+    fun getLatestGeneration() = service.getLatestGeneration()
+
+    @PostMapping("/new")
+    fun createNewGeneration(
+        @RequestBody dto: GenerationDto
+    ) = service.createNewGeneration(dto)
+
+    @PatchMapping("/{id:\\d+}")
+    fun updateGenerationById(
+        @PathVariable id: Long,
+        @RequestBody @Valid
+        dto: UpdateGenerationDto
+    ) = service.updateGenerationById(id, dto)
+
+    @PatchMapping("/{year:\\d{2}-\\d{2}}")
+    fun updateGenerationByYear(
+        @PathVariable year: String,
+        @RequestBody @Valid
+        dto: UpdateGenerationDto
+    ) = service.updateGenerationByYear(year, dto)
+
+    @DeleteMapping("/{id:\\d+}")
+    fun deleteGenerationById(@PathVariable id: Long): Map<String, String> {
+        service.deleteGenerationById(id)
+        return emptyMap()
+    }
+
+    @DeleteMapping("/{year:\\d{2}-\\d{2}}")
+    fun deleteGenerationByYear(@PathVariable year: String): Map<String, String> {
+        service.deleteGenerationByYear(year)
+        return emptyMap()
+    }
+}

src/main/kotlin/pt/up/fe/ni/website/backend/controller/PostController.kt

@@ -34,5 +34,8 @@ class PostController(private val service: PostService) {
     ) = service.updatePostById(postId, dto)
 
     @DeleteMapping("/{postId}")
-    fun deletePost(@PathVariable postId: Long) = service.deletePostById(postId)
+    fun deletePost(@PathVariable postId: Long): Map<String, String> {
+        service.deletePostById(postId)
+        return emptyMap()
+    }
 }

src/main/kotlin/pt/up/fe/ni/website/backend/controller/ProjectController.kt

@@ -9,7 +9,7 @@ import org.springframework.web.bind.annotation.RequestBody
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RestController
 import pt.up.fe.ni.website.backend.dto.entity.ProjectDto
-import pt.up.fe.ni.website.backend.service.ProjectService
+import pt.up.fe.ni.website.backend.service.activity.ProjectService
 
 @RestController
 @RequestMapping("/projects")
@@ -28,7 +28,10 @@ class ProjectController(private val service: ProjectService) {
     fun createNewProject(@RequestBody dto: ProjectDto) = service.createProject(dto)
 
     @DeleteMapping("/{id}")
-    fun deleteProjectById(@PathVariable id: Long) = service.deleteProjectById(id)
+    fun deleteProjectById(@PathVariable id: Long): Map<String, String> {
+        service.deleteProjectById(id)
+        return emptyMap()
+    }
 
     @PutMapping("/{id}")
     fun updatePostById(

src/main/kotlin/pt/up/fe/ni/website/backend/dto/entity/GenerationDto.kt

@@ -0,0 +1,8 @@
+package pt.up.fe.ni.website.backend.dto.entity
+
+import pt.up.fe.ni.website.backend.model.Generation
+
+class GenerationDto(
+    var schoolYear: String?,
+    val roles: List<RoleDto>
+) : EntityDto<Generation>()

src/main/kotlin/pt/up/fe/ni/website/backend/dto/entity/PerActivityRoleDto.kt

@@ -0,0 +1,11 @@
+package pt.up.fe.ni.website.backend.dto.entity
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import pt.up.fe.ni.website.backend.model.PerActivityRole
+
+class PerActivityRoleDto(
+    @JsonProperty(required = true)
+    val activityId: Long?,
+
+    val permissions: List<Int>
+) : EntityDto<PerActivityRole>()

src/main/kotlin/pt/up/fe/ni/website/backend/dto/entity/RoleDto.kt

@@ -0,0 +1,15 @@
+package pt.up.fe.ni.website.backend.dto.entity
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import pt.up.fe.ni.website.backend.model.Role
+
+class RoleDto(
+    val name: String,
+    val permissions: List<Int>,
+
+    @JsonProperty(required = true)
+    val isSection: Boolean?,
+
+    val accountIds: List<Long> = emptyList(),
+    val associatedActivities: List<PerActivityRoleDto>
+) : EntityDto<Role>()

src/main/kotlin/pt/up/fe/ni/website/backend/dto/generations/GetGenerationDto.kt

@@ -0,0 +1,41 @@
+package pt.up.fe.ni.website.backend.dto.generations
+
+import com.fasterxml.jackson.annotation.JsonUnwrapped
+import pt.up.fe.ni.website.backend.model.Account
+import pt.up.fe.ni.website.backend.model.Generation
+
+typealias GetGenerationDto = List<GenerationSectionDto>
+
+data class GenerationUserDto(
+    @JsonUnwrapped
+    val account: Account,
+    val roles: List<String>
+)
+
+data class GenerationSectionDto(
+    val section: String,
+    val accounts: List<GenerationUserDto>
+)
+
+fun buildGetGenerationDto(generation: Generation): GetGenerationDto {
+    val usedAccounts = mutableSetOf<Account>()
+    val sections = generation.roles
+        .filter { it.isSection && it.accounts.isNotEmpty() }
+        .map { role ->
+            GenerationSectionDto(
+                section = role.name,
+                accounts = role.accounts
+                    .filter { !usedAccounts.contains(it) }
+                    .map { account ->
+                        usedAccounts.add(account)
+                        GenerationUserDto(
+                            account,
+                            roles = account.roles
+                                .filter { it.generation == generation && !it.isSection }
+                                .map { it.name }
+                        )
+                    }
+            )
+        }
+    return sections
+}

src/main/kotlin/pt/up/fe/ni/website/backend/dto/generations/UpdateGenerationDto.kt

@@ -0,0 +1,8 @@
+package pt.up.fe.ni.website.backend.dto.generations
+
+import pt.up.fe.ni.website.backend.annotations.validation.SchoolYear
+
+data class UpdateGenerationDto(
+    @SchoolYear
+    val schoolYear: String
+)