Alamofire generalize request

Question

I am using Almofire for all my requests and works fine. I need to know how to generalize all requests to handle all errors at one place.

func updateSettingValue(group : String , value: String , callback: @escaping (SettingsResponseModel) -> Void, errorCallback: @escaping (Error) ->Void)
{        
    let url = BASE_URL_PROD + API_SETTINGS
    let settingsParams : Parameters = ["Setting" : group , "Tag" : value]

    Alamofire.request(url, method: .put, parameters: settingsParams,  headers: getHeader()).responseObject {
        (response: DataResponse< SettingsResponseModel>) in
        switch response.result {
        case .success:
            print("response \(response)")
            DispatchQueue.main.async {
                callback(response.result.value!)
            }
            break
        case .failure(let error):
            print(error)
            errorCallback(error)
        }
    }
}



func releaseKeys(mKey: String ,callback:  @escaping (ReleaseKeyModel) -> Void
    , errorCallback: @escaping (Error) -> Void){

    let url = BASE_URL_PROD + API_RELEASE_KEY

    let params: Parameters = ["mKey" : mKey]
    Alamofire.request(url, method: .delete, parameters: params, encoding: URLEncoding.default, headers: getHeader()).responseObject{
        (response : DataResponse< ReleaseKeyModel >) in
        print("releaseKey: \(response) ")

        switch response.result {
        case .success:
            DispatchQueue.main.async {
                callback(response.result.value!)
            }
            break
        case .failure(let error):
            print(error)
            errorCallback(error)
        }
    }
}

How can I generalize this to take parameters for Mapping Model class in DataResponse so that I don't have to handle success and failure case individually for all methods.

Answer 1

You can divide the work with the server into 2 classes:

1) class RestClient

import Foundation

typealias responseBlock = (_ swiftObj: Any?, _ error: Error?) -> Void

class RestClient: NSObject {

    static let shared = RestClient()
    private var http = HttpService()

    func updateSettingValue(group: String, value: String, resp: @escaping responseBlock) {

        let url = BASE_URL_PROD + API_SETTINGS

        let params = ["Setting": group, "Tag": value]

        http.reque(url, method: .put, parameters: params, headers: getHeader(), resp: { (value, error) in

            if let err = error {
                return resp(nil, err)
            }

            guard let data = value else {
                return resp(nil, error)
            }

            //your method for parse data
            self.parseData(respData: data,
                           modelCls: SettingsResponseModel.self,
                           response: resp)
        })
    }

    func releaseKeys(mKey: String, resp: @escaping responseBlock) {

        let url = BASE_URL_PROD + API_RELEASE_KEY

        let params = ["mKey": mKey]

        http.reque(url, method: .delete, parameters: params, encoding: URLEncoding.default, headers: getHeader(), resp: { (value, error) in

            if let err = error {
                return resp(nil, err)
            }

            guard let data = value else {
                return resp(nil, error)
            }

            //your method for parse data
            self.parseData(respData: data,
                           modelCls: ReleaseKeyModel.self,
                           response: resp)
        })
    }

}

2) class HttpService

class HttpService {

    func reque(_ url: URLConvertible,
               method: HTTPMethod = .get,
               parameters: Parameters? = nil,
               encoding: ParameterEncoding = URLEncoding.default,
               headers: HTTPHeaders? = nil,
               queue: QueueQos = .defaultQos,
               resp: @escaping responseBlock) {

        Alamofire.request(url,
                          method: method,
                          parameters: parameters,
                          encoding: encoding,
                          headers: headers
            ).responseObject (queue: queue) { (response) in

                switch response.result {
                case .success:

                    if let jsonResp = response.result.value {

                        //You can also check out some error messages at this place.

                        resp(jsonResp, nil)
                    }

                case .failure(let error):
                    resp(nil, error)
                }
        }
    }

}

Answer 2

Try this, using generics

func releaseKeys<T: Codable>(parameters params: [String: Any], callback:  @escaping (T) -> Void
, errorCallback: @escaping (Error) -> Void){

    Alamofire.request(url, method: .delete, parameters: params, encoding: URLEncoding.default, headers: getHeader()).responseObject{
        (response : DataResponse< T >) in
        print("releaseKey: \(response) ")

        switch response.result {
        case .success:
            DispatchQueue.main.async {
                callback(response.result.value!)
            }
            break
        case .failure(let error):
            print(error)
            errorCallback(error)
        }
    }
}