From b129eee4832d56ce666c324fc66a4f153ae49ee0 Mon Sep 17 00:00:00 2001
From: Ivan Smolin <ivan.smolin@touchin.ru>
Date: Fri, 30 Dec 2016 08:24:59 +0300
Subject: [PATCH] mapping queue

---
 .../AlamofireManager+Extensions.swift         | 14 +++++++-----
 .../AlamofireRequest+Extensions.swift         | 22 +++++++++++--------
 2 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/LeadKit/LeadKit/Extensions/Alamofire/AlamofireManager+Extensions.swift b/LeadKit/LeadKit/Extensions/Alamofire/AlamofireManager+Extensions.swift
index f44856a3..0dadeb93 100644
--- a/LeadKit/LeadKit/Extensions/Alamofire/AlamofireManager+Extensions.swift
+++ b/LeadKit/LeadKit/Extensions/Alamofire/AlamofireManager+Extensions.swift
@@ -28,21 +28,25 @@ public extension Reactive where Base: Alamofire.SessionManager {
     /// Method which executes request and serializes response into target object
     ///
     /// - Parameter requestParameters: api parameters to pass Alamofire
+    /// - Parameter mappingQueue: The dispatch queue to use for mapping
     /// - Returns: Observable with HTTP URL Response and target object
-    func responseModel<T: ImmutableMappable>(requestParameters: ApiRequestParameters) -> Observable<(HTTPURLResponse, T)> {
+    func responseModel<T: ImmutableMappable>(requestParameters: ApiRequestParameters,
+                       mappingQueue: DispatchQueue = DispatchQueue.global()) -> Observable<(HTTPURLResponse, T)> {
         return apiRequest(requestParameters: requestParameters)
-            .flatMap { $0.rx.apiResponse() }
+            .flatMap { $0.rx.apiResponse(mappingQueue: mappingQueue) }
     }
 
     /// Method which executes request and serializes response into target object
     ///
     /// - Parameter requestParameters: api parameters to pass Alamofire
+    /// - Parameter mappingQueue: The dispatch queue to use for mapping
     /// - Returns: Observable with HTTP URL Response and target object
-    func responseObservableModel<T: ObservableMappable>(requestParameters: ApiRequestParameters) ->
-        Observable<(HTTPURLResponse, T)> where T.ModelType == T {
+    func responseObservableModel<T: ObservableMappable>(requestParameters: ApiRequestParameters,
+                                 mappingQueue: DispatchQueue = DispatchQueue.global()) -> Observable<(HTTPURLResponse, T)>
+        where T.ModelType == T {
 
         return apiRequest(requestParameters: requestParameters)
-            .flatMap { $0.rx.apiResponse() }
+            .flatMap { $0.rx.apiResponse(mappingQueue: mappingQueue) }
     }
 
 }
diff --git a/LeadKit/LeadKit/Extensions/Alamofire/AlamofireRequest+Extensions.swift b/LeadKit/LeadKit/Extensions/Alamofire/AlamofireRequest+Extensions.swift
index 3477163d..1b1035f0 100644
--- a/LeadKit/LeadKit/Extensions/Alamofire/AlamofireRequest+Extensions.swift
+++ b/LeadKit/LeadKit/Extensions/Alamofire/AlamofireRequest+Extensions.swift
@@ -15,33 +15,37 @@ public extension Reactive where Base: DataRequest {
 
     /// Method which serializes response into target object
     ///
-    /// - Parameter mappingQueueQoS: QoS of underlying scheduler queue on which mapping will be executed
+    /// - Parameter mappingQueue: The dispatch queue to use for mapping
     /// - Returns: Observable with HTTP URL Response and target object
-    func apiResponse<T: ImmutableMappable>(mappingQueueQoS: DispatchQoS = .default) -> Observable<(HTTPURLResponse, T)> {
-        return responseJSON()
+    func apiResponse<T: ImmutableMappable>(mappingQueue: DispatchQueue = DispatchQueue.global())
+        -> Observable<(HTTPURLResponse, T)> {
+
+        return responseJSONOnQueue(mappingQueue)
             .map { resp, value in
                 let json = try cast(value) as [String: Any]
 
                 return (resp, try T(JSON: json))
             }
-            .subscribeOn(ConcurrentDispatchQueueScheduler(qos: mappingQueueQoS))
     }
 
     /// Method which serializes response into target object
     ///
-    /// - Parameter mappingQueueQoS: QoS of underlying scheduler queue on which mapping will be executed
+    /// - Parameter mappingQueue: The dispatch queue to use
     /// - Returns: Observable with HTTP URL Response and target object
-    func apiResponse<T: ObservableMappable>(mappingQueueQoS: DispatchQoS = .default) -> Observable<(HTTPURLResponse, T)>
-        where T.ModelType == T {
+    func apiResponse<T: ObservableMappable>(mappingQueue: DispatchQueue = DispatchQueue.global())
+        -> Observable<(HTTPURLResponse, T)> where T.ModelType == T {
 
-        return responseJSON()
+            return responseJSONOnQueue(mappingQueue)
             .flatMap { resp, value -> Observable<(HTTPURLResponse, T)> in
                 let json = try cast(value) as [String: Any]
 
                 return T.createFrom(map: Map(mappingType: .fromJSON, JSON: json))
                     .map { (resp, $0) }
-                    .subscribeOn(ConcurrentDispatchQueueScheduler(qos: mappingQueueQoS))
             }
     }
 
+    internal func responseJSONOnQueue(_ queue: DispatchQueue) -> Observable<(HTTPURLResponse, Any)> {
+        return responseResult(queue: queue, responseSerializer: DataRequest.jsonResponseSerializer(options: .allowFragments))
+    }
+
 }