- It supports all HTTP request methods i.e GET, POST, PUT and DELETE
- It supports multipart requests for uploading data to your server
- It provides three methods for calling an HTTP request methods,
- request
- You will get JSONTopModel as response of this method. You can parse it as per your need
- requestForObject
- You will get the auto-mapped object as response of this method. You just need to send the mapperClass in request parameter
- requestForArray
- You will get the auto-mapped array of objects as response of this method. You just need to send the mapperClass in request parameter
- request
- It provides three same methods for multipart API calls
- It allows you to make your API call authorized with only one Boolean parameter "authorized"
- It gives you the flexibility for server error handling
- It will handle the serialization errors of responses for all API calls by its own
- Protocol Oriented Networking manager
- Provides you the shared implementation of all HTTP and multipart request method
- Allows you to provide the custom implementation of any request method defined in the Routable protocol
- Highly structured with Abstraction and Namespacing techniques
CocoaPods is a dependency manager for Cocoa projects. You can install it with the following command:
$ gem install cocoapodsTo integrate NBUtility into your Xcode project using CocoaPods, specify it in your Podfile:
source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '9.0'
use_frameworks!
target '<Your Target Name>' do
pod 'NBUtility'
endThen, run the following command:
$ pod install- It is a protocol oriented network manager which has the following features
- All network calls will parse its responses with JSONTopModel as base class. You can find its implementation in
Routable.swift
- Create a
ServiceManager.swiftfile in your Xcode project
- Create an
enum Endpointto add app specific end points. Conform it with Directable to make directable urls from your end points. - It should look like following example,
enum Endpoint: Directable {
// Setup the base Url of your application according to the application mode
static var baseUrl: String {
var baseUrl = ""
switch appMode {
case .test:
baseUrl = "http://apidev.accuweather.com/currentconditions"
case .production:
baseUrl = "http://apidev.accuweather.com/currentconditions"
}
return baseUrl
}
// Define some endpoints like this,
case weatherConditions,
countryList
// Implement the protocol method to make your app specific end points fully directable as Url
func directableURLString() -> String {
var servicePath = ""
switch (self) {
case .weatherConditions:
servicePath = "get-weather-conditions"
case .countryList:
servicePath = "get-countries-data"
}
let tail = "api"
return Endpoint.baseUrl + "/" + tail + "/" + servicePath
}
}- Create a class to manage your API calls
class ServiceManagerand conform it withprotocol Routable - It should look like following example,
class ServiceManager: Routable {
// You need to implement this method to send App specific headers with your API calls
func authorizationHeadersIf(_ authorized: Bool) -> [String : String]? {
// You can send Open Auth Token, Appversion, API version and many more as per your need
return ["app-version":"1.0"]
}
// You need to implement this method to validate the error of your server and you can take many decisions here with server's error status code
func handleServerError(_ result: DataResponse<JSONTopModal>, failure: FailureErrorBlock!) -> Bool {
let resultValue = result.value!
if resultValue.isError {
if resultValue.statusCode == -1 {
// handleTokenError(resultValue.message)
}
else {
failure(NSError(errorMessage: resultValue.message, code: resultValue.statusCode))
}
return true
}
return false
}
}-
In your controllers, you can use the
ServiceManagerto manage your network calls -
Example for a simple API call is given below,
fileprivate let manager:ServiceManager = ServiceManager()
manager.request(.get, service: Endpoint.countryList, success: { (response, jsonTopModelResult) in
print("proceed with your jsonTopModelResult")
}, failure: { (error) in
print("Handle error")
})- Add "authorized" Boolean perameter in the same API call to add authorized headers
manager.request(.get, service: Endpoint.countryList, authorized: true, success: { (response, jsonTopModelResult) in
print("proceed with your jsonTopModelResult")
}, failure: { (error) in
print("Handle error")
})- Get the Countries list (Array of custom objects) auto-mapped with the help of Routable protocol
manager.requestForArray(.get, service: Endpoint.countryList, mapperClass: Country.self, success: { (response, countries) in
print("proceed with your countries list")
}, failure: { (error) in
print("Handle error")
})- Get the Weather Conditions (Custom object) auto-mapped with the help of Routable protocol
manager.requestForObject(.get, service: Endpoint.weatherConditions, mapperClass: WeatherCondition.self, success: { (response, weatherConditions) in
print("proceed with your weather Conditions")
}, failure: { (error) in
print("Handle error")
})- Same API calls can be user as multipart request for uploading data to your server. Use the multipart request methods of Routable protocol.
NBUtility is available under the MIT license. See the LICENSE file for more info.
Fahid Attique - (https://github.com/fahidattique55)
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent