JSON Decoder Type Mismatch Error

Question

I want to parse JSON using decodable, but I get an error type mismatch like:

Swift.DecodingError.Context(codingPath: [], debugDescription: "Expected to decode Array but found a dictionary instead."

My JSON :

{
  "code": 0,
  "data": {
    "_id": "string",
    "title": "string",
    "images": [
      "string"
    ],
    "shortDesc": "string",
    "desc": "string",
    "price": 0,
    "discountPrice": 0,
    "quantity": 0,
    "category": {
      "name": "string",
      "val": "string"
    },
    "brand": {
      "name": "string",
      "val": "string"
    },
    "variants": [
      {
        "name": "string",
        "value": "string",
        "quantity": 0,
        "variantCode": "string"
      }
    ],
    "stockCode": "string",
    "updatedDate": "2018-06-05T14:04:51.226Z",
    "status": true,
    "isDeleted": true,
    "isNew": true,
    "freeCargo": true,
    "createDate": "2018-06-05T14:04:51.226Z",
    "note1": "string",
    "note2": "string",
    "note3": "string",
    "shop": {
      "name": "string",
      "val": "string"
    }
  },
  "error": "string"
}

MY MODEL:

struct ProductDetail : Decodable {
        let code : Int = 0
        let error : String = ""
        var data : NestedData? = nil
}

NESTED DATA:

struct NestedData : Decodable{
    let _id : String = ""
    let title : String = ""
    let images : [String] = []
    let shortDesc : String = ""
    let desc : String = ""
    let price : Int = 0
    let discountPrice : Int = 0
    let quantity : Int = 0
    let updatedDate : String = ""
    let status : Bool = false
    let isDeleted : Bool = false
    let isNew : Bool = false
    let freeCargo : Bool = false
    let createDate : String = ""
    let note1: String = ""
    let note2: String = ""
    let note3: String = ""
    let variants : [variants]? = nil
    let brand : brand? = nil
    let category :category? = nil
    let shop : shop? = nil

}

OBJECTS:

struct variants : Decodable{
    let name : String
    let val : String
    let quantity : Int
    let variantCode : String
}

struct brand : Decodable{
    let name : String
    let val : String
}

struct category : Decodable{
    let name : String
    let val : String
}

struct shop : Decodable{
    let name : String
    let val : String
}

I don't understand why I get an error, Console says expected array but dictionary found but I don't understand unfortunately.

Answer 1

Ok man I advise you to use quicktype

it will help you to make your model

I use it and this is the Model

struct ProductDetail: Codable {
    let code: Int?
    let data: DataClass?
    let error: String?
}

struct DataClass: Codable {
    let id, title: String?
    let images: [String]?
    let shortDesc, desc: String?
    let price, discountPrice, quantity: Int?
    let category, brand: Brand?
    let variants: [Variant]?
    let stockCode, updatedDate: String?
    let status, isDeleted, isNew, freeCargo: Bool?
    let createDate, note1, note2, note3: String?
    let shop: Brand?

    enum CodingKeys: String, CodingKey {
        case id = "_id"
        case title, images, shortDesc, desc, price, discountPrice, quantity, category, brand, variants, stockCode, updatedDate, status, isDeleted, isNew, freeCargo, createDate, note1, note2, note3, shop
    }
}

struct Brand: Codable {
    let name, val: String?
}

struct Variant: Codable {
    let name, value: String?
    let quantity: Int?
    let variantCode: String?
}

after that, you can use JSONDecoder

Alamofire.request(urlCourses, method: .get, parameters: nil, encoding: URLEncoding.default, headers: nil).responseJSON { (response) in

        switch response.result {

        case .success:

            guard let data = response.data else { return }

            do {

                let productDetail = try? JSONDecoder().decode(ProductDetail.self, from: jsonData)

            } catch let jsonError {

                print("Error serializing json:", jsonError)
            }

        case .failure(let error):

            print(error)
        }
}