парсинг массива двух разных объектов из ответа JSON

Question

Я пытаюсь проанализировать данные JSON .. я знаю, как это сделать для одного массива объектов ... но я не знаю, как это сделать для ответа, который имеет два массива различных объектов ..

например, это JSON:

  {
"shifts": [
    {
        "id": 4,
        "region": "Eastren",
        "city": "Khobar",
        "nationality": "1",
        "id_service": 2,
        "shift_date": "2018-04-05",
        "shift_type": "night",
        "weekday": "sunday",
        "quantity_staff": 8,
        "lead_hours": 2,
        "created_at": "2018-04-23 11:46:20",
        "updated_at": "2018-04-24 08:46:14",
        "deleted_at": null
    },
    {
        "id": 5,
        "region": "Eastren",
        "city": "Khobar",
        "nationality": "Phili",
        "id_service": 2,
        "shift_date": "2018-04-04",
        "shift_type": "night",
        "weekday": "sunday",
        "quantity_staff": 8,
        "lead_hours": 2,
        "created_at": "2018-04-23 11:47:25",
        "updated_at": "2018-04-23 12:53:05",
        "deleted_at": "2018-04-23"
    }
],
"prices": [
    {
        "id": 1,
        "id_service": 2,
        "nationality": "Phili",
        "price": 150,
        "created_at": "2018-04-23 11:43:40",
        "updated_at": "2018-04-23 11:43:40",
        "deleted_at": null
    }
]
}

он имеет два массива объектов .. сдвиги и цены .. как разобрать каждый из них?

моя функция:

 func GetShiftsAndPrices(id: Int){

    let todosEndpoint: String = "my link"
    guard let todosURL = URL(string: todosEndpoint) else {
        print("Error: cannot create URL")
        return
    }
    var todosUrlRequest = URLRequest(url: todosURL)
    todosUrlRequest.httpMethod = "POST"
    todosUrlRequest.addValue("application/json", forHTTPHeaderField: "Content-Type")
    let newTodo: [String: Any] = ["id_service": id]
    let jsonTodo: Data
    do {
        jsonTodo = try JSONSerialization.data(withJSONObject: newTodo, options: [])
        todosUrlRequest.httpBody = jsonTodo
    } catch {
        print("Error: cannot create JSON from todo")
        return
    }

    let session = URLSession.shared

    let task = session.dataTask(with: todosUrlRequest) {
        (data, response, error) in
        guard error == nil else {
            print("error calling POST on /public/api/login_customer")
            print(error!)
            return
        }
        guard let responseData = data else {
            print("Error: did not receive data")
            return
        }

        // parse the result as JSON, since that's what the API provides
        do {

             //WHAT SHOULD I DO HERE?

                print("Success!")

        } catch  {
            print("error parsing response from POST")
            return
        }
    }
    task.resume()}
   }

У меня есть классы для смены и цены ... и я знаю, как получить каждый из них, если он был один в ответе ... как:

смены:

                  let decoder = JSONDecoder()
                decoder.keyDecodingStrategy = .convertFromSnakeCase
                let shifts1 = try decoder.decode([Shifts].self, from: responseData)
                var shifts = [Shift]()
                for shift in shifts1{
                    let newshift = Shift(id: shift.id, region: shift.region, city: shift.city, nationality: shift.nationality, idService: shift.idService, shiftDate: shift.shiftDate, shiftType: shift.shiftType, weekday: shift.weekday, quantityStaff: shift.quantityStaff, leadHours: shift.leadHours)
                    shifts.append(newshift)
                }


                let userDefaults = UserDefaults.standard
                let encodedData: Data = NSKeyedArchiver.archivedData(withRootObject: shifts)
                userDefaults.set(encodedData, forKey: "shifts")
                userDefaults.synchronize()

                let decoded  = userDefaults.object(forKey: "shifts") as! Data
                let decodedShift = NSKeyedUnarchiver.unarchiveObject(with: decoded) as! [Shift]

                for shift in decodedShift {
                    print(shift.id)
                }

цены:

        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        let prices1 = try decoder.decode([Prices].self, from: responseData)
        print("1")
        var prices = [Price]()
        for price in prices1{
            let newprice = Price(id: price.id, idService: price.idService,nationality: price.nationality, price: price.price)
            print("2")
            prices.append(newprice)
            print(newprice.nationality)
        }


        let userDefaults = UserDefaults.standard
        let encodedData: Data = NSKeyedArchiver.archivedData(withRootObject: prices)
        userDefaults.set(encodedData, forKey: "prices")
        userDefaults.synchronize()

        let decoded  = userDefaults.object(forKey: "prices") as! Data
        let decodedPrice = NSKeyedUnarchiver.unarchiveObject(with: decoded) as! [Price]

        for price in decodedPrice {
            print(price.nationality)
        }

как разобрать их обоих в одном ответе JSON .. Я новичок в этом .. может кто-нибудь подскажите, пожалуйста, как это сделать?

Answer 1

Используйте структуру зонта

struct Root : Decodable {
    let shifts : [Shift]
    let prices : [Price]
}

и две разные структуры для смен и цен:

struct Shift : Decodable {
    let id: Int
    let region, city, nationality : String
    let idService : Int
    let shiftDate, shiftType, weekday : String
    let quantityStaff, leadHours : Int
    let createdAt, updatedAt : String
    let deletedAt : String?
}

struct Price : Decodable {
    let id, idService : Int
    let nationality : String
    let price : Int
    let createdAt, updatedAt : String
    let deletedAt : String?
}

---

Для декодирования JSON напишите

do {
    let decoder = JSONDecoder()
    decoder.keyDecodingStrategy = .convertFromSnakeCase
    let result = try decoder .decode(Root.self, from: responseData)
    print(result.prices)
    print(result.shifts)
} catch { print(error) }

---

Далее я рекомендую декодировать такие ключи, как shiftType и weekday, непосредственно в enum, например

enum ShiftType : String, Decodable {
    case day, night
}

struct Shift : Decodable {
    let id: Int
    ...
    let shiftType : ShiftType
    ...

Answer 2

let shifts = responseJson.valueFor(key:"shifts") as? [String] ?? []
let prices = responseJson.valueFor(key:"prices") as? [String] ?? []
print("\(shifts) and \(prices)")