Cleans up README a little

Reviewed-on: #2

README.md

@@ -1,3 +1,25 @@
 # Scavenger Hunt API
 
-REST API to support a community scavenger hunt app.
+REST API to support a community scavenger hunt app.
+
+## Environment variables
+* `DB_PASSWORD` Password for the database 
+* `DB_URL` JDBC URL for the database
+* `DB_USER` Username for the database
+* `JWT_SECRET` Secret pass for the JWT
+
+## TODO:
+### User Endpoints
+* list teams for hunt GET `/hunt/{id}/team`
+* create new hunt team POST `/hunt/{id}/team`
+* join hunt team POST `/hunt/{id}/team/{id}`
+* list items for hunt GET `/hunt/{id}/item`
+* get hunt item info GET `/hunt/{id}/item/{id}`
+* get hunt team item info GET `/hunt/{id}/team/{id}/item/{id}`
+* get photos for hunt item GET `/hunt/{id}/team/{id}/item/{id}/photo`
+* upload photo for hunt item POST `/hunt/{id}/team/{id}/item/{id}/photo`
+* delete photo for hunt item DELETE `/hunt/{id}/team/{id}/item/{id}/photo`
+* list hunt teams with scores for hunt `GET /lead/hunt/{id}/team`
+* list hunters with scores for hunt GET `/lead/hunt/{id}/hunter`
+### Admin Endpoints
+* approve photo for hunt item POST `/admin/hunt/{id}/team/{id}`

build.gradle.kts

