Error while trying to Parsing API Response with Alamofire - ios

Question

API Response:
{
"data": {
"customer_id": "fb5056fe-d7cf-4b5e-3e32-08d9568a3822",
"source": "self",
"type": "customer",
"language": "en",
"identity_card": {
"first_name": "abdulrahman",
"middle_name": "ahmed",
"last_name": "ali",
"localized_first_name": "abdulrahman",
"localized_middle_name": "ahmed",
"localized_last_name": "ali",
"identity_card_number_last_digits": "4416",
"date_of_birth": "1994-05-15T00:00:00",
"date_of_birth_calendar_type": "gregorian"
},
"income": [],
"identity_verifications": [
null
],
"is_identity_verification_complete": false,
"is_address_complete": false,
"is_income_complete": false,
"is_usage_complete": false,
"is_employment_complete": false,
"customer_status": 3,
"customer_status_description": "inactive",
"wallet_status": 0,
"wallet_status_description": "pending"
}
}
My model:
struct cst_Value : Codable {
let address : cst_Addres?
let employment : cst_Employment?
let income : [cst_Income]?
let usage : cst_Usage?
let identityVerification : [cst_IdentityVerification]?
let customer_id : String?
let source : String?
let type : String?
let language : String?
let email : String?
let phone_number : String?
let identity_card : cst_IdentityCard?
let is_identity_verification_complete : Bool?
let is_address_complete : Bool?
let is_income_complete : Bool?
let is_usage_complete : Bool?
let is_employment_complete : Bool?
let status : String?
enum CodingKeys: String, CodingKey {
case customer_id = "customer_id"
case source = "source"
case type = "type"
case language = "language"
case email = "email"
case phone_number = "phone_number"
case identity_card = "identity_card"
case is_identity_verification_complete = "is_identity_verification_complete"
case is_address_complete = "is_address_complete"
case is_income_complete = "is_income_complete"
case is_usage_complete = "is_usage_complete"
case is_employment_complete = "is_employment_complete"
case status = "status"
case address = "address"
case employment = "employment"
case income = "income"
case usage = "usage"
case identityVerification = "identity_verifications"
}
init(from decoder: Decoder) throws {
let values = try decoder.container(keyedBy: CodingKeys.self)
customer_id = try values.decodeIfPresent(String.self, forKey: .customer_id)
source = try values.decodeIfPresent(String.self, forKey: .source)
type = try values.decodeIfPresent(String.self, forKey: .type)
language = try values.decodeIfPresent(String.self, forKey: .language)
email = try values.decodeIfPresent(String.self, forKey: .email)
phone_number = try values.decodeIfPresent(String.self, forKey: .phone_number)
identity_card = try values.decodeIfPresent(cst_IdentityCard.self, forKey: .identity_card)
is_identity_verification_complete = try values.decodeIfPresent(Bool.self, forKey: .is_identity_verification_complete)
is_address_complete = try values.decodeIfPresent(Bool.self, forKey: .is_address_complete)
is_income_complete = try values.decodeIfPresent(Bool.self, forKey: .is_income_complete)
is_usage_complete = try values.decodeIfPresent(Bool.self, forKey: .is_usage_complete)
is_employment_complete = try values.decodeIfPresent(Bool.self, forKey: .is_employment_complete)
status = try values.decodeIfPresent(String.self, forKey: .status)
address = try values.decodeIfPresent(cst_Addres.self, forKey: .address)
employment = try values.decodeIfPresent(cst_Employment.self, forKey: .employment)
income = try values.decodeIfPresent([cst_Income].self, forKey: .income)
usage = try values.decodeIfPresent(cst_Usage.self, forKey: .usage)
identityVerification = try values.decodeIfPresent([cst_IdentityVerification].self, forKey: .identityVerification)
}
}
struct cst_IdentityVerification : Codable {
let identityVerificationMethod : String?
let identityVerificationStatus : String?
enum CodingKeys: String, CodingKey {
case identityVerificationMethod = "identity_verification_method"
case identityVerificationStatus = "identity_verification_status"
}
init(from decoder: Decoder) throws {
let values = try decoder.container(keyedBy: CodingKeys.self)
identityVerificationMethod = try values.decodeIfPresent(String.self, forKey: .identityVerificationMethod)
identityVerificationStatus = try values.decodeIfPresent(String.self, forKey: .identityVerificationStatus)
}
}
The Error:
▿ Optional<AFError>
▿ some : AFError
▿ responseSerializationFailed : 1 element
▿ reason : ResponseSerializationFailureReason
▿ decodingFailed : 1 element
▿ error : DecodingError
▿ valueNotFound : 2 elements
- .0 : Swift.KeyedDecodingContainer<MobilePay.cst_IdentityVerification.CodingKeys>
▿ .1 : Context
▿ codingPath : 3 elements
- 0 : CodingKeys(stringValue: "data", intValue: nil)
- 1 : CodingKeys(stringValue: "identity_verifications", intValue: nil)
▿ 2 : _JSONKey(stringValue: "Index 0", intValue: 0)
- stringValue : "Index 0"
▿ intValue : Optional<Int>
- some : 0
- debugDescription : "Cannot get keyed decoding container -- found null value instead."
- underlyingError : nil

