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.
704 lines
25 KiB
704 lines
25 KiB
//
|
|
// PlayerRegistration.swift
|
|
// Padel Tournament
|
|
//
|
|
// Created by razmig on 10/03/2024.
|
|
//
|
|
|
|
import Foundation
|
|
import LeStorage
|
|
|
|
@Observable
|
|
final class PlayerRegistration: ModelObject, Storable {
|
|
static func resourceName() -> String { "player-registrations" }
|
|
static func tokenExemptedMethods() -> [HTTPMethod] { return [] }
|
|
static func filterByStoreIdentifier() -> Bool { return true }
|
|
static var relationshipNames: [String] = ["teamRegistration"]
|
|
|
|
var id: String = Store.randomId()
|
|
var teamRegistration: String?
|
|
var firstName: String
|
|
var lastName: String
|
|
var licenceId: String?
|
|
var rank: Int?
|
|
var paymentType: PlayerPaymentType?
|
|
var sex: PlayerSexType?
|
|
|
|
var tournamentPlayed: Int?
|
|
var points: Double?
|
|
var clubName: String?
|
|
var ligueName: String?
|
|
var assimilation: String?
|
|
|
|
var phoneNumber: String?
|
|
var email: String?
|
|
var birthdate: String?
|
|
|
|
var computedRank: Int = 0
|
|
var source: PlayerDataSource?
|
|
|
|
var hasArrived: Bool = false
|
|
var coach: Bool = false
|
|
var captain: Bool = false
|
|
|
|
var clubCode: String?
|
|
var sourceName: String?
|
|
var isNveq: Bool = false
|
|
|
|
func localizedSourceLabel() -> String {
|
|
switch source {
|
|
case .frenchFederation, .frenchFederationVerified:
|
|
return "Via la base fédérale"
|
|
case .beachPadel:
|
|
return "Via le fichier beach-padel"
|
|
case .onlineRegistration:
|
|
return "Via un inscription en ligne"
|
|
case nil:
|
|
return "Manuellement"
|
|
}
|
|
}
|
|
|
|
|
|
init(teamRegistration: String? = nil, firstName: String, lastName: String, licenceId: String? = nil, rank: Int? = nil, paymentType: PlayerPaymentType? = nil, sex: PlayerSexType? = nil, tournamentPlayed: Int? = nil, points: Double? = nil, clubName: String? = nil, ligueName: String? = nil, assimilation: String? = nil, phoneNumber: String? = nil, email: String? = nil, birthdate: String? = nil, computedRank: Int = 0, source: PlayerDataSource? = nil, hasArrived: Bool = false, coach: Bool = false, captain: Bool = false) {
|
|
self.teamRegistration = teamRegistration
|
|
self.firstName = firstName
|
|
self.lastName = lastName
|
|
self.licenceId = licenceId
|
|
self.rank = rank
|
|
self.paymentType = paymentType
|
|
self.sex = sex
|
|
self.tournamentPlayed = tournamentPlayed
|
|
self.points = points
|
|
self.clubName = clubName
|
|
self.ligueName = ligueName
|
|
self.assimilation = assimilation
|
|
self.phoneNumber = phoneNumber
|
|
self.email = email
|
|
self.birthdate = birthdate
|
|
self.computedRank = computedRank
|
|
self.source = source
|
|
self.hasArrived = hasArrived
|
|
self.captain = captain
|
|
self.coach = coach
|
|
}
|
|
|
|
internal init(importedPlayer: ImportedPlayer) {
|
|
self.teamRegistration = ""
|
|
self.firstName = (importedPlayer.firstName ?? "").prefixTrimmed(50).capitalized
|
|
self.lastName = (importedPlayer.lastName ?? "").prefixTrimmed(50).uppercased()
|
|
self.licenceId = importedPlayer.license?.prefixTrimmed(50) ?? nil
|
|
self.rank = Int(importedPlayer.rank)
|
|
self.sex = importedPlayer.male ? .male : .female
|
|
self.tournamentPlayed = importedPlayer.tournamentPlayed
|
|
self.points = importedPlayer.getPoints()
|
|
self.clubName = importedPlayer.clubName?.prefixTrimmed(200)
|
|
self.ligueName = importedPlayer.ligueName?.prefixTrimmed(200)
|
|
self.assimilation = importedPlayer.assimilation?.prefixTrimmed(50)
|
|
self.source = .frenchFederation
|
|
self.birthdate = importedPlayer.birthYear?.prefixTrimmed(50)
|
|
}
|
|
|
|
internal init?(federalData: [String], sex: Int, sexUnknown: Bool) {
|
|
let _lastName = federalData[0].trimmed.uppercased()
|
|
let _firstName = federalData[1].trimmed.capitalized
|
|
if _lastName.isEmpty && _firstName.isEmpty { return nil }
|
|
lastName = _lastName.prefixTrimmed(50)
|
|
firstName = _firstName.prefixTrimmed(50)
|
|
birthdate = federalData[2].formattedAsBirthdate().prefixTrimmed(50)
|
|
licenceId = federalData[3].prefixTrimmed(50)
|
|
clubName = federalData[4].prefixTrimmed(200)
|
|
let stringRank = federalData[5]
|
|
if stringRank.isEmpty {
|
|
rank = nil
|
|
} else {
|
|
rank = Int(stringRank)
|
|
}
|
|
let _email = federalData[6]
|
|
if _email.isEmpty == false {
|
|
self.email = _email.prefixTrimmed(50)
|
|
}
|
|
let _phoneNumber = federalData[7]
|
|
if _phoneNumber.isEmpty == false {
|
|
self.phoneNumber = _phoneNumber.prefixTrimmed(50)
|
|
}
|
|
|
|
source = .beachPadel
|
|
if sexUnknown {
|
|
if sex == 1 && FileImportManager.shared.foundInWomenData(license: federalData[3]) {
|
|
self.sex = .female
|
|
} else if FileImportManager.shared.foundInMenData(license: federalData[3]) {
|
|
self.sex = .male
|
|
} else {
|
|
self.sex = nil
|
|
}
|
|
} else {
|
|
self.sex = PlayerSexType(rawValue: sex)
|
|
}
|
|
}
|
|
|
|
var tournamentStore: TournamentStore {
|
|
if let store = self.store as? TournamentStore {
|
|
return store
|
|
}
|
|
fatalError("missing store for \(String(describing: type(of: self)))")
|
|
}
|
|
|
|
var computedAge: Int? {
|
|
if let birthdate {
|
|
let components = birthdate.components(separatedBy: "/")
|
|
if let age = components.last, let ageInt = Int(age) {
|
|
let year = Calendar.current.getSportAge()
|
|
|
|
if age.count == 2 { //si l'année est sur 2 chiffres dans le fichier
|
|
if ageInt < 23 {
|
|
return year - 2000 - ageInt
|
|
} else {
|
|
return year - 2000 + 100 - ageInt
|
|
}
|
|
} else { //si l'année est représenté sur 4 chiffres
|
|
return year - ageInt
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func fetchUnrankPlayerData() async throws -> Player? {
|
|
guard let licence = licenceId?.replaceCharactersFromSet(characterSet: .whitespacesAndNewlines).trimmed.strippedLicense else {
|
|
return nil
|
|
}
|
|
return try await fetchPlayerData(for: licence)?.first
|
|
}
|
|
|
|
func pasteData(_ exportFormat: ExportFormat = .rawText) -> String {
|
|
switch exportFormat {
|
|
case .rawText:
|
|
return [firstName.capitalized, lastName.capitalized, licenceId].compactMap({ $0 }).joined(separator: exportFormat.separator())
|
|
case .csv:
|
|
return [lastName.uppercased() + " " + firstName.capitalized].joined(separator: exportFormat.separator())
|
|
case .championship:
|
|
let values = [
|
|
lastName.uppercased(),
|
|
firstName.capitalized,
|
|
isVerified(),
|
|
"=\"" + formattedLicense() + "\"",
|
|
"\(computedRank)",
|
|
isNveq ? "NVEQ" : "EQ",
|
|
]
|
|
.joined(separator: exportFormat.separator())
|
|
return values
|
|
}
|
|
}
|
|
|
|
func isVerified() -> String {
|
|
source == .frenchFederationVerified ? "ok" : ""
|
|
}
|
|
|
|
var duplicatePlayers: Int?
|
|
|
|
func championshipAlerts(tournament: Tournament, allPlayers: [(String, String)]) -> [ChampionshipAlert] {
|
|
var alerts = [ChampionshipAlert]()
|
|
|
|
if duplicatePlayers == nil {
|
|
let teamClubCode = self.team()?.clubCode
|
|
let strippedLicense = self.licenceId?.strippedLicense
|
|
duplicatePlayers = allPlayers.count(where: { strippedLicense == $0.0 && teamClubCode != $0.1 })
|
|
}
|
|
|
|
if let duplicatePlayers {
|
|
if duplicatePlayers > 0 {
|
|
print("doublon found \(duplicatePlayers)")
|
|
alerts.append(.duplicate(duplicatePlayers, self))
|
|
}
|
|
}
|
|
|
|
|
|
if isUnranked() && source == nil {
|
|
alerts.append(.unranked(self))
|
|
} else if source != .frenchFederationVerified {
|
|
if tournament.tournamentCategory == .men && isMalePlayer() == false {
|
|
alerts.append(.playerSexInvalid(self))
|
|
}
|
|
if tournament.tournamentCategory == .women && isMalePlayer() {
|
|
alerts.append(.playerSexInvalid(self))
|
|
}
|
|
if let computedAge, tournament.federalTournamentAge.isAgeValid(age: computedAge) == false {
|
|
alerts.append(.playerAgeInvalid(self))
|
|
}
|
|
if isClubCodeOK() == false {
|
|
alerts.append(.playerClubInvalid(self))
|
|
}
|
|
if isNameOK() == false {
|
|
alerts.append(.playerNameInvalid(self))
|
|
}
|
|
if isLicenceOK() == false {
|
|
alerts.append(.playerLicenseInvalid(self))
|
|
}
|
|
}
|
|
|
|
return alerts
|
|
}
|
|
|
|
func isClubCodeOK() -> Bool {
|
|
team()?.clubCode?.trimmed.canonicalVersion == clubCode?.trimmed.canonicalVersion
|
|
}
|
|
|
|
func isLicenceOK() -> Bool {
|
|
guard let licenceId else { return false }
|
|
let licenceIdTrimmed = licenceId.trimmed
|
|
guard licenceIdTrimmed.strippedLicense != nil else { return false }
|
|
|
|
if licenceIdTrimmed.hasLicenseKey() {
|
|
return licenceIdTrimmed.isLicenseNumber
|
|
} else {
|
|
return true
|
|
}
|
|
}
|
|
|
|
func isNameOK() -> Bool {
|
|
lastName.canonicalVersion == sourceName?.canonicalVersion
|
|
}
|
|
|
|
func isPlaying() -> Bool {
|
|
team()?.isPlaying() == true
|
|
}
|
|
|
|
func contains(_ searchField: String) -> Bool {
|
|
let nameComponents = searchField.canonicalVersion.split(separator: " ")
|
|
|
|
if nameComponents.count > 1 {
|
|
let pairs = nameComponents.pairs()
|
|
return pairs.contains(where: {
|
|
(firstName.canonicalVersion.localizedCaseInsensitiveContains(String($0)) &&
|
|
lastName.canonicalVersion.localizedCaseInsensitiveContains(String($1))) ||
|
|
(firstName.canonicalVersion.localizedCaseInsensitiveContains(String($1)) &&
|
|
lastName.canonicalVersion.localizedCaseInsensitiveContains(String($0)))
|
|
})
|
|
} else {
|
|
return nameComponents.contains { component in
|
|
firstName.canonicalVersion.localizedCaseInsensitiveContains(component) ||
|
|
lastName.canonicalVersion.localizedCaseInsensitiveContains(component)
|
|
}
|
|
}
|
|
}
|
|
|
|
func isSameAs(_ player: PlayerRegistration) -> Bool {
|
|
firstName.trimmedMultiline.canonicalVersion.localizedCaseInsensitiveCompare(player.firstName.trimmedMultiline.canonicalVersion) == .orderedSame &&
|
|
lastName.trimmedMultiline.canonicalVersion.localizedCaseInsensitiveCompare(player.lastName.trimmedMultiline.canonicalVersion) == .orderedSame
|
|
}
|
|
|
|
func tournament() -> Tournament? {
|
|
guard let tournament = team()?.tournament else { return nil }
|
|
return Store.main.findById(tournament)
|
|
}
|
|
|
|
func team() -> TeamRegistration? {
|
|
guard let teamRegistration else { return nil }
|
|
return self.tournamentStore.teamRegistrations.findById(teamRegistration)
|
|
}
|
|
|
|
func isHere() -> Bool {
|
|
hasArrived
|
|
}
|
|
|
|
func hasPaid() -> Bool {
|
|
paymentType != nil
|
|
}
|
|
|
|
func playerLabel(_ displayStyle: DisplayStyle = .wide) -> String {
|
|
switch displayStyle {
|
|
case .wide, .title:
|
|
return lastName.trimmed.capitalized + " " + firstName.trimmed.capitalized
|
|
case .short:
|
|
let names = lastName.components(separatedBy: .whitespaces)
|
|
if lastName.components(separatedBy: .whitespaces).count > 1 {
|
|
if let firstLongWord = names.first(where: { $0.count > 3 }) {
|
|
return firstLongWord.trimmed.capitalized.trunc(length: 10) + " " + firstName.trimmed.prefix(1).capitalized + "."
|
|
}
|
|
}
|
|
return lastName.trimmed.capitalized.trunc(length: 10) + " " + firstName.trimmed.prefix(1).capitalized + "."
|
|
}
|
|
}
|
|
|
|
func isImported() -> Bool {
|
|
source == .beachPadel
|
|
}
|
|
|
|
func isValidLicenseNumber(year: Int) -> Bool {
|
|
guard let licenceId else { return false }
|
|
guard licenceId.isLicenseNumber else { return false }
|
|
guard licenceId.suffix(6) == "(\(year))" else { return false }
|
|
return true
|
|
}
|
|
|
|
@objc
|
|
var canonicalName: String {
|
|
playerLabel().folding(options: .diacriticInsensitive, locale: .current).lowercased()
|
|
}
|
|
|
|
func rankLabel(_ displayStyle: DisplayStyle = .wide) -> String {
|
|
if let rank, rank > 0 {
|
|
if rank != computedRank {
|
|
return computedRank.formatted() + " (" + rank.formatted() + ")"
|
|
} else {
|
|
return rank.formatted()
|
|
}
|
|
} else {
|
|
return "non classé" + (isMalePlayer() ? "" : "e")
|
|
}
|
|
}
|
|
|
|
func updateRank(from sources: [CSVParser], lastRank: Int) async throws {
|
|
#if DEBUG_TIME //DEBUGING TIME
|
|
let start = Date()
|
|
defer {
|
|
let duration = Duration.milliseconds(Date().timeIntervalSince(start) * 1_000)
|
|
print("func updateRank()", id, duration.formatted(.units(allowed: [.seconds, .milliseconds])))
|
|
}
|
|
#endif
|
|
|
|
if let dataFound = try await history(from: sources) {
|
|
rank = dataFound.rankValue?.toInt()
|
|
points = dataFound.points
|
|
tournamentPlayed = dataFound.tournamentCountValue?.toInt()
|
|
} else {
|
|
rank = lastRank
|
|
}
|
|
}
|
|
|
|
func history(from sources: [CSVParser]) async throws -> Line? {
|
|
#if DEBUG_TIME //DEBUGING TIME
|
|
let start = Date()
|
|
defer {
|
|
let duration = Duration.milliseconds(Date().timeIntervalSince(start) * 1_000)
|
|
print("func history()", id, duration.formatted(.units(allowed: [.seconds, .milliseconds])))
|
|
}
|
|
#endif
|
|
|
|
guard let license = licenceId?.strippedLicense else {
|
|
return try await historyFromName(from: sources)
|
|
}
|
|
|
|
return await withTaskGroup(of: Line?.self) { group in
|
|
for source in sources.filter({ $0.maleData == isMalePlayer() }) {
|
|
group.addTask {
|
|
guard !Task.isCancelled else { print("Cancelled"); return nil }
|
|
|
|
return try? await source.first(where: { line in
|
|
line.rawValue.contains(";\(license);")
|
|
})
|
|
}
|
|
}
|
|
|
|
if let first = await group.first(where: { $0 != nil }) {
|
|
group.cancelAll()
|
|
return first
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func historyFromName(from sources: [CSVParser]) async throws -> Line? {
|
|
#if DEBUG_TIME //DEBUGING TIME
|
|
let start = Date()
|
|
defer {
|
|
let duration = Duration.milliseconds(Date().timeIntervalSince(start) * 1_000)
|
|
print("func historyFromName()", id, duration.formatted(.units(allowed: [.seconds, .milliseconds])))
|
|
}
|
|
#endif
|
|
|
|
return await withTaskGroup(of: Line?.self) { group in
|
|
for source in sources.filter({ $0.maleData == isMalePlayer() }) {
|
|
group.addTask { [lastName, firstName] in
|
|
guard !Task.isCancelled else { print("Cancelled"); return nil }
|
|
|
|
return try? await source.first(where: { line in
|
|
line.rawValue.canonicalVersionWithPunctuation.contains(";\(lastName.canonicalVersionWithPunctuation);\(firstName.canonicalVersionWithPunctuation);")
|
|
})
|
|
}
|
|
}
|
|
|
|
if let first = await group.first(where: { $0 != nil }) {
|
|
group.cancelAll()
|
|
return first
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func setComputedRank(in tournament: Tournament) {
|
|
if tournament.isAnimation() {
|
|
computedRank = rank ?? 0
|
|
return
|
|
}
|
|
|
|
let currentRank = rank ?? tournament.unrankValue(for: isMalePlayer()) ?? 70_000
|
|
switch tournament.tournamentCategory {
|
|
case .men:
|
|
computedRank = isMalePlayer() ? currentRank : currentRank + PlayerRegistration.addon(for: currentRank, manMax: tournament.maleUnrankedValue ?? 0, womanMax: tournament.femaleUnrankedValue ?? 0)
|
|
default:
|
|
computedRank = currentRank
|
|
}
|
|
}
|
|
|
|
func isMalePlayer() -> Bool {
|
|
sex == .male
|
|
}
|
|
|
|
func validateLicenceId(_ year: Int) {
|
|
if let currentLicenceId = licenceId {
|
|
if currentLicenceId.trimmed.hasSuffix("(\(year-1))") {
|
|
self.licenceId = currentLicenceId.replacingOccurrences(of: "\(year-1)", with: "\(year)")
|
|
} else if let computedLicense = currentLicenceId.strippedLicense?.computedLicense {
|
|
self.licenceId = computedLicense + " (\(year))"
|
|
}
|
|
}
|
|
}
|
|
|
|
func hasHomonym() -> Bool {
|
|
let federalContext = PersistenceController.shared.localContainer.viewContext
|
|
let fetchRequest = ImportedPlayer.fetchRequest()
|
|
let predicate = NSPredicate(format: "firstName == %@ && lastName == %@", firstName, lastName)
|
|
fetchRequest.predicate = predicate
|
|
|
|
do {
|
|
let count = try federalContext.count(for: fetchRequest)
|
|
return count > 1
|
|
} catch {
|
|
|
|
}
|
|
return false
|
|
}
|
|
|
|
enum CodingKeys: String, CodingKey {
|
|
case _id = "id"
|
|
case _teamRegistration = "teamRegistration"
|
|
case _firstName = "firstName"
|
|
case _lastName = "lastName"
|
|
case _licenceId = "licenceId"
|
|
case _rank = "rank"
|
|
case _paymentType = "paymentType"
|
|
case _sex = "sex"
|
|
case _tournamentPlayed = "tournamentPlayed"
|
|
case _points = "points"
|
|
case _clubName = "clubName"
|
|
case _ligueName = "ligueName"
|
|
case _assimilation = "assimilation"
|
|
case _birthdate = "birthdate"
|
|
case _phoneNumber = "phoneNumber"
|
|
case _email = "email"
|
|
case _computedRank = "computedRank"
|
|
case _source = "source"
|
|
case _hasArrived = "hasArrived"
|
|
case _coach = "coach"
|
|
case _captain = "captain"
|
|
case _clubCode = "clubCode"
|
|
case _sourceName = "sourceName"
|
|
case _isNveq = "isNveq"
|
|
}
|
|
|
|
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()
|
|
firstName = try container.decode(String.self, forKey: ._firstName)
|
|
lastName = try container.decode(String.self, forKey: ._lastName)
|
|
computedRank = try container.decodeIfPresent(Int.self, forKey: ._computedRank) ?? 0
|
|
hasArrived = try container.decodeIfPresent(Bool.self, forKey: ._hasArrived) ?? false
|
|
coach = try container.decodeIfPresent(Bool.self, forKey: ._coach) ?? false
|
|
captain = try container.decodeIfPresent(Bool.self, forKey: ._captain) ?? false
|
|
|
|
// Optional properties
|
|
teamRegistration = try container.decodeIfPresent(String.self, forKey: ._teamRegistration)
|
|
licenceId = try container.decodeIfPresent(String.self, forKey: ._licenceId)
|
|
rank = try container.decodeIfPresent(Int.self, forKey: ._rank)
|
|
paymentType = try container.decodeIfPresent(PlayerPaymentType.self, forKey: ._paymentType)
|
|
sex = try container.decodeIfPresent(PlayerSexType.self, forKey: ._sex)
|
|
tournamentPlayed = try container.decodeIfPresent(Int.self, forKey: ._tournamentPlayed)
|
|
points = try container.decodeIfPresent(Double.self, forKey: ._points)
|
|
clubName = try container.decodeIfPresent(String.self, forKey: ._clubName)
|
|
ligueName = try container.decodeIfPresent(String.self, forKey: ._ligueName)
|
|
assimilation = try container.decodeIfPresent(String.self, forKey: ._assimilation)
|
|
phoneNumber = try container.decodeIfPresent(String.self, forKey: ._phoneNumber)
|
|
email = try container.decodeIfPresent(String.self, forKey: ._email)
|
|
birthdate = try container.decodeIfPresent(String.self, forKey: ._birthdate)
|
|
source = try container.decodeIfPresent(PlayerDataSource.self, forKey: ._source)
|
|
clubCode = try container.decodeIfPresent(String.self, forKey: ._clubCode)
|
|
isNveq = try container.decodeIfPresent(Bool.self, forKey: ._isNveq) ?? false
|
|
sourceName = try container.decodeIfPresent(String.self, forKey: ._sourceName)
|
|
}
|
|
|
|
func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
|
|
try container.encode(id, forKey: ._id)
|
|
try container.encode(teamRegistration, forKey: ._teamRegistration)
|
|
|
|
try container.encode(firstName, forKey: ._firstName)
|
|
try container.encode(lastName, forKey: ._lastName)
|
|
try container.encode(licenceId, forKey: ._licenceId)
|
|
try container.encode(rank, forKey: ._rank)
|
|
try container.encode(paymentType, forKey: ._paymentType)
|
|
try container.encode(sex, forKey: ._sex)
|
|
try container.encode(tournamentPlayed, forKey: ._tournamentPlayed)
|
|
try container.encode(points, forKey: ._points)
|
|
try container.encode(clubName, forKey: ._clubName)
|
|
try container.encode(ligueName, forKey: ._ligueName)
|
|
try container.encode(assimilation, forKey: ._assimilation)
|
|
try container.encode(phoneNumber, forKey: ._phoneNumber)
|
|
try container.encode(email, forKey: ._email)
|
|
try container.encode(birthdate, forKey: ._birthdate)
|
|
try container.encode(computedRank, forKey: ._computedRank)
|
|
try container.encode(source, forKey: ._source)
|
|
try container.encode(hasArrived, forKey: ._hasArrived)
|
|
try container.encode(captain, forKey: ._captain)
|
|
try container.encode(coach, forKey: ._coach)
|
|
try container.encode(clubCode, forKey: ._clubCode)
|
|
try container.encode(sourceName, forKey: ._sourceName)
|
|
try container.encode(isNveq, forKey: ._isNveq)
|
|
}
|
|
|
|
enum PlayerDataSource: Int, Codable {
|
|
case frenchFederation = 0
|
|
case beachPadel = 1
|
|
case onlineRegistration = 2
|
|
case frenchFederationVerified = 3
|
|
}
|
|
|
|
enum PlayerSexType: Int, Hashable, CaseIterable, Identifiable, Codable {
|
|
init?(rawValue: Int?) {
|
|
guard let value = rawValue else { return nil }
|
|
self.init(rawValue: value)
|
|
}
|
|
|
|
var id: Self {
|
|
self
|
|
}
|
|
|
|
case female = 0
|
|
case male = 1
|
|
}
|
|
|
|
enum PlayerPaymentType: Int, CaseIterable, Identifiable, Codable {
|
|
init?(rawValue: Int?) {
|
|
guard let value = rawValue else { return nil }
|
|
self.init(rawValue: value)
|
|
}
|
|
|
|
var id: Self {
|
|
self
|
|
}
|
|
|
|
case cash = 0
|
|
case lydia = 1
|
|
case gift = 2
|
|
case check = 3
|
|
case paylib = 4
|
|
case bankTransfer = 5
|
|
case clubHouse = 6
|
|
case creditCard = 7
|
|
case forfeit = 8
|
|
|
|
func localizedLabel(_ displayStyle: DisplayStyle = .wide) -> String {
|
|
switch self {
|
|
case .check:
|
|
return "Chèque"
|
|
case .cash:
|
|
return "Cash"
|
|
case .lydia:
|
|
return "Lydia"
|
|
case .paylib:
|
|
return "Paylib"
|
|
case .bankTransfer:
|
|
return "Virement"
|
|
case .clubHouse:
|
|
return "Clubhouse"
|
|
case .creditCard:
|
|
return "CB"
|
|
case .forfeit:
|
|
return "Forfait"
|
|
case .gift:
|
|
return "Offert"
|
|
}
|
|
}
|
|
}
|
|
|
|
static func addon(for playerRank: Int, manMax: Int, womanMax: Int) -> Int {
|
|
switch playerRank {
|
|
case 0: return 0
|
|
case womanMax: return manMax - womanMax
|
|
case manMax: return 0
|
|
default:
|
|
return TournamentCategory.femaleInMaleAssimilationAddition(playerRank)
|
|
}
|
|
}
|
|
|
|
func insertOnServer() {
|
|
self.tournamentStore.playerRegistrations.writeChangeAndInsertOnServer(instance: self)
|
|
}
|
|
|
|
}
|
|
|
|
extension PlayerRegistration: Hashable {
|
|
static func == (lhs: PlayerRegistration, rhs: PlayerRegistration) -> Bool {
|
|
lhs.id == rhs.id
|
|
}
|
|
|
|
func hash(into hasher: inout Hasher) {
|
|
hasher.combine(id)
|
|
}
|
|
}
|
|
|
|
extension PlayerRegistration: PlayerHolder {
|
|
func getAssimilatedAsMaleRank() -> Int? {
|
|
nil
|
|
}
|
|
|
|
func getFirstName() -> String {
|
|
firstName
|
|
}
|
|
|
|
func getLastName() -> String {
|
|
lastName
|
|
}
|
|
|
|
func getPoints() -> Double? {
|
|
self.points
|
|
}
|
|
|
|
func getRank() -> Int? {
|
|
rank
|
|
}
|
|
|
|
func isUnranked() -> Bool {
|
|
rank == nil
|
|
}
|
|
|
|
func formattedRank() -> String {
|
|
self.rankLabel()
|
|
}
|
|
|
|
func formattedLicense() -> String {
|
|
if let licenceId { return licenceId.computedLicense }
|
|
return "aucune licence"
|
|
}
|
|
|
|
var male: Bool {
|
|
isMalePlayer()
|
|
}
|
|
|
|
func getBirthYear() -> Int? {
|
|
nil
|
|
}
|
|
|
|
func getProgression() -> Int {
|
|
0
|
|
}
|
|
|
|
func getComputedRank() -> Int? {
|
|
computedRank
|
|
}
|
|
}
|
|
|