how_to_use.txt

NetworkService.instance
  .requestObject(.auth(email: "", password: ""), mappableClass: ErrorResponse.self)
  .subscribe(onNext: { (response) in
    guard let `response` = response else { return }
    switch response {
    case .success(let data):
      print(data)
    case .error(let error):
      guard let `error` = error else { return }
      print(error.error)
    }
  }, onError: { (error) in
    print(error)
  })
  .disposed(by: disposeBag)

NetworkService.swift

//
//  NetworkService.swift
//  PKBPartyKit
//
//  Created by alfian0 on 2/6/18.
//  Copyright © 2018 Extra Integer. All rights reserved.
//

import ObjectMapper
import Moya
import RxSwift

enum BaseResponse {
    case success(data: Mappable?)
    case error(error: ErrorResponse?)
}

struct NetworkService: INetworkService {
    
    static let instance = NetworkService()
    fileprivate let disposeBag = DisposeBag()
    fileprivate let provider: MoyaProvider<NetworkAPI>
    
    private init() {
        self.provider = MoyaProvider<NetworkAPI>(
            plugins: [
                RequestLoadingPlugin()
            ]
        )
    }
}

extension NetworkService {
    
    internal func requestObject(_ token: NetworkAPI, mappableClass: Mappable.Type? = nil) -> Observable<BaseResponse?> {
        
        return Observable.create({ (observer) -> Disposable in
            return self.provider.rx.request(token)
                .filterSuccessfulStatusCodes()
                .subscribeOn(ConcurrentDispatchQueueScheduler(qos: .background))
                .subscribe { event in
                    switch event {
                    case .success(let response):
                        
                        // Check mappableClass is not nil
                        // mappableClass is model
                        guard let mappableClass = mappableClass else {
                            observer.onNext(nil)
                            observer.onCompleted()
                            return
                        }
                        
                        do {
                            // First we need map response to JSON
                            // Parse json to get success status
                            // If we are not getting success status throw NetworkError.IncorrectDataReturned
                            guard let jsonResponse = try response.mapJSON() as? [String: Any] else {
                                observer.onError(NetworkError.IncorrectDataReturned)
                                return
                            }
                            
                            // Map jsonData to ObjectMapper format
                            let map = Map(mappingType: .fromJSON, JSON: jsonResponse)
                            
                            if let statusCode = response.response?.statusCode, (statusCode >= 200 && statusCode < 300) {
                                guard let modelObject = mappableClass.init(map: map) else {
                                    observer.onError(NetworkError.IncorrectDataReturned)
                                    return
                                }
                                observer.onNext(.success(data: modelObject))
                                observer.onCompleted()
                            } else {
                                guard let errorResponse = ErrorResponse.init(map: map) else {
                                    observer.onError(NetworkError.IncorrectDataReturned)
                                    return
                                }
                                observer.onNext(.error(error: errorResponse))
                                observer.onCompleted()
                            }
                        } catch {
                            observer.onError(NetworkError.IncorrectDataReturned)
                        }
                        break
                    case .error(let error):
                        if let error = error as? MoyaError {
                            do {
                                guard let json = try error.response?.mapJSON() as? [String: Any] else {
                                    observer.onError(NetworkError.IncorrectDataReturned)
                                    return
                                }
                                let map = Map(mappingType: .fromJSON, JSON: json)
                                guard let errorResponse = ErrorResponse.init(map: map) else {
                                    observer.onError(NetworkError.IncorrectDataReturned)
                                    return
                                }
                                observer.onNext(.error(error: errorResponse))
                            } catch {
                                observer.onError(NetworkError(error: error as NSError))
                            }
                        } else {
                            observer.onError(NetworkError(error: error as NSError))
                        }
                    }
            }
        })
    }
}