Расшифруйте JSON с динамическим ключом

Question

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

Я пробовал приведенный ниже код, но он не работает из-за несоответствия данных из-за недавно введенного planName.

struct ProductDescriptionResponse {
    let disclaimersHtml: String?
    let additionalProperties: [String: ProductDescription]?
}

struct ProductDescription {
    var disclaimersHtml: String?
    var hasPlanDetailsV2: Bool?
    let planDescription: String
    let serviceDescriptions: [ServiceDescriptions]
}

struct ServiceDescriptions {
    let name: String
    let subTitle: String?
    let icon: String?
    let description: String?
    let upgradeText: String?
    let featureDisclaimer: String?
}

func productDescriptions() -> Observable<ProductDescriptionResponse> {

        return APIClient.sharedInstance.rx.response(apiURL: APIURL.productDescription, requestType: .get, httpBody: nil, header: .auth).map({ (responseData) -> ProductDescriptionResponse in

            var parsedData = try JSONSerialization.jsonObject(with: responseData) as? [String:Any]

            // Remove disclaimersHtml key from responseData & hold it to pass
            // in ProductDescriptionResponse constructor during return.
            let disclaimersHtml = parsedData?.removeValue(forKey: "disclaimersHtml") as? String
            // Product descriptions.
            var productDescriptions: [String: ProductDescription]? = nil

            if let parsedData = parsedData {

                // Json data without disclaimersHtml.
                let jsonData = try JSONSerialization.data(withJSONObject: parsedData, options: .prettyPrinted)

                productDescriptions =  try JSONDecoder().decode([String: ProductDescription].self, from: jsonData)
            }

            // ProductDescriptionResponse with disclaimersHtml & productDescriptions.
            return ProductDescriptionResponse(disclaimersHtml: disclaimersHtml,
                                              additionalProperties: productDescriptions)
        })
    }

Ответ JSON:

{
    "disclaimersHtml": "",
    "planName": "",
    “abc456753234”: {
        "planDescription": "",
        "hasPlanDetailsV2": false,
        "serviceDescriptions": [
            {
                "name": "",
                "subTitle": "",
                "icon": "",
                "hasTile": "",
                "tileTitle": "",
                "description": "",
                "featureDisclaimer": "",
                "upgradeText": ""
            },
            {
                "name": "",
                "subTitle": "",
                "icon": "",
                "hasTile": "",
                "tileTitle": "",
                "description": "",
                "featureDisclaimer": "",
                "upgradeText": ""
            }
        ]
    },
    “xyz123456789”: {
        "planDescription": "",
        "hasPlanDetailsV2": true,
        "serviceDescriptions": [
            {
                "name": "",
                "subTitle": "",
                "icon": "",
                "hasTile": "",
                "tileTitle": "",
                "description": "",
                "featureDisclaimer": "",
                "upgradeText": ""
            }
        ]
    }
}

Если я сделаю это ниже, это сработает.Но не хочу продолжать жесткое кодирование, как это:

let _ = parsedData?.removeValue(forKey: "planName") as? String

Есть ли что-нибудь лучше для этого типа JSON для работы?Я не хочу жестко кодировать и продолжать извлекать значения, чтобы получить ProductDescriptionResponse, потому что это поле может быть добавлено в будущем.

Answer 1

Я бы решил эту проблему, используя CustomCodingKeys:

struct ProductDescriptionResponse: Decodable {

    let disclaimersHtml: String?
    let additionalProperties: [String: ProductDescription]?
    var disclaimersHtml: String? = nil
    var additionalProperties: [String: ProductDescription]? = nil

    private struct CustomCodingKeys: CodingKey {
        var stringValue: String

        init?(stringValue: String) {
            self.stringValue = stringValue
        }
        var intValue: Int?
        init?(intValue: Int) {
            return nil
        }
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CustomCodingKeys.self)
        self.additionalProperties = [String: ProductDescription]()
        for key in container.allKeys {
            do {
                if let keyValue = CustomCodingKeys(stringValue: key.stringValue) {
                    if  keyValue.stringValue == "disclaimersHtml" {
                        self.disclaimersHtml = try container.decodeIfPresent(String.self, forKey: keyValue)
                    }

                    self.additionalProperties?[keyValue.stringValue] = try container.decodeIfPresent(ProductDescription.self, forKey: keyValue)
                }
            } catch {
                // Silently ignore the error
            }
        }
    }
}

 func productDescriptions() -> Observable<ProductDescriptionResponse> {

        return APIClient.sharedInstance.rx.response(memberAPIURL: MemberAPIURL.productDescription, requestType: .get, httpBody: nil, header: .auth).map({ (response) -> ProductDescriptionResponse in
            return try JSONDecoder().decode(ProductDescriptionResponse.self, from: response)

        })
    }

Answer 2

Способ, который я решил, - это итерация по (key, value) сериализованного JSON.

Проверьте, что value имеет тип Dictionary<AnyHashable,Any> и декодируйте, только если это соответствует, иначе игнорируйте.

func productDescriptions() -> Observable<ProductDescriptionResponse> {

        return APIClient.sharedInstance.rx.response(memberAPIURL: MemberAPIURL.productDescription, requestType: .get, httpBody: nil, header: .auth).map({ (responseData) -> ProductDescriptionResponse in

            var productDescriptionResponse = ProductDescriptionResponse(disclaimersHtml: nil, additionalProperties: nil)

            var additionalParams: [String: ProductDescription] = [:]

                do {

                    productDescriptionResponse  =  try JSONDecoder().decode(ProductDescriptionResponse.self, from: responseData)

                    if let jsonObject = try JSONSerialization.jsonObject(with: responseData, options: .mutableLeaves) as? [String : Any] {

                        for (key,value) in jsonObject {
                            if value is Dictionary<AnyHashable,Any> {
                                let jsonData = try JSONSerialization.data(withJSONObject: value, options: JSONSerialization.WritingOptions.prettyPrinted)
                                let productDescription =  try JSONDecoder().decode(ProductDescription.self, from: jsonData)
                                additionalParams[key] = productDescription
                            }
                        }
                        productDescriptionResponse.additionalProperties = additionalParams

                    }

                } catch {
                    // handle error
                }

            return productDescriptionResponse
        })
    }