PadelClubData/PadelClubData/Data/Gen/BaseMatchScheduler.swift

// Generated by SwiftModelGenerator
// Do not modify this file manually

import Foundation
import LeStorage
import SwiftUI

@Observable
public class BaseMatchScheduler: BaseModelObject, Storable {

    public static func resourceName() -> String { return "match-scheduler" }
    public static func tokenExemptedMethods() -> [HTTPMethod] { return [] }
    public static var copyServerResponse: Bool = false

    public var id: String = Store.randomId()
    public var tournament: String = ""
    public var timeDifferenceLimit: Int = 5
    public var loserBracketRotationDifference: Int = 0
    public var upperBracketRotationDifference: Int = 1
    public var accountUpperBracketBreakTime: Bool = true
    public var accountLoserBracketBreakTime: Bool = false
    public var randomizeCourts: Bool = true
    public var rotationDifferenceIsImportant: Bool = false
    public var shouldHandleUpperRoundSlice: Bool = false
    public var shouldEndRoundBeforeStartingNext: Bool = true
    public var groupStageChunkCount: Int? = nil
    public var overrideCourtsUnavailability: Bool = false
    public var shouldTryToFillUpCourtsAvailable: Bool = false
    public var courtsAvailable: Set<Int> = Set<Int>()
    public var simultaneousStart: Bool = true
    public var groupStageRotationDifference: Int = 0
    public var accountGroupStageBreakTime: Bool = false

    public init(
        id: String = Store.randomId(),
        tournament: String = "",
        timeDifferenceLimit: Int = 5,
        loserBracketRotationDifference: Int = 0,
        upperBracketRotationDifference: Int = 1,
        accountUpperBracketBreakTime: Bool = true,
        accountLoserBracketBreakTime: Bool = false,
        randomizeCourts: Bool = true,
        rotationDifferenceIsImportant: Bool = false,
        shouldHandleUpperRoundSlice: Bool = false,
        shouldEndRoundBeforeStartingNext: Bool = true,
        groupStageChunkCount: Int? = nil,
        overrideCourtsUnavailability: Bool = false,
        shouldTryToFillUpCourtsAvailable: Bool = false,
        courtsAvailable: Set<Int> = Set<Int>(),
        simultaneousStart: Bool = true,
        groupStageRotationDifference: Int = 0,
        accountGroupStageBreakTime: Bool = false
    ) {
        super.init()
        self.id = id
        self.tournament = tournament
        self.timeDifferenceLimit = timeDifferenceLimit
        self.loserBracketRotationDifference = loserBracketRotationDifference
        self.upperBracketRotationDifference = upperBracketRotationDifference
        self.accountUpperBracketBreakTime = accountUpperBracketBreakTime
        self.accountLoserBracketBreakTime = accountLoserBracketBreakTime
        self.randomizeCourts = randomizeCourts
        self.rotationDifferenceIsImportant = rotationDifferenceIsImportant
        self.shouldHandleUpperRoundSlice = shouldHandleUpperRoundSlice
        self.shouldEndRoundBeforeStartingNext = shouldEndRoundBeforeStartingNext
        self.groupStageChunkCount = groupStageChunkCount
        self.overrideCourtsUnavailability = overrideCourtsUnavailability
        self.shouldTryToFillUpCourtsAvailable = shouldTryToFillUpCourtsAvailable
        self.courtsAvailable = courtsAvailable
        self.simultaneousStart = simultaneousStart
        self.groupStageRotationDifference = groupStageRotationDifference
        self.accountGroupStageBreakTime = accountGroupStageBreakTime
    }
    required public override init() {
        super.init()
    }

