Как сохранить отклик JSON в модели Swift

Question

Я хочу показать данные автомобиля в виде таблицы, и есть 2 типа истории модели.Как вы можете видеть в моем ответе, 1-й объект автомобиля имеет историю, а другой объект - Нет.Как сделать json модель Structure of History в структуре VehicalModel, как получить доступ к этой модели и карте с помощью alamofire.И Как проверить, доступна история или нет, если есть, то сохранить в модели и показать в виде таблицы.

Это мой ответ

{
    "response": "success",
    "account_type": "2",
    "car_data": [
        {
            "registration_no": "Lzq 2233",
            "engincc": "600 - 999",
            "enginccID": "1",
            "vehicleID": "32",
            "history": [
                {
                    "packages": "",
                    "date_time": "2018-12-22 00:40:55",
                    "bill_amount": "7098",
                    "bill_discount": "133.0571251",
                    "bill_paid": "36070"
                }
            ]
        },
        {
            "registration_no": "ghfdhhh",
            "engincc": "1500 - 1799",
            "enginccID": "3",
            "vehicleID": "33",
            "history": "None"
        }
    ]
}

Это моя модель

struct VehicleDataModel {
    var registrationNo : String?
    var engineCC: String?
    var engineCCID: String?
    var vehicleID: String?
    var history: [HistoryModel]


    struct HistoryModel {
        var packages: String
        var billDiscount : String
        var dateTime: String
        var billPaid: String
        var billAmount: String
    }
}

Это моя функция API вызова:

func callApi() {
    let url = "http://esspk.net/production/20m/Api/getVehicleApi"
    let userID = UserDefaults.standard.integer(forKey: "user_id")
    let param = ["user_id" : userID]
    print(param)
    ServerCall.makeCallWitoutFile(url, params: param, type: Method.POST, currentView: nil) { (response) in
        if let json = response {
            print(json)
            if let carData = json["car_data"].array
            {
                //let vehicalObj = VehicleDataModel()

                for cData in carData {

                    let regNo = cData["registration_no"].string
                    let enginCC = cData["engincc"].string
                    let enginID = cData["enginccID"].string
                    let vehicleID = cData["vehicleID"].string

                    let history = cData["history"].arrayObject
//                  let vech = VehicleDataModel(registrationNo: regNo, engineCC: enginCC, engineCCID: enginID, vehicleID: vehicle, history: history)
                    // self.vehicalModel.append(vech)
//                  let vech = VehicleDataModel.init(registrationNo: regNo, engineCC: enginCC, engineCCID: enginID, vehicleID: vehicleID, history: VehicleDataModel.HistoryModel( )                         
                }
                self.myVehicleTblView.reloadData()
            }
        }
    }
}

Answer 1

First Make Model Class.

class Welcome: Codable {
    let response, accountType: String
    let carData: [CarDatum]

    enum CodingKeys: String, CodingKey {
        case response
        case accountType = "account_type"
        case carData = "car_data"
    }

    init(response: String, accountType: String, carData: [CarDatum]) {
        self.response = response
        self.accountType = accountType
        self.carData = carData
    }
}

class CarDatum: Codable {
    let registrationNo, engincc, enginccID, vehicleID: String
    let history: HistoryUnion

    enum CodingKeys: String, CodingKey {
        case registrationNo = "registration_no"
        case engincc, enginccID, vehicleID, history
    }

    init(registrationNo: String, engincc: String, enginccID: String, vehicleID: String, history: HistoryUnion) {
        self.registrationNo = registrationNo
        self.engincc = engincc
        self.enginccID = enginccID
        self.vehicleID = vehicleID
        self.history = history
    }
}

enum HistoryUnion: Codable {
    case historyElementArray([HistoryElement])
    case string(String)

    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        if let x = try? container.decode([HistoryElement].self) {
            self = .historyElementArray(x)
            return
        }
        if let x = try? container.decode(String.self) {
            self = .string(x)
            return
        }
        throw DecodingError.typeMismatch(HistoryUnion.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for HistoryUnion"))
    }

    func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        switch self {
        case .historyElementArray(let x):
            try container.encode(x)
        case .string(let x):
            try container.encode(x)
        }
    }
}

class HistoryElement: Codable {
    let packages, dateTime, billAmount, billDiscount: String
    let billPaid: String

    enum CodingKeys: String, CodingKey {
        case packages
        case dateTime = "date_time"
        case billAmount = "bill_amount"
        case billDiscount = "bill_discount"
        case billPaid = "bill_paid"
    }

    init(packages: String, dateTime: String, billAmount: String, billDiscount: String, billPaid: String) {
        self.packages = packages
        self.dateTime = dateTime
        self.billAmount = billAmount
        self.billDiscount = billDiscount
        self.billPaid = billPaid
    }
}

Или вы также можете использовать ниже Class

struct Welcome {
    let response, accountType: String
    let carData: [CarDatum]
}

struct CarDatum {
    let registrationNo, engincc, enginccID, vehicleID: String
    let history: HistoryUnion
}

enum HistoryUnion {
    case historyElementArray([HistoryElement])
    case string(String)
}

struct HistoryElement {
    let packages, dateTime, billAmount, billDiscount: String
    let billPaid: String
}

Тогда я рекомендовал использовать Alamofire для вызова API.

func request() {

        let url = URL(string: "my url")
        Alamofire.request(url!).responseJSON {(response) in

            switch (response.result) {
            case .success:
                if let data = response.data {
                    do {
                        let response = try JSONDecoder().decode([Welcome].self, from: data)
                        self.arrList = response
                        DispatchQueue.main.async {
                            //Print Responce
                        }
                    } catch {
                        print(error.localizedDescription)
                    }
                }
            case .failure( let error):
                print(error)
            }
        }
    }
} 

Надеюсь, что это работает.