Feature/tournament component - knockout stage

backend/src/main/kotlin/hu/bme/sch/cmsch/component/tournament/MatchGroupDto.kt

@@ -0,0 +1,21 @@
+package hu.bme.sch.cmsch.component.tournament
+
+import hu.bme.sch.cmsch.admin.GenerateOverview
+import hu.bme.sch.cmsch.admin.OverviewType
+import hu.bme.sch.cmsch.model.IdentifiableEntity
+
+data class MatchGroupDto(
+
+    @property:GenerateOverview(renderer = OverviewType.ID, columnName = "ID", order = -1)
+    override var id: Int = 0,
+
+    @property:GenerateOverview(columnName = "Név", order = 1)
+    var name: String = "",
+
+    @property:GenerateOverview(columnName = "Helyszín", order = 2)
+    var location: String = "",
+
+    @property:GenerateOverview(columnName = "Közeli meccsek száma", order = 3)
+    var matchCount: Int = 0,
+
+): IdentifiableEntity

backend/src/main/kotlin/hu/bme/sch/cmsch/component/tournament/ParticipantDto.kt

@@ -0,0 +1,12 @@
+package hu.bme.sch.cmsch.component.tournament
+
+data class ParticipantDto(
+    var teamId: Int = 0,
+    var teamName: String = "",
+)
+
+data class SeededParticipantDto(
+    var teamId: Int = 0,
+    var teamName: String = "",
+    var seed: Int = 0,
+)

backend/src/main/kotlin/hu/bme/sch/cmsch/component/tournament/StageGroupDto.kt

@@ -0,0 +1,24 @@
+package hu.bme.sch.cmsch.component.tournament
+
+import hu.bme.sch.cmsch.admin.GenerateOverview
+import hu.bme.sch.cmsch.admin.OverviewType
+import hu.bme.sch.cmsch.model.IdentifiableEntity
+
+data class StageGroupDto(
+
+    @property:GenerateOverview(renderer = OverviewType.ID, columnName = "ID", order = -1)
+    override var id: Int = 0,
+
+    @property:GenerateOverview(columnName = "Név", order = 1)
+    var name: String = "",
+
+    @property:GenerateOverview(columnName = "Helyszín", order = 2)
+    var location: String = "",
+
+    @property:GenerateOverview(columnName = "Résztvevők száma", order = 3)
+    var participantCount: Int = 0,
+
+    @property:GenerateOverview(columnName = "Szakaszok száma", order = 4)
+    var stageCount: Int = 0
+
+): IdentifiableEntity

backend/src/main/kotlin/hu/bme/sch/cmsch/component/tournament/StageResultDto.kt

@@ -0,0 +1,48 @@
+package hu.bme.sch.cmsch.component.tournament
+
+import com.fasterxml.jackson.annotation.JsonInclude
+
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+data class StageResultDto(
+    val teamId: Int,
+    val teamName: String,
+    val stageId: Int = 0,
+    var highlighted: Boolean = false,
+    var initialSeed: Int = 0,
+    var highestSeed: Int = 0,
+    var detailedStats: GroupStageResults? = null,
+): Comparable<StageResultDto> {
+    override fun compareTo(other: StageResultDto): Int {
+        if (this.stageId != other.stageId) {
+            return this.stageId.compareTo(other.stageId)
+        }
+        if (this.detailedStats == null && other.detailedStats == null) {
+            return -this.initialSeed.compareTo(other.highestSeed)
+        }
+        if (this.detailedStats == null) {
+            return -1 // null detailed stats are considered better (knockout stages are later)
+        }
+        return compareValuesBy(this, other,
+            { it.detailedStats?:GroupStageResults()}, {it.initialSeed}, {it.highlighted})
+    }
+}
+data class GroupStageResults(
+    var group: String = "",
+    var position: UShort = UShort.MAX_VALUE,
+    var points: UInt = 0u,
+    var won: UShort = 0u,
+    var drawn: UShort = 0u,
+    var lost: UShort = 0u,
+    var goalsFor: UInt = 0u,
+    var goalsAgainst: UInt = 0u,
+    var goalDifference: Int = 0
+): Comparable<GroupStageResults> {
+    override fun compareTo(other: GroupStageResults): Int {
+        return compareValuesBy(this, other,
+            { -it.position.toInt() },
+            { it.points },
+            { it.won },
+            { it.goalDifference },
+            { it.goalsFor })
+    }
+}

backend/src/main/kotlin/hu/bme/sch/cmsch/component/tournament/TournamentApiController.kt

