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.
795 lines
30 KiB
795 lines
30 KiB
// This file was generated from JSON Schema using quicktype, do not modify it directly.
|
|
// To parse the JSON, add this file to your project and do:
|
|
//
|
|
// let federalTournament = try? JSONDecoder().decode(FederalTournament.self, from: jsonData)
|
|
|
|
import Foundation
|
|
import CoreLocation
|
|
import LeStorage
|
|
import PadelClubData
|
|
|
|
|
|
// MARK: - FederalTournament
|
|
struct FederalTournament: Identifiable, Codable, Hashable {
|
|
|
|
func getEvent() -> Event {
|
|
let club = DataStore.shared.user.clubsObjects().first(where: { $0.code == codeClub })
|
|
var event = DataStore.shared.events.first(where: { $0.tenupId == id.string })
|
|
if event == nil {
|
|
event = Event(creator: StoreCenter.main.userId, club: club?.id, name: libelle, tenupId: id.string)
|
|
do {
|
|
try DataStore.shared.events.addOrUpdate(instance: event!)
|
|
} catch {
|
|
Logger.error(error)
|
|
}
|
|
}
|
|
if let club, club.creator == nil {
|
|
club.creator = StoreCenter.main.userId
|
|
do {
|
|
try DataStore.shared.clubs.addOrUpdate(instance: club)
|
|
} catch {
|
|
Logger.error(error)
|
|
}
|
|
}
|
|
return event!
|
|
}
|
|
|
|
static func sectionedData(from federalTournaments: [FederalTournament]) -> [String: [FederalTournament]] {
|
|
Dictionary(grouping: federalTournaments) { federalTournament in
|
|
URL.importDateFormatter.string(from: (federalTournament.dateDebut ?? .distantFuture))
|
|
}
|
|
}
|
|
|
|
|
|
let id: String
|
|
var millesime: Int?
|
|
var libelle: String?
|
|
var tmc: Bool?
|
|
var tarifAdulteChampionnat: Double?
|
|
var type: String?
|
|
var ageReel: Bool?
|
|
var naturesTerrains: [JSONAny]?
|
|
var idsArbitres: [JSONAny]?
|
|
var tarifJeuneChampionnat: Double?
|
|
var international, inscriptionEnLigne: Bool?
|
|
var categorieTournoi: CategorieTournoi?
|
|
var prixLot: Int?
|
|
var paiementEnLigne: Bool?
|
|
var reductionAdherentJeune, reductionAdherentAdulte: Double?
|
|
var paiementEnLigneObligatoire: Bool?
|
|
var villeEngagement: String?
|
|
var senior, veteran, inscriptionEnLigneEnCours, avecResultatPublie: Bool?
|
|
var code: String?
|
|
var categorieAge: CategorieAge?
|
|
var codeComite: String?
|
|
var installations: [JSONAny]?
|
|
var reductionEpreuveSupplementaireJeune, reductionEpreuveSupplementaireAdulte: Double?
|
|
var nomComite: String?
|
|
var naturesEpreuves: [Serie]?
|
|
var jeune: Bool?
|
|
var courrielEngagement, nomClub: String?
|
|
var installation: Installation?
|
|
var categorieAgeMax: CategorieAge?
|
|
var tournoiInterne: Bool?
|
|
var nomLigue, nomEngagement, codeLigue: String?
|
|
var modeleDeBalle: ModeleDeBalle?
|
|
var jugeArbitre: JugeArbitre?
|
|
var adresse2Engagement: String?
|
|
var epreuves: [Epreuve]?
|
|
var dateDebut: Date?
|
|
var serie: Serie?
|
|
var dateFin, dateValidation: Date?
|
|
var codePostalEngagement, codeClub: String?
|
|
var prixEspece: Int?
|
|
var japPhoneNumber: String?
|
|
|
|
mutating func updateJapPhoneNumber(phone: String?) {
|
|
self.japPhoneNumber = phone
|
|
}
|
|
|
|
init(from decoder: Decoder) throws {
|
|
let container = try decoder.container(keyedBy: CodingKeys.self)
|
|
|
|
// Handle id that could be string or int
|
|
if let idString = try? container.decode(String.self, forKey: .id) {
|
|
id = idString
|
|
} else if let idInt = try? container.decode(Int.self, forKey: .id) {
|
|
id = String(idInt)
|
|
} else {
|
|
throw DecodingError.dataCorruptedError(forKey: .id, in: container,
|
|
debugDescription: "Expected String or Int for id")
|
|
}
|
|
|
|
// Regular decoding for simple properties
|
|
millesime = try container.decodeIfPresent(Int.self, forKey: .millesime)
|
|
libelle = try container.decodeIfPresent(String.self, forKey: .libelle)
|
|
tmc = try container.decodeIfPresent(Bool.self, forKey: .tmc)
|
|
tarifAdulteChampionnat = try container.decodeIfPresent(Double.self, forKey: .tarifAdulteChampionnat)
|
|
type = try container.decodeIfPresent(String.self, forKey: .type)
|
|
ageReel = try container.decodeIfPresent(Bool.self, forKey: .ageReel)
|
|
naturesTerrains = try container.decodeIfPresent([JSONAny].self, forKey: .naturesTerrains)
|
|
idsArbitres = try container.decodeIfPresent([JSONAny].self, forKey: .idsArbitres)
|
|
tarifJeuneChampionnat = try container.decodeIfPresent(Double.self, forKey: .tarifJeuneChampionnat)
|
|
international = try container.decodeIfPresent(Bool.self, forKey: .international)
|
|
inscriptionEnLigne = try container.decodeIfPresent(Bool.self, forKey: .inscriptionEnLigne)
|
|
categorieTournoi = try container.decodeIfPresent(CategorieTournoi.self, forKey: .categorieTournoi)
|
|
prixLot = try container.decodeIfPresent(Int.self, forKey: .prixLot)
|
|
paiementEnLigne = try container.decodeIfPresent(Bool.self, forKey: .paiementEnLigne)
|
|
reductionAdherentJeune = try container.decodeIfPresent(Double.self, forKey: .reductionAdherentJeune)
|
|
reductionAdherentAdulte = try container.decodeIfPresent(Double.self, forKey: .reductionAdherentAdulte)
|
|
paiementEnLigneObligatoire = try container.decodeIfPresent(Bool.self, forKey: .paiementEnLigneObligatoire)
|
|
villeEngagement = try container.decodeIfPresent(String.self, forKey: .villeEngagement)
|
|
senior = try container.decodeIfPresent(Bool.self, forKey: .senior)
|
|
veteran = try container.decodeIfPresent(Bool.self, forKey: .veteran)
|
|
inscriptionEnLigneEnCours = try container.decodeIfPresent(Bool.self, forKey: .inscriptionEnLigneEnCours)
|
|
avecResultatPublie = try container.decodeIfPresent(Bool.self, forKey: .avecResultatPublie)
|
|
code = try container.decodeIfPresent(String.self, forKey: .code)
|
|
categorieAge = try container.decodeIfPresent(CategorieAge.self, forKey: .categorieAge)
|
|
codeComite = try container.decodeIfPresent(String.self, forKey: .codeComite)
|
|
installations = try container.decodeIfPresent([JSONAny].self, forKey: .installations)
|
|
reductionEpreuveSupplementaireJeune = try container.decodeIfPresent(Double.self, forKey: .reductionEpreuveSupplementaireJeune)
|
|
reductionEpreuveSupplementaireAdulte = try container.decodeIfPresent(Double.self, forKey: .reductionEpreuveSupplementaireAdulte)
|
|
nomComite = try container.decodeIfPresent(String.self, forKey: .nomComite)
|
|
naturesEpreuves = try container.decodeIfPresent([Serie].self, forKey: .naturesEpreuves)
|
|
jeune = try container.decodeIfPresent(Bool.self, forKey: .jeune)
|
|
courrielEngagement = try container.decodeIfPresent(String.self, forKey: .courrielEngagement)
|
|
nomClub = try container.decodeIfPresent(String.self, forKey: .nomClub)
|
|
installation = try container.decodeIfPresent(Installation.self, forKey: .installation)
|
|
categorieAgeMax = try container.decodeIfPresent(CategorieAge.self, forKey: .categorieAgeMax)
|
|
tournoiInterne = try container.decodeIfPresent(Bool.self, forKey: .tournoiInterne)
|
|
nomLigue = try container.decodeIfPresent(String.self, forKey: .nomLigue)
|
|
nomEngagement = try container.decodeIfPresent(String.self, forKey: .nomEngagement)
|
|
codeLigue = try container.decodeIfPresent(String.self, forKey: .codeLigue)
|
|
modeleDeBalle = try container.decodeIfPresent(ModeleDeBalle.self, forKey: .modeleDeBalle)
|
|
jugeArbitre = try container.decodeIfPresent(JugeArbitre.self, forKey: .jugeArbitre)
|
|
adresse2Engagement = try container.decodeIfPresent(String.self, forKey: .adresse2Engagement)
|
|
epreuves = try container.decodeIfPresent([Epreuve].self, forKey: .epreuves)
|
|
serie = try container.decodeIfPresent(Serie.self, forKey: .serie)
|
|
codePostalEngagement = try container.decodeIfPresent(String.self, forKey: .codePostalEngagement)
|
|
codeClub = try container.decodeIfPresent(String.self, forKey: .codeClub)
|
|
prixEspece = try container.decodeIfPresent(Int.self, forKey: .prixEspece)
|
|
|
|
// Custom decoding for dateDebut
|
|
if let dateContainer = try? container.nestedContainer(keyedBy: DateKeys.self, forKey: .dateDebut) {
|
|
if let dateString = try? dateContainer.decode(String.self, forKey: .date) {
|
|
let dateFormatter = DateFormatter()
|
|
dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss.SSSSSS"
|
|
dateDebut = dateFormatter.date(from: dateString)
|
|
}
|
|
}
|
|
|
|
// Custom decoding for dateFin
|
|
if let dateContainer = try? container.nestedContainer(keyedBy: DateKeys.self, forKey: .dateFin) {
|
|
if let dateString = try? dateContainer.decode(String.self, forKey: .date) {
|
|
let dateFormatter = DateFormatter()
|
|
dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss.SSSSSS"
|
|
dateFin = dateFormatter.date(from: dateString)
|
|
}
|
|
}
|
|
|
|
// Custom decoding for dateValidation
|
|
if let dateContainer = try? container.nestedContainer(keyedBy: DateKeys.self, forKey: .dateValidation) {
|
|
if let dateString = try? dateContainer.decode(String.self, forKey: .date) {
|
|
let dateFormatter = DateFormatter()
|
|
dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss.SSSSSS"
|
|
dateValidation = dateFormatter.date(from: dateString)
|
|
}
|
|
}
|
|
}
|
|
|
|
private enum DateKeys: String, CodingKey {
|
|
case date
|
|
}
|
|
|
|
var dayPeriod: DayPeriod {
|
|
if let dateDebut {
|
|
let day = dateDebut.get(.weekday)
|
|
switch day {
|
|
case 2...6:
|
|
return .week
|
|
default:
|
|
return .weekend
|
|
}
|
|
}
|
|
return .all
|
|
}
|
|
|
|
var dayDuration: Int {
|
|
if let dateDebut, let dateFin {
|
|
return Calendar.current.numberOfDaysBetween(dateDebut, and: dateFin) + 1
|
|
} else {
|
|
return 1
|
|
}
|
|
}
|
|
|
|
var city: String? {
|
|
if let installation { return installation.ville }
|
|
return nil
|
|
}
|
|
|
|
var location: CLLocation? {
|
|
if let lat = installation?.lat, let lng = installation?.lng {
|
|
return CLLocation(latitude: lat, longitude: lng)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var computedStartDate: String? {
|
|
dateDebut?.formatted(.dateTime.day(.defaultDigits).month(.abbreviated).year())
|
|
}
|
|
|
|
var tournaments: [any TournamentBuildHolder] {
|
|
epreuves?
|
|
.compactMap({ $0.tournamentBuild })
|
|
.sorted(using:
|
|
.keyPath(\TournamentBuild.level.order),
|
|
.keyPath(\TournamentBuild.category.order),
|
|
.keyPath(\TournamentBuild.age.order))
|
|
?? []
|
|
}
|
|
|
|
var federalClub: FederalClub? {
|
|
if let codeClub {
|
|
return FederalClub(federalClubCode: codeClub, federalClubName: clubLabel())
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
var shareMessage: String {
|
|
[libelle, dateDebut?.formatted(date: .complete, time: .omitted)].compactMap({$0}).joined(separator: "\n") + "\n"
|
|
}
|
|
|
|
var sharePartnerMessage: String {
|
|
["Je nous ai inscris au tournoi suivant : ",
|
|
libelle,
|
|
dateDebut?.formatted(date: .complete, time: .omitted),
|
|
"message preparé par Padel Club",
|
|
URLs.appStore.rawValue
|
|
].compactMap({$0}).joined(separator: "\n") + "\n"
|
|
}
|
|
|
|
func calendarNoteMessage() -> String {
|
|
[jugeArbitre?.nom, jugeArbitre?.prenom, courrielEngagement, installation?.telephone].compactMap({$0}).joined(separator: "\n")
|
|
}
|
|
|
|
var japMessage: String {
|
|
[nomClub, jugeArbitre?.nom, jugeArbitre?.prenom, courrielEngagement, japPhoneNumber].compactMap({$0}).joined(separator: ";")
|
|
}
|
|
|
|
func umpireLabel() -> String {
|
|
[jugeArbitre?.nom, jugeArbitre?.prenom].compactMap({$0}).map({ $0.lowercased().capitalized }).joined(separator: " ")
|
|
}
|
|
|
|
func phoneLabel() -> String {
|
|
[installation?.telephone].compactMap({$0}).joined(separator: " ")
|
|
}
|
|
|
|
func mailLabel() -> String {
|
|
[courrielEngagement].compactMap({$0}).joined(separator: " ")
|
|
}
|
|
|
|
func validForSearch(_ searchText: String, scope: FederalTournamentSearchScope) -> Bool {
|
|
var trimmedSearchText = searchText.lowercased().trimmingCharacters(in: .whitespaces).folding(options: .diacriticInsensitive, locale: .current)
|
|
trimmedSearchText = trimmedSearchText.replaceCharactersFromSet(characterSet: .punctuationCharacters, replacementString: " ")
|
|
trimmedSearchText = trimmedSearchText.replaceCharactersFromSet(characterSet: .symbols, replacementString: " ")
|
|
|
|
switch scope {
|
|
case .club:
|
|
return nomClub?.canonicalVersion.localizedCaseInsensitiveContains(trimmedSearchText) == true
|
|
case .all:
|
|
return libelle?.canonicalVersion.localizedCaseInsensitiveContains(trimmedSearchText) == true || nomClub?.canonicalVersion.localizedCaseInsensitiveContains(trimmedSearchText) == true || nomLigue?.canonicalVersion.localizedCaseInsensitiveContains(trimmedSearchText) == true || jugeArbitre?.nom?.canonicalVersion.localizedCaseInsensitiveContains(trimmedSearchText) == true ||
|
|
jugeArbitre?.prenom?.canonicalVersion.localizedCaseInsensitiveContains(trimmedSearchText) == true
|
|
case .ligue:
|
|
return nomLigue?.canonicalVersion.localizedCaseInsensitiveContains(trimmedSearchText) == true
|
|
}
|
|
}
|
|
}
|
|
|
|
extension FederalTournament: FederalTournamentHolder {
|
|
var startDate: Date { dateDebut ?? .distantFuture }
|
|
var endDate: Date? { dateFin }
|
|
// var distance: Double? { distanceEnMetres }
|
|
// var localizedLabel: String? { libelle }
|
|
// var clubName: String? { nomClub }
|
|
// var importedId: Int { id }
|
|
|
|
var holderId: String { id.string }
|
|
func clubLabel() -> String {
|
|
nomClub ?? villeEngagement ?? installation?.nom ?? ""
|
|
}
|
|
|
|
func subtitleLabel(forBuild build: any TournamentBuildHolder) -> String {
|
|
""
|
|
}
|
|
|
|
func tournamentTitle(_ displayStyle: DisplayStyle, forBuild build: any TournamentBuildHolder) -> String {
|
|
build.level.localizedLevelLabel(displayStyle)
|
|
}
|
|
|
|
func displayAgeAndCategory(forBuild build: any TournamentBuildHolder) -> Bool {
|
|
true
|
|
}
|
|
}
|
|
|
|
// MARK: - CategorieAge
|
|
struct CategorieAge: Codable, Hashable {
|
|
var ageJoueurMin, ageMin, ageJoueurMax, ageRechercheMax: Int?
|
|
var categoriesAgeTypePratique: [CategoriesAgeTypePratique]?
|
|
var ageMax: Int?
|
|
var libelle: String?
|
|
var id: Int?
|
|
var valide, ageReel: Bool?
|
|
var ageRechercheMin: Int?
|
|
var homologable: Bool?
|
|
|
|
var tournamentAge: FederalTournamentAge? {
|
|
if let id {
|
|
return FederalTournamentAge(rawValue: id) ?? .senior
|
|
}
|
|
if let libelle {
|
|
return FederalTournamentAge.allCases.first(where: { $0.localizedFederalAgeLabel().localizedCaseInsensitiveContains(libelle) }) ?? .senior
|
|
}
|
|
return .senior
|
|
}
|
|
}
|
|
|
|
// MARK: - CategoriesAgeTypePratique
|
|
struct CategoriesAgeTypePratique: Codable, Hashable {
|
|
var id: ID?
|
|
}
|
|
|
|
// MARK: - ID
|
|
struct ID: Codable, Hashable {
|
|
var typePratique: String?
|
|
var idCategorieAge: Int?
|
|
}
|
|
|
|
// MARK: - CategorieTournoi
|
|
struct CategorieTournoi: Codable, Hashable {
|
|
var code, codeTaxe: String?
|
|
var compteurGda: CompteurGda?
|
|
var libelle, niveauHierarchique: String?
|
|
var valide: Bool?
|
|
}
|
|
|
|
// MARK: - CompteurGda
|
|
struct CompteurGda: Codable, Hashable {
|
|
var classementMax: Classement?
|
|
var libelle: String?
|
|
var classementMin: Classement?
|
|
}
|
|
|
|
// MARK: - Classement
|
|
struct Classement: Codable, Hashable {
|
|
var nature, libelle: String?
|
|
var serie: Serie?
|
|
var sexe: String?
|
|
var id: Int?
|
|
var valide: Bool?
|
|
var poidsDouble, echelon: Int?
|
|
}
|
|
|
|
// MARK: - Serie
|
|
struct Serie: Codable, Hashable {
|
|
var code, libelle: String?
|
|
var valide: Bool?
|
|
var sexe: String?
|
|
|
|
var tournamentCategory: TournamentCategory? {
|
|
TournamentCategory.allCases.first(where: { $0.requestLabel == code }) ?? .men
|
|
}
|
|
}
|
|
|
|
// MARK: - Epreuve
|
|
struct Epreuve: Codable, Hashable {
|
|
var inscriptionEnLigneEnCours: Bool?
|
|
var categorieAge: CategorieAge?
|
|
var typeEpreuve: TypeEpreuve?
|
|
var tarifAdulte: Double?
|
|
var classementHaut: Classement?
|
|
var nombreDecoupagesPublies: Int?
|
|
var libelle: String?
|
|
var participationAgeReel, clotureInscriptionSansPreavis: Bool?
|
|
var dateCloture: Date?
|
|
var publicationResultat: Bool?
|
|
var classementBas: Classement?
|
|
var tarifsSpecifiques: [JSONAny]?
|
|
var homologuee: Bool?
|
|
var dateDebut: Date?
|
|
var tarifJeune: Double?
|
|
var serie: Serie?
|
|
var categorieAgeMax: CategorieAge?
|
|
var dateFin: Date?
|
|
var borneAnneesNaissance: BorneAnneesNaissance?
|
|
var natureEpreuve: Serie?
|
|
var epreuveOpen: Bool?
|
|
|
|
enum CodingKeys: String, CodingKey {
|
|
case inscriptionEnLigneEnCours, categorieAge, tarifAdulte, classementHaut, nombreDecoupagesPublies, libelle, participationAgeReel, clotureInscriptionSansPreavis, dateCloture, publicationResultat, classementBas, tarifsSpecifiques, homologuee, dateDebut, tarifJeune, serie, categorieAgeMax, dateFin, borneAnneesNaissance, natureEpreuve, typeEpreuve
|
|
case epreuveOpen = "open"
|
|
}
|
|
|
|
var tournamentBuild: TournamentBuild? {
|
|
if let age = categorieAge?.tournamentAge, let category = natureEpreuve?.tournamentCategory, let level = typeEpreuve?.tournamentLevel {
|
|
return TournamentBuild(category: category, level: level, age: age)
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
// MARK: - TypeEpreuve
|
|
struct TypeEpreuve: Codable, Hashable {
|
|
let code: String?
|
|
let delai: Int?
|
|
let libelle: String?
|
|
let coefficient, montantMax, montantMin: Int?
|
|
let valide: Bool?
|
|
let echelon: Int?
|
|
let typeHomologation: String?
|
|
|
|
var tournamentLevel: TournamentLevel? {
|
|
if let code, let value = Int(code.removingFirstCharacter) {
|
|
return TournamentLevel(rawValue: value) ?? .p100
|
|
}
|
|
return .p100
|
|
}
|
|
}
|
|
|
|
// MARK: - BorneAnneesNaissance
|
|
struct BorneAnneesNaissance: Codable, Hashable {
|
|
var min, max: Int?
|
|
}
|
|
|
|
// MARK: - Installation
|
|
struct Installation: Codable, Hashable {
|
|
var ville: String?
|
|
var lng: Double?
|
|
var surfaces: [JSONAny]?
|
|
var vestiaires: Bool?
|
|
var telephone, codePostal, nom, adresse1, adresse2: String?
|
|
var lat: Double?
|
|
var clubHouse: Bool?
|
|
|
|
var libelle: String {
|
|
[adresse1, adresse2, ville, codePostal].compactMap({ $0 }).joined(separator: " ")
|
|
}
|
|
}
|
|
|
|
// MARK: - JugeArbitre
|
|
struct JugeArbitre: Codable, Hashable {
|
|
var idCRM, id: Int?
|
|
var nom, prenom: String?
|
|
|
|
enum CodingKeys: String, CodingKey {
|
|
case idCRM = "idCrm"
|
|
case id, nom, prenom
|
|
}
|
|
}
|
|
|
|
// MARK: - ModeleDeBalle
|
|
struct ModeleDeBalle: Codable, Hashable {
|
|
var libelle: String?
|
|
var marqueDeBalle: MarqueDeBalle?
|
|
var id: Int?
|
|
var valide, homologue: Bool?
|
|
}
|
|
|
|
// MARK: - MarqueDeBalle
|
|
struct MarqueDeBalle: Codable, Hashable {
|
|
var id: Int?
|
|
var valide: Bool?
|
|
var marque: String?
|
|
}
|
|
|
|
// MARK: - Encode/decode helpers
|
|
|
|
class JSONNull: Codable, Hashable {
|
|
|
|
public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool {
|
|
return true
|
|
}
|
|
|
|
public var hashValue: Int {
|
|
return 0
|
|
}
|
|
|
|
public init() {}
|
|
|
|
public required init(from decoder: Decoder) throws {
|
|
let container = try decoder.singleValueContainer()
|
|
if !container.decodeNil() {
|
|
throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull"))
|
|
}
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encodeNil()
|
|
}
|
|
}
|
|
|
|
class JSONCodingKey: CodingKey {
|
|
let key: String
|
|
|
|
required init?(intValue: Int) {
|
|
return nil
|
|
}
|
|
|
|
required init?(stringValue: String) {
|
|
key = stringValue
|
|
}
|
|
|
|
var intValue: Int? {
|
|
return nil
|
|
}
|
|
|
|
var stringValue: String {
|
|
return key
|
|
}
|
|
}
|
|
|
|
class JSONAny: Codable, Hashable, Equatable {
|
|
|
|
var value: Any
|
|
|
|
init() {
|
|
self.value = ()
|
|
}
|
|
|
|
static func decodingError(forCodingPath codingPath: [CodingKey]) -> DecodingError {
|
|
let context = DecodingError.Context(codingPath: codingPath, debugDescription: "Cannot decode JSONAny")
|
|
return DecodingError.typeMismatch(JSONAny.self, context)
|
|
}
|
|
|
|
static func encodingError(forValue value: Any, codingPath: [CodingKey]) -> EncodingError {
|
|
let context = EncodingError.Context(codingPath: codingPath, debugDescription: "Cannot encode JSONAny")
|
|
return EncodingError.invalidValue(value, context)
|
|
}
|
|
|
|
static func decode(from container: SingleValueDecodingContainer) throws -> Any {
|
|
if let value = try? container.decode(Bool.self) {
|
|
return value
|
|
}
|
|
if let value = try? container.decode(Int64.self) {
|
|
return value
|
|
}
|
|
if let value = try? container.decode(Double.self) {
|
|
return value
|
|
}
|
|
if let value = try? container.decode(String.self) {
|
|
return value
|
|
}
|
|
if container.decodeNil() {
|
|
return JSONNull()
|
|
}
|
|
throw decodingError(forCodingPath: container.codingPath)
|
|
}
|
|
|
|
static func decode(from container: inout UnkeyedDecodingContainer) throws -> Any {
|
|
if let value = try? container.decode(Bool.self) {
|
|
return value
|
|
}
|
|
if let value = try? container.decode(Int64.self) {
|
|
return value
|
|
}
|
|
if let value = try? container.decode(Double.self) {
|
|
return value
|
|
}
|
|
if let value = try? container.decode(String.self) {
|
|
return value
|
|
}
|
|
if let value = try? container.decodeNil() {
|
|
if value {
|
|
return JSONNull()
|
|
}
|
|
}
|
|
if var container = try? container.nestedUnkeyedContainer() {
|
|
return try decodeArray(from: &container)
|
|
}
|
|
if var container = try? container.nestedContainer(keyedBy: JSONCodingKey.self) {
|
|
return try decodeDictionary(from: &container)
|
|
}
|
|
throw decodingError(forCodingPath: container.codingPath)
|
|
}
|
|
|
|
static func decode(from container: inout KeyedDecodingContainer<JSONCodingKey>, forKey key: JSONCodingKey) throws -> Any {
|
|
if let value = try? container.decode(Bool.self, forKey: key) {
|
|
return value
|
|
}
|
|
if let value = try? container.decode(Int64.self, forKey: key) {
|
|
return value
|
|
}
|
|
if let value = try? container.decode(Double.self, forKey: key) {
|
|
return value
|
|
}
|
|
if let value = try? container.decode(String.self, forKey: key) {
|
|
return value
|
|
}
|
|
if let value = try? container.decodeNil(forKey: key) {
|
|
if value {
|
|
return JSONNull()
|
|
}
|
|
}
|
|
if var container = try? container.nestedUnkeyedContainer(forKey: key) {
|
|
return try decodeArray(from: &container)
|
|
}
|
|
if var container = try? container.nestedContainer(keyedBy: JSONCodingKey.self, forKey: key) {
|
|
return try decodeDictionary(from: &container)
|
|
}
|
|
throw decodingError(forCodingPath: container.codingPath)
|
|
}
|
|
|
|
static func decodeArray(from container: inout UnkeyedDecodingContainer) throws -> [Any] {
|
|
var arr: [Any] = []
|
|
while !container.isAtEnd {
|
|
let value = try decode(from: &container)
|
|
arr.append(value)
|
|
}
|
|
return arr
|
|
}
|
|
|
|
static func decodeDictionary(from container: inout KeyedDecodingContainer<JSONCodingKey>) throws -> [String: Any] {
|
|
var dict = [String: Any]()
|
|
for key in container.allKeys {
|
|
let value = try decode(from: &container, forKey: key)
|
|
dict[key.stringValue] = value
|
|
}
|
|
return dict
|
|
}
|
|
|
|
static func encode(to container: inout UnkeyedEncodingContainer, array: [Any]) throws {
|
|
for value in array {
|
|
if let value = value as? Bool {
|
|
try container.encode(value)
|
|
} else if let value = value as? Int64 {
|
|
try container.encode(value)
|
|
} else if let value = value as? Double {
|
|
try container.encode(value)
|
|
} else if let value = value as? String {
|
|
try container.encode(value)
|
|
} else if value is JSONNull {
|
|
try container.encodeNil()
|
|
} else if let value = value as? [Any] {
|
|
var container = container.nestedUnkeyedContainer()
|
|
try encode(to: &container, array: value)
|
|
} else if let value = value as? [String: Any] {
|
|
var container = container.nestedContainer(keyedBy: JSONCodingKey.self)
|
|
try encode(to: &container, dictionary: value)
|
|
} else {
|
|
throw encodingError(forValue: value, codingPath: container.codingPath)
|
|
}
|
|
}
|
|
}
|
|
|
|
static func encode(to container: inout KeyedEncodingContainer<JSONCodingKey>, dictionary: [String: Any]) throws {
|
|
for (key, value) in dictionary {
|
|
let key = JSONCodingKey(stringValue: key)!
|
|
if let value = value as? Bool {
|
|
try container.encode(value, forKey: key)
|
|
} else if let value = value as? Int64 {
|
|
try container.encode(value, forKey: key)
|
|
} else if let value = value as? Double {
|
|
try container.encode(value, forKey: key)
|
|
} else if let value = value as? String {
|
|
try container.encode(value, forKey: key)
|
|
} else if value is JSONNull {
|
|
try container.encodeNil(forKey: key)
|
|
} else if let value = value as? [Any] {
|
|
var container = container.nestedUnkeyedContainer(forKey: key)
|
|
try encode(to: &container, array: value)
|
|
} else if let value = value as? [String: Any] {
|
|
var container = container.nestedContainer(keyedBy: JSONCodingKey.self, forKey: key)
|
|
try encode(to: &container, dictionary: value)
|
|
} else {
|
|
throw encodingError(forValue: value, codingPath: container.codingPath)
|
|
}
|
|
}
|
|
}
|
|
|
|
static func encode(to container: inout SingleValueEncodingContainer, value: Any) throws {
|
|
if let value = value as? Bool {
|
|
try container.encode(value)
|
|
} else if let value = value as? Int64 {
|
|
try container.encode(value)
|
|
} else if let value = value as? Double {
|
|
try container.encode(value)
|
|
} else if let value = value as? String {
|
|
try container.encode(value)
|
|
} else if value is JSONNull {
|
|
try container.encodeNil()
|
|
} else {
|
|
throw encodingError(forValue: value, codingPath: container.codingPath)
|
|
}
|
|
}
|
|
|
|
public required init(from decoder: Decoder) throws {
|
|
if var arrayContainer = try? decoder.unkeyedContainer() {
|
|
self.value = try JSONAny.decodeArray(from: &arrayContainer)
|
|
} else if var container = try? decoder.container(keyedBy: JSONCodingKey.self) {
|
|
self.value = try JSONAny.decodeDictionary(from: &container)
|
|
} else {
|
|
let container = try decoder.singleValueContainer()
|
|
self.value = try JSONAny.decode(from: container)
|
|
}
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
if let arr = self.value as? [Any] {
|
|
var container = encoder.unkeyedContainer()
|
|
try JSONAny.encode(to: &container, array: arr)
|
|
} else if let dict = self.value as? [String: Any] {
|
|
var container = encoder.container(keyedBy: JSONCodingKey.self)
|
|
try JSONAny.encode(to: &container, dictionary: dict)
|
|
} else {
|
|
var container = encoder.singleValueContainer()
|
|
try JSONAny.encode(to: &container, value: self.value)
|
|
}
|
|
}
|
|
|
|
public static func == (lhs: JSONAny, rhs: JSONAny) -> Bool {
|
|
switch (lhs.value, rhs.value) {
|
|
case (let l as Bool, let r as Bool): return l == r
|
|
case (let l as Int64, let r as Int64): return l == r
|
|
case (let l as Double, let r as Double): return l == r
|
|
case (let l as String, let r as String): return l == r
|
|
case (let l as JSONNull, let r as JSONNull): return true
|
|
case (let l as [Any], let r as [Any]):
|
|
guard l.count == r.count else { return false }
|
|
return zip(l, r).allSatisfy { (a, b) in
|
|
// Recursively wrap in JSONAny for comparison
|
|
JSONAny(value: a) == JSONAny(value: b)
|
|
}
|
|
case (let l as [String: Any], let r as [String: Any]):
|
|
guard l.count == r.count else { return false }
|
|
for (key, lVal) in l {
|
|
guard let rVal = r[key], JSONAny(value: lVal) == JSONAny(value: rVal) else { return false }
|
|
}
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
switch value {
|
|
case let v as Bool:
|
|
hasher.combine(0)
|
|
hasher.combine(v)
|
|
case let v as Int64:
|
|
hasher.combine(1)
|
|
hasher.combine(v)
|
|
case let v as Double:
|
|
hasher.combine(2)
|
|
hasher.combine(v)
|
|
case let v as String:
|
|
hasher.combine(3)
|
|
hasher.combine(v)
|
|
case is JSONNull:
|
|
hasher.combine(4)
|
|
case let v as [Any]:
|
|
hasher.combine(5)
|
|
for elem in v {
|
|
JSONAny(value: elem).hash(into: &hasher)
|
|
}
|
|
case let v as [String: Any]:
|
|
hasher.combine(6)
|
|
// Order of hashing dictionary keys shouldn't matter
|
|
for key in v.keys.sorted() {
|
|
hasher.combine(key)
|
|
if let val = v[key] {
|
|
JSONAny(value: val).hash(into: &hasher)
|
|
}
|
|
}
|
|
default:
|
|
hasher.combine(-1)
|
|
}
|
|
}
|
|
|
|
// Helper init for internal use
|
|
convenience init(value: Any) {
|
|
self.init()
|
|
self.value = value
|
|
}
|
|
}
|
|
|
|
|