otbivnoe / codablealamofire Goto Github PK

extension DateFormatter {
    static let apiDateFormatter: DateFormatter = {
        let formatter = DateFormatter()
        //2019-08-05T08:41:06.590Z
        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZ"
        return formatter
    }()
}

let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .formatted(.apiDateFormatter)

Alamofire.request(url, method: method, parameters: parameters, encoding: encoding, headers: headers)
    .responseDecodableObject(decoder: decoder) { (response: DataResponse<T>) in
        let data = response.data
}

...alamofireRequest.responseDecodableObject(
    queue: nil, 
    keyPath: nil, 
    decoder: JSONDecoder()) { 
        (resp: DataResponse<GenralResponse<FlexibleValue>>) in
        logger.verbose(resp)
}

struct FlexibleValue: Decodable {
    var role: [String]
}

struct GeneralResponse<T: Decodable>: Decodable  {
    struct Head: Decodable {
        let version: String
        let msgtype: String
        let interface: String
        let remark: String
    }
    struct Body: Decodable {
        let ret: String
        let retcode: String
        let retinfo: String
        let data: T?
    }
    let head: Head
    let body: Body
}

    var id:        String
    var owner_id:  String
    var name:      String
    var active:    Bool?
    var share:     Bool?
    var date:      Int?
    var duration:  Int
    
    typealias DownloadComplete = () -> ()
}

extension ActiveChannelHangouts {
    static func from(json: String, using encoding: String.Encoding = .utf8) -> ActiveChannelHangouts? {
        guard let data = json.data(using: encoding) else { return nil }
        return ActiveChannelHangouts.from(data: data)
    }
    
    static func from(data: Data) -> ActiveChannelHangouts? {
        let decoder = JSONDecoder()
        do {
            return try decoder.decode(ActiveChannelHangouts.self, from: data)
        } catch  {
            print(error.localizedDescription)
            return nil
        }
    }
    
    var jsonData: Data? {
        let encoder = JSONEncoder()
        do {
            return try encoder.encode(self)
        } catch {
            print(error.localizedDescription)
            return nil
        }
    }
    
    var jsonString: String? {
        guard let data = self.jsonData else { return nil }
        return String(data: data, encoding: .utf8)
    }
    
}

extension ActiveChannelHangouts {
    enum CodingKeys: String, CodingKey {
        case id       = "id"
        case ownerId  = "ownerId"
        case name     = "name"
        case active   = "active"
        case share    = "share"
        case date     = "date"
        case duration = "duration"
    }
}

// from my APIClient struct trying to call this method 
func responseDecodableObject<T: Decodable>(url: String, queue: DispatchQueue? = nil,
                                               keyPath: String? = nil,
                                               decoder: JSONDecoder = JSONDecoder(),
                                               completionHandler: @escaping (DataResponse<T>) -> Void) {
        if !PerfectLocalAuth.sessionid.isEmpty {
            Alamofire.request(url).responseDecodableObject(queue: PerfectLocalAuth.setHeaders(), keyPath: keyPath, decoder: decoder) {
                (response: DataResponse<[T]>) in
                let repo = response.result.value
                print(repo)
            }
            
        }
    }