@@ -0,0 +1,81 @@
+package hu.bme.sch.cmsch.component.tournament
+
+import com.fasterxml.jackson.annotation.JsonView
+import hu.bme.sch.cmsch.config.OwnershipType
+import hu.bme.sch.cmsch.dto.Preview
+import hu.bme.sch.cmsch.model.RoleType
+import hu.bme.sch.cmsch.util.getUserOrNull
+import hu.bme.sch.cmsch.util.isAvailableForRole
+import io.swagger.v3.oas.annotations.Operation
+import io.swagger.v3.oas.annotations.responses.ApiResponse
+import io.swagger.v3.oas.annotations.responses.ApiResponses
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean
+import org.springframework.http.HttpStatus
+import org.springframework.http.ResponseEntity
+import org.springframework.security.core.Authentication
+import org.springframework.web.bind.annotation.*
+
+@RestController
+@RequestMapping("/api")
+@ConditionalOnBean(TournamentComponent::class)
+class TournamentApiController(
+    private val tournamentComponent: TournamentComponent,
+    private val tournamentService: TournamentService,
+) {
+    @JsonView(Preview::class)
+    @GetMapping("/tournament")
+    @Operation(
+        summary = "List all tournaments.",
+    )
+    @ApiResponses(value = [
+        ApiResponse(responseCode = "200", description = "List of tournaments")
+    ])
+    fun listTournaments(auth: Authentication?): ResponseEntity<List<TournamentPreviewView>> {
+        val user = auth?.getUserOrNull()
+        if (!tournamentComponent.minRole.isAvailableForRole(user?.role ?: RoleType.GUEST))
+            return ResponseEntity.status(HttpStatus.FORBIDDEN).body(listOf())
+        if (!tournamentComponent.showTournamentsAtAll) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build()
+        }
+
+        return ResponseEntity.ok(tournamentService.listAllTournaments())
+    }
+
+
+    @GetMapping("/tournament/{tournamentId}")
+    @Operation(
+        summary = "Get details of a tournament.",
+    )
+    @ApiResponses(value = [
+        ApiResponse(responseCode = "200", description = "Details of the tournament"),
+        ApiResponse(responseCode = "404", description = "Tournament not found")
+    ])
+    fun tournamentDetails(
+        @PathVariable tournamentId: Int,
+        auth: Authentication?
+    ): ResponseEntity<OptionalTournamentView>{
+        val user = auth?.getUserOrNull()
+        if (!tournamentComponent.minRole.isAvailableForRole(user?.role ?: RoleType.GUEST))
+            return ResponseEntity.status(HttpStatus.FORBIDDEN).build()
+
+        return tournamentService.showTournament(tournamentId, user)?.let { ResponseEntity.ok(it) }
+            ?: ResponseEntity.status(HttpStatus.NOT_FOUND).build()
+    }
+
+    @PostMapping("/tournament/register")
+    fun registerTeam(
+        @RequestBody tournamentJoinDto: TournamentJoinDto,
+        auth: Authentication?
+    ): TournamentJoinStatus {
+        val user = auth?.getUserOrNull()
+            ?: return TournamentJoinStatus.INSUFFICIENT_PERMISSIONS
+
+        val tournament = tournamentService.findById(tournamentJoinDto.id)
+            ?: return TournamentJoinStatus.TOURNAMENT_NOT_FOUND
+        return when (tournament.participantType) {
+            OwnershipType.GROUP -> tournamentService.teamRegister(tournament, user)
+            OwnershipType.USER -> tournamentService.userRegister(tournament, user)
+        }
+    }
+
+}

backend/src/main/kotlin/hu/bme/sch/cmsch/component/tournament/TournamentComponent.kt

@@ -0,0 +1,56 @@
+package hu.bme.sch.cmsch.component.tournament
+
+import hu.bme.sch.cmsch.component.ComponentBase
+import hu.bme.sch.cmsch.model.RoleType
+import hu.bme.sch.cmsch.service.ControlPermissions
+import hu.bme.sch.cmsch.setting.*
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
+import org.springframework.core.env.Environment
+import org.springframework.stereotype.Service
+
+
+@Service
+@ConditionalOnProperty(
+    prefix = "hu.bme.sch.cmsch.component.load",
+    name = ["tournament"],
+    havingValue = "true",
+    matchIfMissing = false
+)
+class TournamentComponent (
+    componentSettingService: ComponentSettingService,
+    env: Environment
+) : ComponentBase(
+    componentSettingService,
+    "tournament",
+    "/tournament",
+    "Tournament",
+    ControlPermissions.PERMISSION_CONTROL_TOURNAMENT,
+    listOf(),
+    env
+) {
+
+    val tournamentGroup by SettingGroup(fieldName = "Versenyek")
+    final var title by StringSettingRef(
+        "Sportversenyek",
+        fieldName = "Lap címe", description = "Ez jelenik meg a böngésző címsorában"
+    )
+    final override var menuDisplayName by StringSettingRef(
+        "Sportversenyek", serverSideOnly = true,
+        fieldName = "Menü neve", description = "Ez lesz a neve a menünek"
+    )
+    final override var minRole by MinRoleSettingRef(
+        setOf(), fieldName = "Jogosultságok",
+        description = "Melyik roleokkal nyitható meg az oldal"
+    )
+
+    var showTournamentsAtAll by BooleanSettingRef(
+        false, fieldName = "Leküldött",
+        description = "Ha igaz, akkor leküldésre kerülnek a versenyek"
+    )
+
+    var closeMatchesTimeWindow by NumberSettingRef(
+        defaultValue = 120, fieldName = "Közelgő mérkőzések időablaka",
+        description = "Mennyi időn belül közelgő mérkőzések jelenjenek meg a match admin oldalon",
+        minRoleToEdit = RoleType.ADMIN
+    )
+}

