You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
742 lines
28 KiB
742 lines
28 KiB
//
|
|
// TeamRegistration.swift
|
|
// Padel Tournament
|
|
//
|
|
// Created by razmig on 10/03/2024.
|
|
//
|
|
|
|
import Foundation
|
|
import LeStorage
|
|
import SwiftUI
|
|
|
|
@Observable
|
|
final class TeamRegistration: ModelObject, Storable {
|
|
static func resourceName() -> String { "team-registrations" }
|
|
static func tokenExemptedMethods() -> [HTTPMethod] { return [] }
|
|
static func filterByStoreIdentifier() -> Bool { return true }
|
|
static var relationshipNames: [String] = []
|
|
|
|
var id: String = Store.randomId()
|
|
var tournament: String
|
|
var groupStage: String?
|
|
var registrationDate: Date?
|
|
var callDate: Date?
|
|
var bracketPosition: Int?
|
|
var groupStagePosition: Int?
|
|
var comment: String?
|
|
var source: String?
|
|
var sourceValue: String?
|
|
var logo: String?
|
|
var name: String?
|
|
|
|
var walkOut: Bool = false
|
|
var wildCardBracket: Bool = false
|
|
var wildCardGroupStage: Bool = false
|
|
var weight: Int = 0
|
|
var lockedWeight: Int?
|
|
var confirmationDate: Date?
|
|
var qualified: Bool = false
|
|
var finalRanking: Int?
|
|
var pointsEarned: Int?
|
|
|
|
func hasRegisteredOnline() -> Bool {
|
|
players().anySatisfy({ $0.registeredOnline })
|
|
}
|
|
|
|
func unrankedOrUnknown() -> Bool {
|
|
players().anySatisfy({ $0.source == nil })
|
|
}
|
|
|
|
|
|
func isOutOfTournament() -> Bool {
|
|
walkOut
|
|
}
|
|
|
|
init(tournament: String, groupStage: String? = nil, registrationDate: Date? = nil, callDate: Date? = nil, bracketPosition: Int? = nil, groupStagePosition: Int? = nil, comment: String? = nil, source: String? = nil, sourceValue: String? = nil, logo: String? = nil, name: String? = nil, walkOut: Bool = false, wildCardBracket: Bool = false, wildCardGroupStage: Bool = false, weight: Int = 0, lockedWeight: Int? = nil, confirmationDate: Date? = nil, qualified: Bool = false, finalRanking: Int? = nil, pointsEarned: Int? = nil) {
|
|
self.tournament = tournament
|
|
self.groupStage = groupStage
|
|
self.registrationDate = registrationDate ?? Date()
|
|
self.callDate = callDate
|
|
self.bracketPosition = bracketPosition
|
|
self.groupStagePosition = groupStagePosition
|
|
self.comment = comment
|
|
self.source = source
|
|
self.sourceValue = sourceValue
|
|
self.logo = logo
|
|
self.name = name
|
|
self.walkOut = walkOut
|
|
self.wildCardBracket = wildCardBracket
|
|
self.wildCardGroupStage = wildCardGroupStage
|
|
self.weight = weight
|
|
self.lockedWeight = lockedWeight
|
|
self.confirmationDate = confirmationDate
|
|
self.qualified = qualified
|
|
self.finalRanking = finalRanking
|
|
self.pointsEarned = pointsEarned
|
|
}
|
|
|
|
var tournamentStore: TournamentStore {
|
|
return TournamentStore.instance(tournamentId: self.tournament)
|
|
}
|
|
|
|
// MARK: - Computed dependencies
|
|
|
|
func unsortedPlayers() -> [PlayerRegistration] {
|
|
return self.tournamentStore.playerRegistrations.filter { $0.teamRegistration == self.id && $0.coach == false }
|
|
}
|
|
|
|
// MARK: -
|
|
|
|
func deleteTeamScores() {
|
|
let ts = self.tournamentStore.teamScores.filter({ $0.teamRegistration == id })
|
|
do {
|
|
try self.tournamentStore.teamScores.delete(contentOfs: ts)
|
|
} catch {
|
|
Logger.error(error)
|
|
}
|
|
}
|
|
|
|
override func deleteDependencies() throws {
|
|
let unsortedPlayers = unsortedPlayers()
|
|
for player in unsortedPlayers {
|
|
try player.deleteDependencies()
|
|
}
|
|
self.tournamentStore.playerRegistrations.deleteDependencies(unsortedPlayers)
|
|
|
|
let teamScores = teamScores()
|
|
for teamScore in teamScores {
|
|
try teamScore.deleteDependencies()
|
|
}
|
|
self.tournamentStore.teamScores.deleteDependencies(teamScores)
|
|
}
|
|
|
|
func hasArrived(isHere: Bool = false) {
|
|
let unsortedPlayers = unsortedPlayers()
|
|
unsortedPlayers.forEach({ $0.hasArrived = !isHere })
|
|
do {
|
|
try self.tournamentStore.playerRegistrations.addOrUpdate(contentOfs: unsortedPlayers)
|
|
} catch {
|
|
Logger.error(error)
|
|
}
|
|
}
|
|
|
|
func isHere() -> Bool {
|
|
let unsortedPlayers = unsortedPlayers()
|
|
if unsortedPlayers.isEmpty { return false }
|
|
return unsortedPlayers.allSatisfy({ $0.hasArrived })
|
|
}
|
|
|
|
|
|
func isSeedable() -> Bool {
|
|
bracketPosition == nil && groupStage == nil
|
|
}
|
|
|
|
func setSeedPosition(inSpot match: Match, slot: TeamPosition?, opposingSeeding: Bool) {
|
|
var teamPosition : TeamPosition {
|
|
if let slot {
|
|
return slot
|
|
} else {
|
|
let matchIndex = match.index
|
|
let seedRound = RoundRule.roundIndex(fromMatchIndex: matchIndex)
|
|
let numberOfMatches = RoundRule.numberOfMatches(forRoundIndex: seedRound)
|
|
let isUpper = RoundRule.matchIndexWithinRound(fromMatchIndex: matchIndex) < (numberOfMatches / 2)
|
|
var teamPosition = slot ?? (isUpper ? .one : .two)
|
|
if opposingSeeding {
|
|
teamPosition = slot ?? (isUpper ? .two : .one)
|
|
}
|
|
return teamPosition
|
|
}
|
|
}
|
|
|
|
let seedPosition: Int = match.lockAndGetSeedPosition(atTeamPosition: teamPosition)
|
|
tournamentObject()?.resetTeamScores(in: bracketPosition)
|
|
self.bracketPosition = seedPosition
|
|
if groupStagePosition != nil && qualified == false {
|
|
qualified = true
|
|
}
|
|
if let tournament = tournamentObject() {
|
|
if let index = index(in: tournament.selectedSortedTeams()) {
|
|
let drawLog = DrawLog(tournament: tournament.id, drawSeed: index, drawMatchIndex: match.index, drawTeamPosition: teamPosition, drawType: .seed)
|
|
do {
|
|
try tournamentStore.drawLogs.addOrUpdate(instance: drawLog)
|
|
} catch {
|
|
Logger.error(error)
|
|
}
|
|
}
|
|
tournament.updateTeamScores(in: bracketPosition)
|
|
}
|
|
}
|
|
|
|
func expectedSummonDate() -> Date? {
|
|
if let groupStageStartDate = groupStageObject()?.startDate {
|
|
return groupStageStartDate
|
|
} else if let roundMatchStartDate = initialMatch()?.startDate {
|
|
return roundMatchStartDate
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var initialWeight: Int {
|
|
return lockedWeight ?? weight
|
|
}
|
|
|
|
func called() -> Bool {
|
|
return callDate != nil
|
|
}
|
|
|
|
func confirmed() -> Bool {
|
|
return confirmationDate != nil
|
|
}
|
|
|
|
func getPhoneNumbers() -> [String] {
|
|
return players().compactMap { $0.phoneNumber }.filter({ $0.isEmpty == false })
|
|
}
|
|
|
|
func getMail() -> [String] {
|
|
let mails = players().compactMap({ $0.email })
|
|
return mails
|
|
}
|
|
|
|
func isImported() -> Bool {
|
|
let unsortedPlayers = unsortedPlayers()
|
|
if unsortedPlayers.isEmpty { return false }
|
|
|
|
return unsortedPlayers.allSatisfy({ $0.isImported() })
|
|
}
|
|
|
|
func isWildCard() -> Bool {
|
|
return wildCardBracket || wildCardGroupStage
|
|
}
|
|
|
|
func isPlaying() -> Bool {
|
|
return currentMatch() != nil
|
|
}
|
|
|
|
func currentMatch() -> Match? {
|
|
return teamScores().compactMap { $0.matchObject() }.first(where: { $0.isRunning() })
|
|
}
|
|
|
|
func teamScores() -> [TeamScore] {
|
|
return self.tournamentStore.teamScores.filter({ $0.teamRegistration == id })
|
|
}
|
|
|
|
func wins() -> [Match] {
|
|
return self.tournamentStore.matches.filter({ $0.winningTeamId == id })
|
|
}
|
|
|
|
func loses() -> [Match] {
|
|
return self.tournamentStore.matches.filter({ $0.losingTeamId == id })
|
|
}
|
|
|
|
func matches() -> [Match] {
|
|
return self.tournamentStore.matches.filter({ $0.losingTeamId == id || $0.winningTeamId == id })
|
|
}
|
|
|
|
var tournamentCategory: TournamentCategory {
|
|
tournamentObject()?.tournamentCategory ?? .men
|
|
}
|
|
|
|
@objc
|
|
var canonicalName: String {
|
|
players().map { $0.canonicalName }.joined(separator: " ")
|
|
}
|
|
|
|
func hasMemberOfClub(_ codeClubOrClubName: String?) -> Bool {
|
|
guard let codeClubOrClubName else { return true }
|
|
return unsortedPlayers().anySatisfy({
|
|
$0.clubName?.contains(codeClubOrClubName) == true || $0.clubName?.contains(codeClubOrClubName) == true
|
|
})
|
|
}
|
|
|
|
func updateWeight(inTournamentCategory tournamentCategory: TournamentCategory) {
|
|
self.setWeight(from: self.players(), inTournamentCategory: tournamentCategory)
|
|
}
|
|
|
|
func teamLabel(_ displayStyle: DisplayStyle = .wide, twoLines: Bool = false, separator: String = "&") -> String {
|
|
if let name { return name }
|
|
return players().map { $0.playerLabel(displayStyle) }.joined(separator: twoLines ? "\n" : " \(separator) ")
|
|
}
|
|
|
|
func teamLabelRanked(displayRank: Bool, displayTeamName: Bool) -> String {
|
|
[displayTeamName ? name : nil, displayRank ? seedIndex() : nil, displayTeamName ? (name == nil ? teamLabel() : name) : teamLabel()].compactMap({ $0 }).joined(separator: " ")
|
|
}
|
|
|
|
func seedIndex() -> String? {
|
|
guard let tournament = tournamentObject() else { return nil }
|
|
guard let index = index(in: tournament.selectedSortedTeams()) else { return nil }
|
|
return "(\(index + 1))"
|
|
}
|
|
|
|
func index(in teams: [TeamRegistration]) -> Int? {
|
|
return teams.firstIndex(where: { $0.id == id })
|
|
}
|
|
|
|
func formattedSeed(in teams: [TeamRegistration]? = nil) -> String {
|
|
let selectedSortedTeams = teams ?? tournamentObject()?.selectedSortedTeams() ?? []
|
|
if let index = index(in: selectedSortedTeams) {
|
|
return "#\(index + 1)"
|
|
} else {
|
|
return "###"
|
|
}
|
|
}
|
|
|
|
func contains(_ searchField: String) -> Bool {
|
|
return unsortedPlayers().anySatisfy({ $0.contains(searchField) }) || self.name?.localizedCaseInsensitiveContains(searchField) == true
|
|
}
|
|
|
|
func containsExactlyPlayerLicenses(_ playerLicenses: [String?]) -> Bool {
|
|
let arrayOfIds : [String] = unsortedPlayers().compactMap({ $0.licenceId?.strippedLicense?.canonicalVersion })
|
|
let ids : Set<String> = Set<String>(arrayOfIds.sorted())
|
|
let searchedIds = Set<String>(playerLicenses.compactMap({ $0?.strippedLicense?.canonicalVersion }).sorted())
|
|
if ids.isEmpty || searchedIds.isEmpty { return false }
|
|
return ids.hashValue == searchedIds.hashValue
|
|
}
|
|
|
|
func includes(players: [PlayerRegistration]) -> Bool {
|
|
let unsortedPlayers = unsortedPlayers()
|
|
guard players.count == unsortedPlayers.count else { return false }
|
|
return players.allSatisfy { player in
|
|
unsortedPlayers.anySatisfy { _player in
|
|
_player.isSameAs(player)
|
|
}
|
|
}
|
|
}
|
|
|
|
func includes(player: PlayerRegistration) -> Bool {
|
|
return unsortedPlayers().anySatisfy { _player in
|
|
_player.isSameAs(player)
|
|
}
|
|
}
|
|
|
|
func canPlay() -> Bool {
|
|
let unsortedPlayers = unsortedPlayers()
|
|
if unsortedPlayers.isEmpty { return false }
|
|
|
|
return matches().isEmpty == false || unsortedPlayers.allSatisfy({ $0.hasPaid() || $0.hasArrived })
|
|
}
|
|
|
|
func availableForSeedPick() -> Bool {
|
|
return groupStage == nil && bracketPosition == nil
|
|
}
|
|
|
|
func inGroupStage() -> Bool {
|
|
return groupStagePosition != nil
|
|
}
|
|
|
|
func inRound() -> Bool {
|
|
return bracketPosition != nil
|
|
}
|
|
|
|
func positionLabel() -> String? {
|
|
if groupStagePosition != nil { return "Poule" }
|
|
if let initialRound = initialRound() {
|
|
return initialRound.roundTitle()
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func initialRoundColor() -> Color? {
|
|
if walkOut { return Color.logoRed }
|
|
if groupStagePosition != nil { return Color.blue }
|
|
if let initialRound = initialRound(), let colorHex = RoundRule.colors[safe: initialRound.index] {
|
|
return Color(uiColor: .init(fromHex: colorHex))
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func resetGroupeStagePosition() {
|
|
if let groupStage {
|
|
let matches = self.tournamentStore.matches.filter({ $0.groupStage == groupStage }).map { $0.id }
|
|
let teamScores = self.tournamentStore.teamScores.filter({ $0.teamRegistration == id && matches.contains($0.match) })
|
|
do {
|
|
try tournamentStore.teamScores.delete(contentOfs: teamScores)
|
|
} catch {
|
|
Logger.error(error)
|
|
}
|
|
}
|
|
//groupStageObject()?._matches().forEach({ $0.updateTeamScores() })
|
|
groupStage = nil
|
|
groupStagePosition = nil
|
|
}
|
|
|
|
func resetBracketPosition() {
|
|
let matches = self.tournamentStore.matches.filter({ $0.groupStage == nil }).map { $0.id }
|
|
let teamScores = self.tournamentStore.teamScores.filter({ $0.teamRegistration == id && matches.contains($0.match) })
|
|
do {
|
|
try tournamentStore.teamScores.delete(contentOfs: teamScores)
|
|
} catch {
|
|
Logger.error(error)
|
|
}
|
|
|
|
self.bracketPosition = nil
|
|
}
|
|
|
|
func resetPositions() {
|
|
resetGroupeStagePosition()
|
|
resetBracketPosition()
|
|
}
|
|
|
|
func pasteData(_ exportFormat: ExportFormat = .rawText, _ index: Int = 0) -> String {
|
|
switch exportFormat {
|
|
case .rawText:
|
|
return [playersPasteData(exportFormat), formattedInscriptionDate(exportFormat), name].compactMap({ $0 }).joined(separator: exportFormat.newLineSeparator())
|
|
case .csv:
|
|
return [index.formatted(), playersPasteData(exportFormat), isWildCard() ? "WC" : weight.formatted()].joined(separator: exportFormat.separator())
|
|
}
|
|
}
|
|
|
|
var computedRegistrationDate: Date {
|
|
return registrationDate ?? .distantFuture
|
|
}
|
|
|
|
func formattedInscriptionDate(_ exportFormat: ExportFormat = .rawText) -> String? {
|
|
guard let registrationDate else { return nil }
|
|
|
|
let formattedDate = registrationDate.formatted(.dateTime.weekday().day().month().hour().minute())
|
|
let onlineSuffix = hasRegisteredOnline() ? " en ligne" : ""
|
|
|
|
switch exportFormat {
|
|
case .rawText:
|
|
return "Inscrit\(onlineSuffix) le \(formattedDate)"
|
|
case .csv:
|
|
return formattedDate
|
|
}
|
|
}
|
|
|
|
func formattedSummonDate(_ exportFormat: ExportFormat = .rawText) -> String? {
|
|
|
|
switch exportFormat {
|
|
case .rawText:
|
|
if let callDate {
|
|
return "Convoqué le " + callDate.formatted(.dateTime.weekday().day().month().hour().minute())
|
|
} else {
|
|
return nil
|
|
}
|
|
case .csv:
|
|
if let callDate {
|
|
return callDate.formatted(.dateTime.weekday().day().month().hour().minute())
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func playersPasteData(_ exportFormat: ExportFormat = .rawText) -> String {
|
|
switch exportFormat {
|
|
case .rawText:
|
|
return players().map { $0.pasteData(exportFormat) }.joined(separator: exportFormat.newLineSeparator())
|
|
case .csv:
|
|
return players().map { [$0.pasteData(exportFormat), isWildCard() ? "WC" : $0.computedRank.formatted() ].joined(separator: exportFormat.separator()) }.joined(separator: exportFormat.separator())
|
|
}
|
|
}
|
|
|
|
func updatePlayers(_ players: Set<PlayerRegistration>, inTournamentCategory tournamentCategory: TournamentCategory) {
|
|
let previousPlayers = Set(unsortedPlayers())
|
|
|
|
players.forEach { player in
|
|
previousPlayers.forEach { oldPlayer in
|
|
if player.licenceId?.strippedLicense == oldPlayer.licenceId?.strippedLicense, player.licenceId?.strippedLicense != nil {
|
|
player.registeredOnline = oldPlayer.registeredOnline
|
|
player.coach = oldPlayer.coach
|
|
player.tournamentPlayed = oldPlayer.tournamentPlayed
|
|
player.points = oldPlayer.points
|
|
player.captain = oldPlayer.captain
|
|
player.assimilation = oldPlayer.assimilation
|
|
player.ligueName = oldPlayer.ligueName
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
let playersToRemove = previousPlayers.subtracting(players)
|
|
do {
|
|
try self.tournamentStore.playerRegistrations.delete(contentOfs: playersToRemove)
|
|
} catch {
|
|
Logger.error(error)
|
|
}
|
|
setWeight(from: Array(players), inTournamentCategory: tournamentCategory)
|
|
|
|
players.forEach { player in
|
|
player.teamRegistration = id
|
|
}
|
|
|
|
// do {
|
|
// try self.tournamentStore.playerRegistrations.addOrUpdate(contentOfs: players)
|
|
// } catch {
|
|
// Logger.error(error)
|
|
// }
|
|
}
|
|
|
|
typealias TeamRange = (left: TeamRegistration?, right: TeamRegistration?)
|
|
|
|
func replacementRange() -> TeamRange? {
|
|
guard let tournamentObject = tournamentObject() else { return nil }
|
|
guard let index = tournamentObject.indexOf(team: self) else { return nil }
|
|
let selectedSortedTeams = tournamentObject.selectedSortedTeams()
|
|
let left = selectedSortedTeams[safe: index - 1]
|
|
let right = selectedSortedTeams[safe: index + 1]
|
|
return (left: left, right: right)
|
|
}
|
|
|
|
func replacementRangeExtended() -> TeamRange? {
|
|
guard let tournamentObject = tournamentObject() else { return nil }
|
|
guard let groupStagePosition else { return nil }
|
|
let selectedSortedTeams = tournamentObject.selectedSortedTeams()
|
|
var left: TeamRegistration? = nil
|
|
if groupStagePosition == 0 {
|
|
left = tournamentObject.seeds().last
|
|
} else {
|
|
let previousHat = selectedSortedTeams.filter({ $0.groupStagePosition == groupStagePosition - 1 }).sorted(by: \.weight)
|
|
left = previousHat.last
|
|
}
|
|
var right: TeamRegistration? = nil
|
|
if groupStagePosition == tournamentObject.teamsPerGroupStage - 1 {
|
|
right = nil
|
|
} else {
|
|
let previousHat = selectedSortedTeams.filter({ $0.groupStagePosition == groupStagePosition + 1 }).sorted(by: \.weight)
|
|
right = previousHat.first
|
|
}
|
|
return (left: left, right: right)
|
|
}
|
|
|
|
typealias AreInIncreasingOrder = (PlayerRegistration, PlayerRegistration) -> Bool
|
|
|
|
func players() -> [PlayerRegistration] {
|
|
|
|
self.unsortedPlayers().sorted { (lhs, rhs) in
|
|
let predicates: [AreInIncreasingOrder] = [
|
|
{ $0.sex?.rawValue ?? 0 < $1.sex?.rawValue ?? 0 },
|
|
{ $0.rank ?? Int.max < $1.rank ?? Int.max },
|
|
{ $0.lastName < $1.lastName},
|
|
{ $0.firstName < $1.firstName }
|
|
]
|
|
|
|
for predicate in predicates {
|
|
if !predicate(lhs, rhs) && !predicate(rhs, lhs) {
|
|
continue
|
|
}
|
|
|
|
return predicate(lhs, rhs)
|
|
}
|
|
|
|
return false
|
|
}
|
|
}
|
|
|
|
func coaches() -> [PlayerRegistration] {
|
|
tournamentStore.playerRegistrations.filter({ $0.coach })
|
|
}
|
|
|
|
func setWeight(from players: [PlayerRegistration], inTournamentCategory tournamentCategory: TournamentCategory) {
|
|
let significantPlayerCount = significantPlayerCount()
|
|
weight = (players.prefix(significantPlayerCount).map { $0.computedRank } + missingPlayerType(inTournamentCategory: tournamentCategory).map { unrankValue(for: $0 == 1 ? true : false ) }).prefix(significantPlayerCount).reduce(0,+)
|
|
}
|
|
|
|
func significantPlayerCount() -> Int {
|
|
return tournamentObject()?.significantPlayerCount() ?? 2
|
|
}
|
|
|
|
func missingPlayerType(inTournamentCategory tournamentCategory: TournamentCategory) -> [Int] {
|
|
let players = unsortedPlayers()
|
|
if players.count >= 2 { return [] }
|
|
let s = players.compactMap { $0.sex?.rawValue }
|
|
var missing = tournamentCategory.mandatoryPlayerType()
|
|
s.forEach { i in
|
|
if let index = missing.firstIndex(of: i) {
|
|
missing.remove(at: index)
|
|
}
|
|
}
|
|
return missing
|
|
}
|
|
|
|
func unrankValue(for malePlayer: Bool) -> Int {
|
|
return tournamentObject()?.unrankValue(for: malePlayer) ?? 90_000
|
|
}
|
|
|
|
func groupStageObject() -> GroupStage? {
|
|
guard let groupStage else { return nil }
|
|
return self.tournamentStore.groupStages.findById(groupStage)
|
|
}
|
|
|
|
func initialRound() -> Round? {
|
|
guard let bracketPosition else { return nil }
|
|
let roundIndex = RoundRule.roundIndex(fromMatchIndex: bracketPosition / 2)
|
|
return self.tournamentStore.rounds.first(where: { $0.index == roundIndex })
|
|
}
|
|
|
|
func initialMatch() -> Match? {
|
|
guard let bracketPosition else { return nil }
|
|
guard let initialRoundObject = initialRound() else { return nil }
|
|
return self.tournamentStore.matches.first(where: { $0.round == initialRoundObject.id && $0.index == bracketPosition / 2 })
|
|
}
|
|
|
|
func toggleSummonConfirmation() {
|
|
if confirmationDate == nil { confirmationDate = Date() }
|
|
else { confirmationDate = nil }
|
|
}
|
|
|
|
func didConfirmSummon() -> Bool {
|
|
confirmationDate != nil
|
|
}
|
|
|
|
func tournamentObject() -> Tournament? {
|
|
return Store.main.findById(tournament)
|
|
}
|
|
|
|
func groupStagePositionAtStep(_ step: Int) -> Int? {
|
|
guard let groupStagePosition else { return nil }
|
|
if step == 0 {
|
|
return groupStagePosition
|
|
} else if let groupStageObject = groupStageObject(), groupStageObject.hasEnded() {
|
|
return groupStageObject.index
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func wildcardLabel() -> String? {
|
|
if isWildCard() {
|
|
let wildcardLabel: String = ["wildcard", (wildCardBracket ? "tableau" : "poule")].joined(separator: " ")
|
|
return wildcardLabel
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
var _cachedRestingTime: (Bool, Date?)?
|
|
|
|
func restingTime() -> Date? {
|
|
if let _cachedRestingTime { return _cachedRestingTime.1 }
|
|
let restingTime = matches().filter({ $0.hasEnded() }).sorted(by: \.computedEndDateForSorting).last?.endDate
|
|
_cachedRestingTime = (true, restingTime)
|
|
return restingTime
|
|
}
|
|
|
|
func resetRestingTime() {
|
|
_cachedRestingTime = nil
|
|
}
|
|
|
|
var restingTimeForSorting: Date {
|
|
restingTime()!
|
|
}
|
|
|
|
func teamNameLabel() -> String {
|
|
if let name, name.isEmpty == false {
|
|
return name
|
|
} else {
|
|
return "Toute l'équipe"
|
|
}
|
|
}
|
|
|
|
func isDifferentPosition(_ drawMatchIndex: Int?) -> Bool {
|
|
if let bracketPosition, let drawMatchIndex {
|
|
return drawMatchIndex != bracketPosition
|
|
} else if let bracketPosition {
|
|
return true
|
|
} else if let drawMatchIndex {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
enum CodingKeys: String, CodingKey {
|
|
case _id = "id"
|
|
case _tournament = "tournament"
|
|
case _groupStage = "groupStage"
|
|
case _registrationDate = "registrationDate"
|
|
case _callDate = "callDate"
|
|
case _bracketPosition = "bracketPosition"
|
|
case _groupStagePosition = "groupStagePosition"
|
|
case _comment = "comment"
|
|
case _source = "source"
|
|
case _sourceValue = "sourceValue"
|
|
case _logo = "logo"
|
|
case _name = "name"
|
|
case _wildCardBracket = "wildCardBracket"
|
|
case _wildCardGroupStage = "wildCardGroupStage"
|
|
case _weight = "weight"
|
|
case _walkOut = "walkOut"
|
|
case _lockedWeight = "lockedWeight"
|
|
case _confirmationDate = "confirmationDate"
|
|
case _qualified = "qualified"
|
|
case _finalRanking = "finalRanking"
|
|
case _pointsEarned = "pointsEarned"
|
|
}
|
|
|
|
init(from decoder: Decoder) throws {
|
|
let container = try decoder.container(keyedBy: CodingKeys.self)
|
|
// Non-optional properties
|
|
id = try container.decodeIfPresent(String.self, forKey: ._id) ?? Store.randomId()
|
|
tournament = try container.decode(String.self, forKey: ._tournament)
|
|
walkOut = try container.decodeIfPresent(Bool.self, forKey: ._walkOut) ?? false
|
|
wildCardBracket = try container.decodeIfPresent(Bool.self, forKey: ._wildCardBracket) ?? false
|
|
wildCardGroupStage = try container.decodeIfPresent(Bool.self, forKey: ._wildCardGroupStage) ?? false
|
|
weight = try container.decodeIfPresent(Int.self, forKey: ._weight) ?? 0
|
|
qualified = try container.decodeIfPresent(Bool.self, forKey: ._qualified) ?? false
|
|
|
|
// Optional properties
|
|
groupStage = try container.decodeIfPresent(String.self, forKey: ._groupStage)
|
|
registrationDate = try container.decodeIfPresent(Date.self, forKey: ._registrationDate)
|
|
callDate = try container.decodeIfPresent(Date.self, forKey: ._callDate)
|
|
bracketPosition = try container.decodeIfPresent(Int.self, forKey: ._bracketPosition)
|
|
groupStagePosition = try container.decodeIfPresent(Int.self, forKey: ._groupStagePosition)
|
|
comment = try container.decodeIfPresent(String.self, forKey: ._comment)
|
|
source = try container.decodeIfPresent(String.self, forKey: ._source)
|
|
sourceValue = try container.decodeIfPresent(String.self, forKey: ._sourceValue)
|
|
logo = try container.decodeIfPresent(String.self, forKey: ._logo)
|
|
name = try container.decodeIfPresent(String.self, forKey: ._name)
|
|
lockedWeight = try container.decodeIfPresent(Int.self, forKey: ._lockedWeight)
|
|
confirmationDate = try container.decodeIfPresent(Date.self, forKey: ._confirmationDate)
|
|
finalRanking = try container.decodeIfPresent(Int.self, forKey: ._finalRanking)
|
|
pointsEarned = try container.decodeIfPresent(Int.self, forKey: ._pointsEarned)
|
|
}
|
|
|
|
func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
|
|
try container.encode(id, forKey: ._id)
|
|
try container.encode(tournament, forKey: ._tournament)
|
|
try container.encode(groupStage, forKey: ._groupStage)
|
|
try container.encode(registrationDate, forKey: ._registrationDate)
|
|
try container.encode(callDate, forKey: ._callDate)
|
|
try container.encode(bracketPosition, forKey: ._bracketPosition)
|
|
try container.encode(groupStagePosition, forKey: ._groupStagePosition)
|
|
try container.encode(comment, forKey: ._comment)
|
|
try container.encode(source, forKey: ._source)
|
|
try container.encode(sourceValue, forKey: ._sourceValue)
|
|
try container.encode(logo, forKey: ._logo)
|
|
try container.encode(name, forKey: ._name)
|
|
try container.encode(walkOut, forKey: ._walkOut)
|
|
try container.encode(wildCardBracket, forKey: ._wildCardBracket)
|
|
try container.encode(wildCardGroupStage, forKey: ._wildCardGroupStage)
|
|
try container.encode(weight, forKey: ._weight)
|
|
try container.encode(lockedWeight, forKey: ._lockedWeight)
|
|
try container.encode(confirmationDate, forKey: ._confirmationDate)
|
|
try container.encode(qualified, forKey: ._qualified)
|
|
try container.encode(finalRanking, forKey: ._finalRanking)
|
|
try container.encode(pointsEarned, forKey: ._pointsEarned)
|
|
}
|
|
|
|
func insertOnServer() {
|
|
self.tournamentStore.teamRegistrations.writeChangeAndInsertOnServer(instance: self)
|
|
for playerRegistration in self.unsortedPlayers() {
|
|
playerRegistration.insertOnServer()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
extension TeamRegistration: Hashable {
|
|
static func == (lhs: TeamRegistration, rhs: TeamRegistration) -> Bool {
|
|
lhs.id == rhs.id
|
|
}
|
|
|
|
func hash(into hasher: inout Hasher) {
|
|
hasher.combine(id)
|
|
}
|
|
}
|
|
|
|
enum TeamDataSource: Int, Codable {
|
|
case beachPadel
|
|
}
|
|
|