Answer 1

The source of your problem is given in the error message
1 : CodingKeys(stringValue: "identity_verifications", intValue: nil)
This should prompt you to check that data structure and the associated JSON.
The property is defined as
let identityVerification : [cst_IdentityVerification]?
So, an optional array of cst_IdentityVerification elements.
The JSON however is
"identity_verifications": [
null
],
so a non-optional array with an optional element.
This is not the same. In the definition the array is optional, in the data the array in non-optional, but with an element that is optional.
Looking at the JSON you need a data structure of
let identityVerification : [cst_IdentityVerification?]
although if there is a chance that the array itself could be nil you will need
let identityVerification : [cst_IdentityVerification?]?

Answer 2

You have a number of problems here. The major one is that you have json with three tiers of data and you are treating it as one flat structure. You have two choices here. You could make it fit your existing data structure by manually unwrapping all the nested levels within the init(decoder:) and handling the containers manually, but the easier way is to model the json in your data structures and allow Decodable to do it for you.
The first level you have is the top level data dictionary. You can create a wrapper struct for the decoding of this:
struct Wrapper: Codable {
let data: cst_Value
}
Then you will need to define the cst_Value struct (note Swift convention is that all types should start with a capital letter). This is similar to what you have before, but as we are now relying on Decodable you don't need to define the CodingKeys or initialiser.
struct cst_Value : Codable {
let address : cst_Addres?
let employment : cst_Employment?
let income : [cst_Income]?
let usage : cst_Usage?
let identityVerification : [cst_IdentityVerification?]?
let customer_id : String?
let source : String?
let type : String?
let language : String?
let email : String?
let phone_number : String?
let identity_card : cst_IdentityCard?
let is_identity_verification_complete : Bool?
let is_address_complete : Bool?
let is_income_complete : Bool?
let is_usage_complete : Bool?
let is_employment_complete : Bool?
let status : String?
Many of these fields aren't present in your JSON but I have left them in as they are optional and might(?) be present in some future json. If they will remain unused then remove them.
Also note the change in the definition of
let identity_verifications : [cst_IdentityVerification?]?
As I have removed the CodingKeys enum I have changed the property name to the same as the json key (but note my final paragraph about this, and why you might want to revert it).
The json sructure here is a non optional array with an optional element, so they type held by the array needs to be optional. The array itself also needs to be optional as you are using decodeIfPresent, so it needs to be able to accept nil if there is no entry for it in the json.
Finally the third tier in the json that isn't being handled is the entry for identity_card. To support this will need an appropriate type:
struct cst_IdentityCard: Codable {
let first_name: String
let middle_name: String
let last_name: String
let localized_first_name: String
let localized_middle_name: String
let localized_last_name: String
let identity_card_number_last_digits: String
let date_of_birth: String
let date_of_birth_calendar_type: String
}
Once all these components are in place, you can decode the Wrapper type, and then extract the data you want from its data field:
let decoder = JSONDecoder()
let jsonData = json.data(using: .utf8)!
do {
let output = try decoder.decode(Wrapper.self, from: jsonData)
print(output)
} catch {
print(error)
}
Doing this gives a successful decoding, with the output being:
Wrapper(data: __lldb_expr_12.cst_Value(address: nil, employment: nil,
income: Optional([]), usage: nil, identityVerification: nil, customer_id:
Optional("fb5056fe-d7cf-4b5e-3e32-08d9568a3822"), source:
Optional("self"), type: Optional("customer"), language: Optional("en"), email: nil, phone_number: nil, identity_card:
Optional(__lldb_expr_12.cst_IdentityCard(first_name: "abdulrahman",
middle_name: "ahmed", last_name: "ali", localized_first_name:
"abdulrahman", localized_middle_name: "ahmed", localized_last_name: "ali",
identity_card_number_last_digits: "4416", date_of_birth: "1994-05-
15T00:00:00", date_of_birth_calendar_type: "gregorian")),
is_identity_verification_complete: Optional(false), is_address_complete:
Optional(false), is_income_complete: Optional(false), is_usage_complete:
Optional(false), is_employment_complete: Optional(false), status: nil))
Note there are a lot of nil values in here still as many of the fields are not defined in the json.
If you wanted you could then process this into a flattened data structure.
While involving more data types, this approach is a lot simpler to code and manage as Decodable is doing most of the work for you and you don't have to worry about the CodingKeys or init(decoder:)
One other thing you may want to consider is reintroducing the CodingKeys enum and use this to map more 'Swifty' property names to the json keys.