backend/src/main/kotlin/hu/bme/sch/cmsch/component/tournament/TournamentComponentController.kt

@@ -0,0 +1,36 @@
+package hu.bme.sch.cmsch.component.tournament
+
+import hu.bme.sch.cmsch.component.ComponentApiBase
+import hu.bme.sch.cmsch.component.app.MenuService
+import hu.bme.sch.cmsch.service.AdminMenuService
+import hu.bme.sch.cmsch.service.AuditLogService
+import hu.bme.sch.cmsch.service.ControlPermissions
+import hu.bme.sch.cmsch.service.StorageService
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean
+import org.springframework.stereotype.Controller
+import org.springframework.web.bind.annotation.RequestMapping
+
+@Controller
+@RequestMapping("/admin/control/component/tournament")
+@ConditionalOnBean(TournamentComponent::class)
+class TournamentComponentController(
+    adminMenuService: AdminMenuService,
+    component: TournamentComponent,
+    private val menuService: MenuService,
+    private val tournamentService: TournamentService,
+    private val auditLogService: AuditLogService,
+    private val storageService: StorageService,
+    service: MenuService
+) : ComponentApiBase(
+    adminMenuService,
+    TournamentComponent::class.java,
+    component,
+    ControlPermissions.PERMISSION_CONTROL_TOURNAMENT,
+    "Tournament",
+    "Tournament beállítások",
+    auditLogService = auditLogService,
+    menuService = menuService,
+    storageService = storageService
+) {
+
+}

backend/src/main/kotlin/hu/bme/sch/cmsch/component/tournament/TournamentComponentEntityConfiguration.kt

@@ -0,0 +1,11 @@
+package hu.bme.sch.cmsch.component.tournament
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean
+import org.springframework.boot.autoconfigure.domain.EntityScan
+import org.springframework.context.annotation.Configuration
+
+
+@Configuration
+@ConditionalOnBean(TournamentComponent::class)
+@EntityScan(basePackageClasses = [TournamentComponent::class])
+class TournamentComponentEntityConfiguration

backend/src/main/kotlin/hu/bme/sch/cmsch/component/tournament/TournamentController.kt

@@ -0,0 +1,66 @@
+package hu.bme.sch.cmsch.component.tournament
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import hu.bme.sch.cmsch.controller.admin.OneDeepEntityPage
+import hu.bme.sch.cmsch.controller.admin.calculateSearchSettings
+import hu.bme.sch.cmsch.service.AdminMenuService
+import hu.bme.sch.cmsch.service.AuditLogService
+import hu.bme.sch.cmsch.service.ImportService
+import hu.bme.sch.cmsch.service.StaffPermissions
+import hu.bme.sch.cmsch.service.StorageService
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean
+import org.springframework.core.env.Environment
+import org.springframework.stereotype.Controller
+import org.springframework.transaction.PlatformTransactionManager
+import org.springframework.web.bind.annotation.RequestMapping
+
+@Controller
+@RequestMapping("/admin/control/tournament")
+@ConditionalOnBean(TournamentComponent::class)
+class TournamentController(
+    private val tournamentService: TournamentService,
+    repo: TournamentRepository,
+    importService: ImportService,
+    adminMenuService: AdminMenuService,
+    component: TournamentComponent,
+    auditLog: AuditLogService,
+    objectMapper: ObjectMapper,
+    transactionManager: PlatformTransactionManager,
+    storageService: StorageService,
+    env: Environment
+) : OneDeepEntityPage<TournamentEntity>(
+    "tournament",
+    TournamentEntity::class, ::TournamentEntity,
+    "Verseny", "Versenyek",
+    "A rendezvény versenyeinek kezelése.",
+
+    transactionManager,
+    repo,
+    importService,
+    adminMenuService,
+    storageService,
+    component,
+    auditLog,
+    objectMapper,
+    env,
+
+    showPermission =   StaffPermissions.PERMISSION_SHOW_TOURNAMENTS,
+    createPermission = StaffPermissions.PERMISSION_CREATE_TOURNAMENTS,
+    editPermission =   StaffPermissions.PERMISSION_EDIT_TOURNAMENTS,
+    deletePermission = StaffPermissions.PERMISSION_DELETE_TOURNAMENTS,
+
+    createEnabled = true,
+    editEnabled = true,
+    deleteEnabled = true,
+    importEnabled = true,
+    exportEnabled = true,
+
+    adminMenuIcon = "sports_esports",
+    adminMenuPriority = 1,
+    searchSettings = calculateSearchSettings<TournamentEntity>(true)
+){
+    override fun onEntityDeleted(entity: TournamentEntity) {
+        tournamentService.deleteStagesForTournament(entity)
+        super.onEntityDeleted(entity)
+    }
+}