@@ -28,12 +28,22 @@ repositories {
 
 dependencies {
     val mysqlConnectorJ = "9.5.0"
+    val commonsValidator = "1.10.1"
+    val jakartaValidation = "3.1.1"
+    val jsonWebToken = "0.13.0"
     implementation("org.springframework.boot:spring-boot-starter-actuator")
     implementation("org.springframework.boot:spring-boot-starter-web")
     implementation("org.springframework.boot:spring-boot-starter-data-jpa")
+    implementation("org.springframework.boot:spring-boot-starter-validation")
+    implementation("org.springframework.boot:spring-boot-starter-security")
+    implementation("jakarta.validation:jakarta.validation-api:${jakartaValidation}")
     implementation("com.mysql:mysql-connector-j:${mysqlConnectorJ}")
     implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
     implementation("org.jetbrains.kotlin:kotlin-reflect")
+    implementation("commons-validator:commons-validator:${commonsValidator}")
+    implementation("io.jsonwebtoken:jjwt-api:${jsonWebToken}")
+    implementation("io.jsonwebtoken:jjwt-impl:${jsonWebToken}")
+    implementation("io.jsonwebtoken:jjwt-jackson:${jsonWebToken}")
     developmentOnly("org.springframework.boot:spring-boot-devtools")
     annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
     testImplementation("org.springframework.boot:spring-boot-starter-actuator-test")

src/main/kotlin/net/halfbinary/scavengerhuntapi/config/AuthEntrypointJwt.kt

@@ -0,0 +1,18 @@
+package net.halfbinary.scavengerhuntapi.config
+
+import jakarta.servlet.http.HttpServletRequest
+import jakarta.servlet.http.HttpServletResponse
+import org.springframework.security.core.AuthenticationException
+import org.springframework.security.web.AuthenticationEntryPoint
+import org.springframework.stereotype.Component
+
+@Component
+class AuthEntrypointJwt: AuthenticationEntryPoint {
+    override fun commence(
+        request: HttpServletRequest,
+        response: HttpServletResponse,
+        authException: AuthenticationException
+    ) {
+        response.sendError(HttpServletResponse.SC_UNAUTHORIZED, authException.message)
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/config/AuthTokenFilter.kt

@@ -0,0 +1,49 @@
+package net.halfbinary.scavengerhuntapi.config
+
+import jakarta.servlet.FilterChain
+import jakarta.servlet.http.HttpServletRequest
+import jakarta.servlet.http.HttpServletResponse
+import net.halfbinary.scavengerhuntapi.service.HunterDetailsService
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken
+import org.springframework.security.core.context.SecurityContextHolder
+import org.springframework.security.core.userdetails.UserDetails
+import org.springframework.security.web.authentication.WebAuthenticationDetailsSource
+import org.springframework.stereotype.Component
+import org.springframework.web.filter.OncePerRequestFilter
+
+
+@Component
+class AuthTokenFilter(private val jwtUtils: JwtUtil, private val hunterDetailsService: HunterDetailsService): OncePerRequestFilter() {
+    override fun doFilterInternal(
+        request: HttpServletRequest,
+        response: HttpServletResponse,
+        filterChain: FilterChain
+    ) {
+        try {
+            val jwt: String? = parseJwt(request)
+            if (jwt != null && jwtUtils.validateJwtToken(jwt)) {
+                val username = jwtUtils.getUsernameFromToken(jwt)
+                val userDetails: UserDetails = hunterDetailsService.loadUserByUsername(username)
+                val authentication =
+                    UsernamePasswordAuthenticationToken(
+                        userDetails,
+                        null,
+                        userDetails.authorities
+                    )
+                authentication.details = WebAuthenticationDetailsSource().buildDetails(request)
+                SecurityContextHolder.getContext().authentication = authentication
+            }
+        } catch (e: Exception) {
+            println("Cannot set user authentication: $e")
+        }
+        filterChain.doFilter(request, response)
+    }
+
+    private fun parseJwt(request: HttpServletRequest): String? {
+        val headerAuth = request.getHeader("Authorization")
+        if (headerAuth != null && headerAuth.startsWith("Bearer ")) {
+            return headerAuth.substring(7)
+        }
+        return null
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/config/JwtUtil.kt

@@ -0,0 +1,62 @@
+package net.halfbinary.scavengerhuntapi.config
+
+import io.jsonwebtoken.JwtException
+import io.jsonwebtoken.Jwts
+import jakarta.annotation.PostConstruct
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.stereotype.Component
+import java.util.Date
+import javax.crypto.SecretKey
+
+@Component
+class JwtUtil {
+    @Value($$"${jwt.secret}")
+    private val jwtSecret: String? = null
+
+    @Value($$"${jwt.expiration}")
+    private val jwtExpirationMs = 0
+
+    private var key: SecretKey? = null
+
+    // Initializes the key after the class is instantiated and the jwtSecret is injected,
+    // preventing the repeated creation of the key and enhancing performance
+    @PostConstruct
+    fun init() {
+        this.key = Jwts.SIG.HS256.key().build()
+    }
+
+    // Generate JWT token
+    fun generateToken(email: String): String {
+        return Jwts.builder()
+            .subject(email)
+            .issuedAt(Date())
+            .expiration(Date(System.currentTimeMillis() + jwtExpirationMs))
+            .signWith(key)
+            .compact()
+    }
+
+    // Get username from JWT token
+    fun getUsernameFromToken(token: String): String {
+        return Jwts.parser()
+            .verifyWith(key)
+            .build()
+            .parseSignedClaims(token)
+            .payload
+            .subject
+    }
+
+    // Validate JWT token
+    fun validateJwtToken(token: String?): Boolean {
+        try {
+            Jwts.parser().verifyWith(key).build().parseSignedClaims(token)
+            return true
+        } catch (e: SecurityException) {
+            println("Invalid JWT signature: " + e.message)
+        } catch (e: JwtException) {
+            println("Invalid JWT token: " + e.message)
+        } catch (e: IllegalArgumentException) {
+            println("JWT claims string is empty: " + e.message)
+        }
+        return false
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/config/SecurityConfig.kt

@@ -0,0 +1,74 @@
+package net.halfbinary.scavengerhuntapi.config
+
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.security.authentication.AuthenticationManager
+import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity
+import org.springframework.security.config.annotation.web.builders.HttpSecurity
+import org.springframework.security.config.annotation.web.configurers.CorsConfigurer
+import org.springframework.security.config.annotation.web.configurers.CsrfConfigurer
+import org.springframework.security.config.annotation.web.configurers.ExceptionHandlingConfigurer
+import org.springframework.security.config.annotation.web.configurers.SessionManagementConfigurer
+import org.springframework.security.config.http.SessionCreationPolicy
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder
+import org.springframework.security.crypto.password.PasswordEncoder
+import org.springframework.security.web.SecurityFilterChain
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter
+
+
+@Configuration
+@EnableMethodSecurity
+class SecurityConfig(private val authEntrypointJwt: AuthEntrypointJwt,
+    private val authTokenFilter: AuthTokenFilter) {
+
+    @Bean
+    fun authenticationJwtTokenFilter(): AuthTokenFilter {
+        return authTokenFilter
+    }
+
+    @Bean
+    @Throws(Exception::class)
+    fun authenticationManager(
+        authenticationConfiguration: AuthenticationConfiguration
+    ): AuthenticationManager? {
+        return authenticationConfiguration.getAuthenticationManager()
+    }
+
+    @Bean
+    fun passwordEncoder(): PasswordEncoder {
+        return BCryptPasswordEncoder()
+    }
+
+    @Bean
+    @Throws(Exception::class)
+    fun securityFilterChain(http: HttpSecurity): SecurityFilterChain? {
+        // Updated configuration for Spring Security 6.x
+        http
+            .csrf { csrf: CsrfConfigurer<HttpSecurity> -> csrf.disable() } // Disable CSRF
+            .cors { cors: CorsConfigurer<HttpSecurity> -> cors.disable() } // Disable CORS (or configure if needed)
+            .exceptionHandling { exceptionHandling: ExceptionHandlingConfigurer<HttpSecurity> ->
+                exceptionHandling.authenticationEntryPoint(
+                    authEntrypointJwt
+                )
+            }
+            .sessionManagement { sessionManagement: SessionManagementConfigurer<HttpSecurity> ->
+                sessionManagement.sessionCreationPolicy(
+                    SessionCreationPolicy.STATELESS
+                )
+            }
+            .authorizeHttpRequests { authorizeRequests ->
+                authorizeRequests
+                    .requestMatchers("/auth/**", "/signup")
+                    .permitAll()
+                    .anyRequest().authenticated()
+            }
+
+        // Add the JWT Token filter before the UsernamePasswordAuthenticationFilter
+        http.addFilterBefore(
+            authenticationJwtTokenFilter(),
+            UsernamePasswordAuthenticationFilter::class.java
+        )
+        return http.build()
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/controller/AuthController.kt

@@ -0,0 +1,53 @@
+package net.halfbinary.scavengerhuntapi.controller
+
+import jakarta.servlet.http.HttpServletResponse
+import jakarta.validation.Valid
+import net.halfbinary.scavengerhuntapi.config.JwtUtil
+import net.halfbinary.scavengerhuntapi.model.converter.toDomain
+import net.halfbinary.scavengerhuntapi.model.request.LoginRequest
+import net.halfbinary.scavengerhuntapi.model.request.LogoutRequest
+import net.halfbinary.scavengerhuntapi.model.request.RefreshRequest
+import net.halfbinary.scavengerhuntapi.model.response.LoginResponse
+import net.halfbinary.scavengerhuntapi.service.LoginService
+import net.halfbinary.scavengerhuntapi.service.RefreshTokenService
+import org.springframework.http.ResponseEntity
+import org.springframework.security.core.authority.SimpleGrantedAuthority
+import org.springframework.security.core.userdetails.User
+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 java.util.Collections
+
+
+@RestController
+@RequestMapping("/auth")
+class AuthController(private val loginService: LoginService, private val jwtUtils: JwtUtil, private val refreshTokenService: RefreshTokenService) {
+    @PostMapping("/login")
+    fun login(@Valid @RequestBody body: LoginRequest, response: HttpServletResponse): ResponseEntity<LoginResponse> {
+        val result = loginService.login(body.toDomain())
+        // TODO: Figure out how to use the authorities
+        val hunterAuthorities =
+            if (result.isAdmin) {
+                SimpleGrantedAuthority("ROLE_ADMIN")
+            } else {
+                SimpleGrantedAuthority("ROLE_USER")
+            }
+        val user = User(result.email, result.password, Collections.singleton(hunterAuthorities))
+        val accessToken = jwtUtils.generateToken(result.email)
+        val refreshToken  = refreshTokenService.generateRefreshToken(result.email)
+        val loginResponse = LoginResponse(accessToken, refreshToken)
+        return ResponseEntity.ok(loginResponse)
+    }
+
+    @PostMapping("/refresh")
+    fun refresh(@RequestBody body: RefreshRequest): String {
+        return refreshTokenService.getAccessToken(body.refreshToken)
+    }
+
+    @PostMapping("/logout")
+    fun logout(@RequestBody body: LogoutRequest, response: HttpServletResponse): ResponseEntity<String> {
+        refreshTokenService.removeToken(body.refreshToken)
+        return ResponseEntity.ok().build()
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/controller/HuntController.kt

@@ -0,0 +1,41 @@
+package net.halfbinary.scavengerhuntapi.controller
+
+import jakarta.validation.Valid
+import net.halfbinary.scavengerhuntapi.model.HuntId
+import net.halfbinary.scavengerhuntapi.model.HunterId
+import net.halfbinary.scavengerhuntapi.model.converter.toDomain
+import net.halfbinary.scavengerhuntapi.model.converter.toResponse
+import net.halfbinary.scavengerhuntapi.model.request.HuntCreateRequest
+import net.halfbinary.scavengerhuntapi.model.request.HuntStatus
+import net.halfbinary.scavengerhuntapi.model.response.HuntResponse
+import net.halfbinary.scavengerhuntapi.service.HuntService
+import org.springframework.http.ResponseEntity
+import org.springframework.security.access.prepost.PreAuthorize
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping("hunt")
+class HuntController(private val huntService: HuntService) {
+
+    @GetMapping("/{id}")
+    fun getHunt(@PathVariable("id") huntId: HuntId): ResponseEntity<HuntResponse> {
+        return ResponseEntity.ok(huntService.getHunt(huntId).toResponse())
+    }
+
+    @PreAuthorize("hasRole('ADMIN')")
+    @GetMapping()
+    fun getAllHunts(@RequestParam status: HuntStatus?): ResponseEntity<List<HuntResponse>> {
+        return ResponseEntity.ok(huntService.getAllHunts(status).map { it.toResponse() })
+    }
+
+    @PostMapping()
+    fun createHunt(@Valid @RequestBody huntRequest: HuntCreateRequest): ResponseEntity<HuntResponse> {
+        return ResponseEntity.ok(huntService.createHunt(huntRequest.toDomain()).toResponse())
+    }
+
+    @GetMapping("/hunter/{hunterId}")
+    fun getHuntsByHunter(@PathVariable("hunterId") hunterId: HunterId): ResponseEntity<List<HuntResponse>> {
+        return ResponseEntity.ok(huntService.getHuntsByHunter(hunterId).map { it.toResponse() })
+    }
+
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/controller/SignupController.kt

@@ -0,0 +1,19 @@
+package net.halfbinary.scavengerhuntapi.controller
+
+import jakarta.validation.Valid
+import net.halfbinary.scavengerhuntapi.model.converter.toDomain
+import net.halfbinary.scavengerhuntapi.model.request.HunterSignupRequest
+import net.halfbinary.scavengerhuntapi.service.SignupService
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+class SignupController(private val signupService: SignupService) {
+    @PostMapping("/signup")
+    fun hunterSignup(@Valid @RequestBody body: HunterSignupRequest): ResponseEntity<Any> {
+        signupService.createNewHunter(body.toDomain())
+        return ResponseEntity.ok().build()
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/controller/TeamController.kt

@@ -0,0 +1,27 @@
+package net.halfbinary.scavengerhuntapi.controller
+
+import jakarta.validation.Valid
+import net.halfbinary.scavengerhuntapi.model.HuntId
+import net.halfbinary.scavengerhuntapi.model.request.TeamRequest
+import net.halfbinary.scavengerhuntapi.model.response.TeamResponse
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.GetMapping
+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
+
+@RestController
+@RequestMapping("hunt/{id}/team")
+class TeamController {
+    @GetMapping
+    fun listHuntTeams(@PathVariable id: HuntId): ResponseEntity<List<TeamResponse>> {
+        TODO()
+    }
+
+    @PostMapping
+    fun createHuntTeam(@PathVariable id: HuntId, @Valid @RequestBody team: TeamRequest) {
+        TODO()
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/error/ExceptionHandler.kt

@@ -0,0 +1,74 @@
+package net.halfbinary.scavengerhuntapi.error
+
+import net.halfbinary.scavengerhuntapi.error.exception.InvalidEmailException
+import net.halfbinary.scavengerhuntapi.error.exception.LoginFailedException
+import net.halfbinary.scavengerhuntapi.error.exception.NotFoundException
+import net.halfbinary.scavengerhuntapi.error.exception.PreexistingAccountException
+import org.slf4j.LoggerFactory
+import org.springframework.http.HttpStatus
+import org.springframework.http.converter.HttpMessageNotReadableException
+import org.springframework.validation.FieldError
+import org.springframework.web.bind.MethodArgumentNotValidException
+import org.springframework.web.bind.annotation.ExceptionHandler
+import org.springframework.web.bind.annotation.ResponseStatus
+import org.springframework.web.bind.annotation.RestControllerAdvice
+
+
+@RestControllerAdvice
+class ExceptionHandler {
+    companion object {
+        private val log = LoggerFactory.getLogger(net.halfbinary.scavengerhuntapi.error.ExceptionHandler::class.java)
+    }
+    @ExceptionHandler(PreexistingAccountException::class)
+    @ResponseStatus(HttpStatus.CONFLICT)
+    fun preexistingAccountException(e: PreexistingAccountException): String? {
+        return e.message
+    }
+
+    @ExceptionHandler(LoginFailedException::class)
+    @ResponseStatus(HttpStatus.UNAUTHORIZED)
+    fun loginFailedException(e: LoginFailedException): String? {
+        return e.message
+    }
+
+    @ExceptionHandler(InvalidEmailException::class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    fun invalidEmailException(e: InvalidEmailException): String? {
+        return e.message
+    }
+
+    @ExceptionHandler(NotFoundException::class)
+    @ResponseStatus(HttpStatus.NOT_FOUND)
+    fun notFoundException(e: NotFoundException): String? {
+        return e.message
+    }
+
+    @ExceptionHandler(HttpMessageNotReadableException::class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    fun httpMessageNotReadableException(e: HttpMessageNotReadableException): Map<String, String?> {
+        if (e.message?.contains("body is missing")?:false) {
+            return simpleMap("body","Body is missing")
+        }
+        if (e.message?.contains("parameter")?:false) {
+            val missingParameter = e.message?.split("parameter ")[1]
+            return simpleMap(missingParameter?:"","Missing required parameter $missingParameter")
+        }
+        log.debug("JSON parsing issue", e)
+        return simpleMap("body", "Parsing error")
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException::class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    fun handleValidationExceptions(e: MethodArgumentNotValidException): Map<String, String?> {
+        return e.bindingResult.allErrors.associate { error ->
+            Pair(
+                (error as FieldError).field,
+                error.defaultMessage
+            )
+        }
+    }
+
+    private fun simpleMap(key: String, value: String?): Map<String, String?> {
+        return mapOf(Pair(key, value))
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/error/exception/ExpiredRefreshTokenException.kt

@@ -0,0 +1,5 @@
+package net.halfbinary.scavengerhuntapi.error.exception
+
+import net.halfbinary.scavengerhuntapi.model.RefreshId
+
+class ExpiredRefreshTokenException(token: RefreshId): RuntimeException("The refresh token $token is expired.")

src/main/kotlin/net/halfbinary/scavengerhuntapi/error/exception/InvalidEmailException.kt

@@ -0,0 +1,3 @@
+package net.halfbinary.scavengerhuntapi.error.exception
+
+class InvalidEmailException(email: String): RuntimeException("The email ${email} is not valid.")

src/main/kotlin/net/halfbinary/scavengerhuntapi/error/exception/InvalidRefreshTokenException.kt

@@ -0,0 +1,5 @@
+package net.halfbinary.scavengerhuntapi.error.exception
+
+import net.halfbinary.scavengerhuntapi.model.RefreshId
+
+class InvalidRefreshTokenException(token: RefreshId): RuntimeException("The refresh token $token is not valid.")

src/main/kotlin/net/halfbinary/scavengerhuntapi/error/exception/LoginFailedException.kt

@@ -0,0 +1,3 @@
+package net.halfbinary.scavengerhuntapi.error.exception
+
+class LoginFailedException(): RuntimeException("The email and password combination is not correct.")

src/main/kotlin/net/halfbinary/scavengerhuntapi/error/exception/NotFoundException.kt

@@ -0,0 +1,3 @@
+package net.halfbinary.scavengerhuntapi.error.exception
+
+class NotFoundException(override val message: String): RuntimeException(message)

src/main/kotlin/net/halfbinary/scavengerhuntapi/error/exception/PreexistingAccountException.kt

@@ -0,0 +1,3 @@
+package net.halfbinary.scavengerhuntapi.error.exception
+
+class PreexistingAccountException: RuntimeException("An account with that email already exists.")

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/TypeAlias.kt

@@ -6,4 +6,5 @@ typealias FoundId = UUID
 typealias HuntId = UUID
 typealias HunterId = UUID
 typealias ItemId = UUID
-typealias TeamId = UUID
+typealias TeamId = UUID
+typealias RefreshId = UUID

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/converter/HuntConverter.kt

@@ -0,0 +1,22 @@
+package net.halfbinary.scavengerhuntapi.model.converter
+
+import net.halfbinary.scavengerhuntapi.model.domain.Hunt
+import net.halfbinary.scavengerhuntapi.model.record.HuntRecord
+import net.halfbinary.scavengerhuntapi.model.request.HuntCreateRequest
+import net.halfbinary.scavengerhuntapi.model.response.HuntResponse
+
+fun HuntRecord.toDomain(): Hunt {
+    return Hunt(id, title, startDateTime, endDateTime, isTerminated)
+}
+
+fun Hunt.toResponse(): HuntResponse {
+    return HuntResponse(id, title, startDateTime, endDateTime, isTerminated)
+}
+
+fun HuntCreateRequest.toDomain(): Hunt {
+    return Hunt(title = title, startDateTime = startDateTime, endDateTime = endDateTime, isTerminated = false)
+}
+
+fun Hunt.toRecord(): HuntRecord {
+    return HuntRecord(id, title, startDateTime, endDateTime, isTerminated)
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/converter/HunterConverter.kt

@@ -0,0 +1,22 @@
+package net.halfbinary.scavengerhuntapi.model.converter
+
+import net.halfbinary.scavengerhuntapi.model.domain.Hunter
+import net.halfbinary.scavengerhuntapi.model.record.HunterRecord
+import net.halfbinary.scavengerhuntapi.model.request.HunterSignupRequest
+
+fun HunterSignupRequest.toDomain(): Hunter {
+    return Hunter(
+        email = email,
+        name = name,
+        password = password,
+        isAdmin = false
+    )
+}
+
+fun Hunter.toRecord(): HunterRecord {
+    return HunterRecord(id, email, name, password, isAdmin)
+}
+
+fun HunterRecord.toDomain(): Hunter {
+    return Hunter(id, email, name, password, isAdmin)
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/converter/LoginConverter.kt

@@ -0,0 +1,8 @@
+package net.halfbinary.scavengerhuntapi.model.converter
+
+import net.halfbinary.scavengerhuntapi.model.domain.Login
+import net.halfbinary.scavengerhuntapi.model.request.LoginRequest
+
+fun LoginRequest.toDomain(): Login {
+    return Login(email, password)
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/converter/TeamConverter.kt

@@ -0,0 +1,22 @@
+package net.halfbinary.scavengerhuntapi.model.converter
+
+import net.halfbinary.scavengerhuntapi.model.domain.Team
+import net.halfbinary.scavengerhuntapi.model.record.TeamRecord
+import net.halfbinary.scavengerhuntapi.model.request.TeamRequest
+import net.halfbinary.scavengerhuntapi.model.response.TeamResponse
+
+fun TeamRequest.toDomain(): Team {
+    return Team(name = name)
+}
+
+fun Team.toRecord(): TeamRecord {
+    return TeamRecord(id, name)
+}
+
+fun TeamRecord.toDomain(): Team {
+    return Team(id, name)
+}
+
+fun Team.toResponse(): TeamResponse {
+    return TeamResponse(id, name)
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/domain/Hunt.kt

@@ -0,0 +1,13 @@
+package net.halfbinary.scavengerhuntapi.model.domain
+
+import net.halfbinary.scavengerhuntapi.model.HuntId
+import java.time.LocalDateTime
+import java.util.*
+
+data class Hunt(
+    val id: HuntId = UUID.randomUUID(),
+    val title: String,
+    val startDateTime: LocalDateTime,
+    val endDateTime: LocalDateTime,
+    val isTerminated: Boolean
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/domain/Hunter.kt

@@ -0,0 +1,12 @@
+package net.halfbinary.scavengerhuntapi.model.domain
+
+import net.halfbinary.scavengerhuntapi.model.HunterId
+import java.util.*
+
+data class Hunter(
+    val id: HunterId = UUID.randomUUID(),
+    val email: String,
+    val name: String,
+    val password: String,
+    val isAdmin: Boolean
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/domain/Login.kt

@@ -0,0 +1,6 @@
+package net.halfbinary.scavengerhuntapi.model.domain
+
+data class Login(
+    val email: String,
+    val password: String
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/domain/Team.kt

@@ -0,0 +1,9 @@
+package net.halfbinary.scavengerhuntapi.model.domain
+
+import net.halfbinary.scavengerhuntapi.model.TeamId
+import java.util.UUID
+
+data class Team(
+    val id: TeamId = UUID.randomUUID(),
+    val name: String
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/record/RefreshTokenRecord.kt

@@ -0,0 +1,16 @@
+package net.halfbinary.scavengerhuntapi.model.record
+
+import jakarta.persistence.Entity
+import jakarta.persistence.Id
+import jakarta.persistence.Table
+import net.halfbinary.scavengerhuntapi.model.RefreshId
+import java.time.LocalDateTime
+
+@Entity
+@Table(name = "refresh_token")
+data class RefreshTokenRecord(
+    @Id
+    val token: RefreshId,
+    val email: String,
+    val expiryDateTime: LocalDateTime
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/request/HuntCreateRequest.kt

@@ -0,0 +1,14 @@
+package net.halfbinary.scavengerhuntapi.model.request
+
+import jakarta.validation.constraints.Future
+import jakarta.validation.constraints.NotBlank
+import java.time.LocalDateTime
+
+data class HuntCreateRequest(
+    @field:NotBlank(message = "Hunt title is required")
+    val title: String,
+    @field:Future
+    val startDateTime: LocalDateTime,
+    @field:Future
+    val endDateTime: LocalDateTime,
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/request/HuntStatus.kt

@@ -0,0 +1,7 @@
+package net.halfbinary.scavengerhuntapi.model.request
+
+enum class HuntStatus {
+    UNSTARTED,
+    ONGOING,
+    CLOSED
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/request/HunterSignupRequest.kt

@@ -0,0 +1,14 @@
+package net.halfbinary.scavengerhuntapi.model.request
+
+import jakarta.validation.constraints.Email
+import jakarta.validation.constraints.NotBlank
+
+data class HunterSignupRequest(
+    @field:Email(message = "Must be a valid email address")
+    @field:NotBlank(message = "Email must not be blank")
+    val email: String,
+    @field:NotBlank(message = "Name cannot be blank")
+    val name: String,
+    @field:NotBlank(message = "Password cannot be blank")
+    val password: String
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/request/LoginRequest.kt

@@ -0,0 +1,10 @@
+package net.halfbinary.scavengerhuntapi.model.request
+
+import jakarta.validation.constraints.NotBlank
+
+data class LoginRequest(
+    @field:NotBlank(message = "Email cannot be blank")
+    val email: String,
+    @field:NotBlank(message = "Password cannot be blank")
+    val password: String
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/request/LogoutRequest.kt

@@ -0,0 +1,9 @@
+package net.halfbinary.scavengerhuntapi.model.request
+
+import jakarta.validation.constraints.NotBlank
+import net.halfbinary.scavengerhuntapi.model.RefreshId
+
+data class LogoutRequest(
+    @field:NotBlank(message = "You must provide a refresh token.")
+    val refreshToken: RefreshId
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/request/RefreshRequest.kt

@@ -0,0 +1,9 @@
+package net.halfbinary.scavengerhuntapi.model.request
+
+import jakarta.validation.constraints.NotBlank
+import net.halfbinary.scavengerhuntapi.model.RefreshId
+
+data class RefreshRequest(
+    @field:NotBlank(message = "Refresh token cannot be blank")
+    val refreshToken: RefreshId,
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/request/TeamRequest.kt

@@ -0,0 +1,5 @@
+package net.halfbinary.scavengerhuntapi.model.request
+
+data class TeamRequest(
+    val name: String
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/response/HuntResponse.kt

@@ -0,0 +1,12 @@
+package net.halfbinary.scavengerhuntapi.model.response
+
+import net.halfbinary.scavengerhuntapi.model.HuntId
+import java.time.LocalDateTime
+
+data class HuntResponse(
+    val id: HuntId,
+    val title: String,
+    val startDateTime: LocalDateTime,
+    val endDateTime: LocalDateTime,
+    val isTerminated: Boolean
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/response/LoginResponse.kt

@@ -0,0 +1,8 @@
+package net.halfbinary.scavengerhuntapi.model.response
+
+import net.halfbinary.scavengerhuntapi.model.RefreshId
+
+data class LoginResponse(
+    val accessToken: String,
+    val refreshToken: RefreshId
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/model/response/TeamResponse.kt

@@ -0,0 +1,8 @@
+package net.halfbinary.scavengerhuntapi.model.response
+
+import net.halfbinary.scavengerhuntapi.model.TeamId
+
+data class TeamResponse(
+    val id: TeamId,
+    val name: String
+)

src/main/kotlin/net/halfbinary/scavengerhuntapi/repository/HuntRepository.kt

@@ -1,9 +1,49 @@
 package net.halfbinary.scavengerhuntapi.repository
 
 import net.halfbinary.scavengerhuntapi.model.HuntId
+import net.halfbinary.scavengerhuntapi.model.HunterId
 import net.halfbinary.scavengerhuntapi.model.record.HuntRecord
 import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Query
 import org.springframework.stereotype.Repository
 
 @Repository
-interface HuntRepository : JpaRepository<HuntRecord, HuntId>
+interface HuntRepository : JpaRepository<HuntRecord, HuntId> {
+    @Query("""
+        SELECT h.*
+            FROM hunter u
+                 INNER JOIN hunter_team ht ON u.id = ht.hunter_id
+                 INNER JOIN team t ON ht.team_id = t.id
+                 INNER JOIN team_hunt th ON t.id = th.team_id
+                 INNER JOIN hunt h ON th.hunt_id = h.id
+            WHERE u.id = :hunterId
+              AND h.is_terminated = FALSE
+              AND h.start_date_time < NOW()
+              AND h.end_date_time > NOW()
+    """, nativeQuery = true)
+    fun findAllOngoingByHunter(hunterId: HunterId): List<HuntRecord>
+
+    @Query("""
+                SELECT h.*
+            FROM hunt h
+            WHERE h.is_terminated = FALSE
+              AND h.start_date_time < NOW()
+              AND h.end_date_time > NOW()
+    """, nativeQuery = true)
+    fun findAllOngoing(): List<HuntRecord>
+
+    @Query("""
+                SELECT h.*
+            FROM hunt h
+            WHERE h.is_terminated = FALSE
+              AND h.start_date_time > NOW()
+    """, nativeQuery = true)
+    fun findAllUnstarted(): List<HuntRecord>
+
+    @Query("""
+                SELECT h.*
+            FROM hunt h
+            WHERE h.is_terminated = TRUE
+    """, nativeQuery = true)
+    fun findAllClosed(): List<HuntRecord>
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/repository/HunterRepository.kt

@@ -3,7 +3,18 @@ package net.halfbinary.scavengerhuntapi.repository
 import net.halfbinary.scavengerhuntapi.model.HunterId
 import net.halfbinary.scavengerhuntapi.model.record.HunterRecord
 import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Query
 import org.springframework.stereotype.Repository
 
 @Repository
-interface HunterRepository : JpaRepository<HunterRecord, HunterId>
+interface HunterRepository : JpaRepository<HunterRecord, HunterId> {
+    fun findByEmail(email: String): HunterRecord?
+
+    @Query("""
+        SELECT h.*
+        FROM hunter h
+        WHERE h.email = :email
+            AND h.password = :password
+    """, nativeQuery = true)
+    fun login(email: String, password: String): HunterRecord?
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/repository/RefreshTokenRepository.kt

@@ -0,0 +1,7 @@
+package net.halfbinary.scavengerhuntapi.repository
+
+import net.halfbinary.scavengerhuntapi.model.RefreshId
+import net.halfbinary.scavengerhuntapi.model.record.RefreshTokenRecord
+import org.springframework.data.jpa.repository.JpaRepository
+
+interface RefreshTokenRepository: JpaRepository<RefreshTokenRecord, RefreshId>

src/main/kotlin/net/halfbinary/scavengerhuntapi/service/HuntService.kt

@@ -0,0 +1,36 @@
+package net.halfbinary.scavengerhuntapi.service
+
+import net.halfbinary.scavengerhuntapi.error.exception.NotFoundException
+import net.halfbinary.scavengerhuntapi.model.HuntId
+import net.halfbinary.scavengerhuntapi.model.HunterId
+import net.halfbinary.scavengerhuntapi.model.converter.toDomain
+import net.halfbinary.scavengerhuntapi.model.converter.toRecord
+import net.halfbinary.scavengerhuntapi.model.domain.Hunt
+import net.halfbinary.scavengerhuntapi.model.request.HuntStatus
+import net.halfbinary.scavengerhuntapi.repository.HuntRepository
+import org.springframework.data.repository.findByIdOrNull
+import org.springframework.stereotype.Service
+
+@Service
+class HuntService(private val huntRepository: HuntRepository) {
+    fun getHunt(huntId: HuntId): Hunt {
+        return huntRepository.findByIdOrNull(huntId)?.toDomain() ?: throw NotFoundException("No hunt with id ${huntId} found")
+    }
+
+    fun getAllHunts(status: HuntStatus?): List<Hunt> {
+        return when(status) {
+            HuntStatus.UNSTARTED -> huntRepository.findAllUnstarted().map { it.toDomain() }
+            HuntStatus.ONGOING -> huntRepository.findAllOngoing().map { it.toDomain() }
+            HuntStatus.CLOSED -> huntRepository.findAllClosed().map { it.toDomain() }
+            else -> huntRepository.findAll().map { it.toDomain() }
+        }
+    }
+
+    fun getHuntsByHunter(hunterId: HunterId): List<Hunt> {
+        return huntRepository.findAllOngoingByHunter(hunterId).map { it.toDomain() }
+    }
+
+    fun createHunt(hunt: Hunt): Hunt {
+        return huntRepository.save(hunt.toRecord()).toDomain()
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/service/HunterDetailsService.kt

@@ -0,0 +1,32 @@
+package net.halfbinary.scavengerhuntapi.service
+
+import net.halfbinary.scavengerhuntapi.repository.HunterRepository
+import org.springframework.security.core.authority.SimpleGrantedAuthority
+import org.springframework.security.core.userdetails.User
+import org.springframework.security.core.userdetails.UserDetails
+import org.springframework.security.core.userdetails.UserDetailsService
+import org.springframework.security.core.userdetails.UsernameNotFoundException
+import org.springframework.stereotype.Service
+import java.util.Collections
+
+
+@Service
+class HunterDetailsService(private val hunterRepository: HunterRepository): UserDetailsService {
+    override fun loadUserByUsername(username: String): UserDetails {
+        hunterRepository.findByEmail(username)
+            ?.let { hunter ->
+                val hunterAuthorities =
+                    if (hunter.isAdmin) {
+                        SimpleGrantedAuthority("ROLE_ADMIN")
+                    } else {
+                        SimpleGrantedAuthority("ROLE_USER")
+                    }
+                return User(
+                    hunter.email,
+                    hunter.password,
+                    Collections.singleton(hunterAuthorities)
+                )
+            }
+        throw UsernameNotFoundException("User Not Found with username: $username")
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/service/LoginService.kt

@@ -0,0 +1,20 @@
+package net.halfbinary.scavengerhuntapi.service
+
+import net.halfbinary.scavengerhuntapi.error.exception.LoginFailedException
+import net.halfbinary.scavengerhuntapi.model.converter.toDomain
+import net.halfbinary.scavengerhuntapi.model.domain.Hunter
+import net.halfbinary.scavengerhuntapi.model.domain.Login
+import net.halfbinary.scavengerhuntapi.repository.HunterRepository
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+
+@Service
+class LoginService(private val hunterRepository: HunterRepository) {
+    companion object {
+        private val log = LoggerFactory.getLogger(LoginService::class.java)
+    }
+    fun login(login: Login): Hunter {
+        log.info("Logging in with email: ${login.email}")
+        return hunterRepository.login(login.email, login.password)?.toDomain()?:throw LoginFailedException()
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/service/RefreshTokenService.kt

@@ -0,0 +1,49 @@
+package net.halfbinary.scavengerhuntapi.service
+
+import net.halfbinary.scavengerhuntapi.config.JwtUtil
+import net.halfbinary.scavengerhuntapi.error.exception.ExpiredRefreshTokenException
+import net.halfbinary.scavengerhuntapi.error.exception.InvalidRefreshTokenException
+import net.halfbinary.scavengerhuntapi.model.RefreshId
+import net.halfbinary.scavengerhuntapi.model.record.RefreshTokenRecord
+import net.halfbinary.scavengerhuntapi.repository.RefreshTokenRepository
+import org.slf4j.LoggerFactory
+import org.springframework.data.repository.findByIdOrNull
+import org.springframework.stereotype.Service
+import java.time.LocalDateTime
+import java.time.temporal.ChronoUnit
+
+@Service
+class RefreshTokenService(private val refreshTokenRepository: RefreshTokenRepository, private val jwtUtil: JwtUtil) {
+
+    companion object {
+        private val log = LoggerFactory.getLogger(RefreshTokenService::class.java)
+    }
+
+    fun getAccessToken(tokenId: RefreshId): String {
+        return getToken(tokenId)?.let { refreshToken ->
+            if (isTokenExpired(refreshToken)) {
+                removeToken(tokenId)
+                throw ExpiredRefreshTokenException(tokenId)
+            } else {
+                jwtUtil.generateToken(refreshToken.email)
+            }
+        }?: throw InvalidRefreshTokenException(tokenId)
+    }
+
+    fun generateRefreshToken(email: String): RefreshId {
+        return refreshTokenRepository.save(RefreshTokenRecord(RefreshId.randomUUID(), email, LocalDateTime.now().plus(1, ChronoUnit.MONTHS))).token
+    }
+
+    fun isTokenExpired(token: RefreshTokenRecord): Boolean {
+        return token.expiryDateTime.isBefore(LocalDateTime.now())
+    }
+
+    fun getToken(token: RefreshId): RefreshTokenRecord? {
+        return refreshTokenRepository.findByIdOrNull(token)
+    }
+
+    fun removeToken(token: RefreshId) {
+        log.debug("Removing refresh token: $token")
+        refreshTokenRepository.deleteById(token)
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/service/SignupService.kt

@@ -0,0 +1,31 @@
+package net.halfbinary.scavengerhuntapi.service
+
+import net.halfbinary.scavengerhuntapi.error.exception.InvalidEmailException
+import net.halfbinary.scavengerhuntapi.error.exception.PreexistingAccountException
+import net.halfbinary.scavengerhuntapi.model.converter.toRecord
+import net.halfbinary.scavengerhuntapi.model.domain.Hunter
+import net.halfbinary.scavengerhuntapi.repository.HunterRepository
+import org.apache.commons.validator.routines.EmailValidator
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+
+@Service
+class SignupService(private val hunterRepository: HunterRepository) {
+
+    companion object {
+        private val log = LoggerFactory.getLogger(SignupService::class.java)
+    }
+    fun createNewHunter(hunter: Hunter) {
+        log.info("Creating new Hunter with email: ${hunter.email}...")
+        if (!EmailValidator.getInstance().isValid(hunter.email)) {
+            log.error("Invalid email ${hunter.email}")
+            throw InvalidEmailException(hunter.email)
+        }
+        if (hunterRepository.findByEmail(hunter.email) != null) {
+            log.error("Hunter ${hunter.email} already exists")
+            throw PreexistingAccountException()
+        }
+        hunterRepository.save(hunter.toRecord())
+        log.info("...Created new Hunter with email: ${hunter.email}")
+    }
+}

src/main/kotlin/net/halfbinary/scavengerhuntapi/service/TeamService.kt

@@ -0,0 +1,21 @@
+package net.halfbinary.scavengerhuntapi.service
+
+import net.halfbinary.scavengerhuntapi.model.HuntId
+import net.halfbinary.scavengerhuntapi.model.TeamId
+import net.halfbinary.scavengerhuntapi.model.domain.Team
+import org.springframework.stereotype.Service
+
+@Service
+class TeamService {
+    fun getListOfTeamsForHunt(huntId: HuntId): List<Team> {
+        TODO()
+    }
+
+    fun createTeam(name: String): Team {
+        TODO()
+    }
+
+    fun addTeamToHunt(huntId: HuntId, teamId: TeamId) {
+        TODO()
+    }
+}

src/main/resources/application.properties

@@ -7,4 +7,7 @@ spring.jpa.properties.hibernate.type.preferred_uuid_jdbc_type=CHAR
 spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
 spring.datasource.url=${DB_URL}
 spring.datasource.username=${DB_USER}
-spring.datasource.password=${DB_PASSWORD}
+spring.datasource.password=${DB_PASSWORD}
+
+jwt.secret=${JWT_SECRET}
+jwt.expiration=30000

src/main/resources/logback.xml

@@ -0,0 +1,11 @@
+<configuration>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <encoder>
+      <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+  <logger name="net.halfbinary.scavengerhuntapi" level="debug" />
+  <root level="info">
+    <appender-ref ref="STDOUT" />
+  </root>
+</configuration>