    public enum CodingKeys: String, CodingKey {
        case _id = "id"
        case _tournament = "tournament"
        case _timeDifferenceLimit = "timeDifferenceLimit"
        case _loserBracketRotationDifference = "loserBracketRotationDifference"
        case _upperBracketRotationDifference = "upperBracketRotationDifference"
        case _accountUpperBracketBreakTime = "accountUpperBracketBreakTime"
        case _accountLoserBracketBreakTime = "accountLoserBracketBreakTime"
        case _randomizeCourts = "randomizeCourts"
        case _rotationDifferenceIsImportant = "rotationDifferenceIsImportant"
        case _shouldHandleUpperRoundSlice = "shouldHandleUpperRoundSlice"
        case _shouldEndRoundBeforeStartingNext = "shouldEndRoundBeforeStartingNext"
        case _groupStageChunkCount = "groupStageChunkCount"
        case _overrideCourtsUnavailability = "overrideCourtsUnavailability"
        case _shouldTryToFillUpCourtsAvailable = "shouldTryToFillUpCourtsAvailable"
        case _courtsAvailable = "courtsAvailable"
        case _simultaneousStart = "simultaneousStart"
        case _groupStageRotationDifference = "groupStageRotationDifference"
        case _accountGroupStageBreakTime = "accountGroupStageBreakTime"
    }

    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.id = try container.decodeIfPresent(String.self, forKey: ._id) ?? Store.randomId()
        self.tournament = try container.decodeIfPresent(String.self, forKey: ._tournament) ?? ""
        self.timeDifferenceLimit = try container.decodeIfPresent(Int.self, forKey: ._timeDifferenceLimit) ?? 5
        self.loserBracketRotationDifference = try container.decodeIfPresent(Int.self, forKey: ._loserBracketRotationDifference) ?? 0
        self.upperBracketRotationDifference = try container.decodeIfPresent(Int.self, forKey: ._upperBracketRotationDifference) ?? 1
        self.accountUpperBracketBreakTime = try container.decodeIfPresent(Bool.self, forKey: ._accountUpperBracketBreakTime) ?? true
        self.accountLoserBracketBreakTime = try container.decodeIfPresent(Bool.self, forKey: ._accountLoserBracketBreakTime) ?? false
        self.randomizeCourts = try container.decodeIfPresent(Bool.self, forKey: ._randomizeCourts) ?? true
        self.rotationDifferenceIsImportant = try container.decodeIfPresent(Bool.self, forKey: ._rotationDifferenceIsImportant) ?? false
        self.shouldHandleUpperRoundSlice = try container.decodeIfPresent(Bool.self, forKey: ._shouldHandleUpperRoundSlice) ?? false
        self.shouldEndRoundBeforeStartingNext = try container.decodeIfPresent(Bool.self, forKey: ._shouldEndRoundBeforeStartingNext) ?? true
        self.groupStageChunkCount = try container.decodeIfPresent(Int.self, forKey: ._groupStageChunkCount) ?? nil
        self.overrideCourtsUnavailability = try container.decodeIfPresent(Bool.self, forKey: ._overrideCourtsUnavailability) ?? false
        self.shouldTryToFillUpCourtsAvailable = try container.decodeIfPresent(Bool.self, forKey: ._shouldTryToFillUpCourtsAvailable) ?? false
        self.courtsAvailable = try container.decodeIfPresent(Set<Int>.self, forKey: ._courtsAvailable) ?? Set<Int>()
        self.simultaneousStart = try container.decodeIfPresent(Bool.self, forKey: ._simultaneousStart) ?? true
        self.groupStageRotationDifference = try container.decodeIfPresent(Int.self, forKey: ._groupStageRotationDifference) ?? 0
        self.accountGroupStageBreakTime = try container.decodeIfPresent(Bool.self, forKey: ._accountGroupStageBreakTime) ?? false
        try super.init(from: decoder)
    }

    public override func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(self.id, forKey: ._id)
        try container.encode(self.tournament, forKey: ._tournament)
        try container.encode(self.timeDifferenceLimit, forKey: ._timeDifferenceLimit)
        try container.encode(self.loserBracketRotationDifference, forKey: ._loserBracketRotationDifference)
        try container.encode(self.upperBracketRotationDifference, forKey: ._upperBracketRotationDifference)
        try container.encode(self.accountUpperBracketBreakTime, forKey: ._accountUpperBracketBreakTime)
        try container.encode(self.accountLoserBracketBreakTime, forKey: ._accountLoserBracketBreakTime)
        try container.encode(self.randomizeCourts, forKey: ._randomizeCourts)
        try container.encode(self.rotationDifferenceIsImportant, forKey: ._rotationDifferenceIsImportant)
        try container.encode(self.shouldHandleUpperRoundSlice, forKey: ._shouldHandleUpperRoundSlice)
        try container.encode(self.shouldEndRoundBeforeStartingNext, forKey: ._shouldEndRoundBeforeStartingNext)
        try container.encode(self.groupStageChunkCount, forKey: ._groupStageChunkCount)
        try container.encode(self.overrideCourtsUnavailability, forKey: ._overrideCourtsUnavailability)
        try container.encode(self.shouldTryToFillUpCourtsAvailable, forKey: ._shouldTryToFillUpCourtsAvailable)
        try container.encode(self.courtsAvailable, forKey: ._courtsAvailable)
        try container.encode(self.simultaneousStart, forKey: ._simultaneousStart)
        try container.encode(self.groupStageRotationDifference, forKey: ._groupStageRotationDifference)
        try container.encode(self.accountGroupStageBreakTime, forKey: ._accountGroupStageBreakTime)
        try super.encode(to: encoder)
    }

    func tournamentValue() -> Tournament? {
        return Store.main.findById(tournament)
    }

    public func copy(from other: any Storable) {
        guard let matchscheduler = other as? BaseMatchScheduler else { return }
        self.id = matchscheduler.id
        self.tournament = matchscheduler.tournament
        self.timeDifferenceLimit = matchscheduler.timeDifferenceLimit
        self.loserBracketRotationDifference = matchscheduler.loserBracketRotationDifference
        self.upperBracketRotationDifference = matchscheduler.upperBracketRotationDifference
        self.accountUpperBracketBreakTime = matchscheduler.accountUpperBracketBreakTime
        self.accountLoserBracketBreakTime = matchscheduler.accountLoserBracketBreakTime
        self.randomizeCourts = matchscheduler.randomizeCourts
        self.rotationDifferenceIsImportant = matchscheduler.rotationDifferenceIsImportant
        self.shouldHandleUpperRoundSlice = matchscheduler.shouldHandleUpperRoundSlice
        self.shouldEndRoundBeforeStartingNext = matchscheduler.shouldEndRoundBeforeStartingNext
        self.groupStageChunkCount = matchscheduler.groupStageChunkCount
        self.overrideCourtsUnavailability = matchscheduler.overrideCourtsUnavailability
        self.shouldTryToFillUpCourtsAvailable = matchscheduler.shouldTryToFillUpCourtsAvailable
        self.courtsAvailable = matchscheduler.courtsAvailable
        self.simultaneousStart = matchscheduler.simultaneousStart
        self.groupStageRotationDifference = matchscheduler.groupStageRotationDifference
        self.accountGroupStageBreakTime = matchscheduler.accountGroupStageBreakTime
    }

    public static func relationships() -> [Relationship] {
        return [
            Relationship(type: Tournament.self, keyPath: \BaseMatchScheduler.tournament),
        ]
    }

}