 
 private extension SYDataRequest {
     
-    func generateValidationFailureError(_ serverError: Error?) -> AFError {
-        if let sError = serverError {
-            let reason = AFError.ResponseValidationFailureReason.customValidationFailed(error: sError)
-            let afError = AFError.responseValidationFailed(reason: reason)
-            return afError
-        }
-        enum ValidationStatusCode: Int {
-            case invalid = -1
-        }
-        let requestValidationErrorDomain = "com.synetwork.request.validation"
-        let validationFailureDescription = "Validation failure"
-        
-        let e = NSError(domain: requestValidationErrorDomain, code: ValidationStatusCode.invalid.rawValue, userInfo: [NSLocalizedDescriptionKey: validationFailureDescription])
-        let reason = AFError.ResponseValidationFailureReason.customValidationFailed(error: e)
-        let error = AFError.responseValidationFailed(reason: reason)
-        return error
-    }
+//    func generateValidationFailureError(_ serverError: Error?) -> Error {
+//        if let sError = serverError {
+//            let reason = AFError.ResponseValidationFailureReason.customValidationFailed(error: sError)
+//            let afError = AFError.responseValidationFailed(reason: reason)
+//            return afError
+//        }
+//        enum ValidationStatusCode: Int {
+//            case invalid = -1
+//        }
+//        let requestValidationErrorDomain = "com.synetwork.request.validation"
+//        let validationFailureDescription = "Validation failure"
+//
+//        let e = NSError(domain: requestValidationErrorDomain, code: ValidationStatusCode.invalid.rawValue, userInfo: [NSLocalizedDescriptionKey: validationFailureDescription])
+//        let reason = AFError.ResponseValidationFailureReason.customValidationFailed(error: e)
+//        let error = AFError.responseValidationFailed(reason: reason)
+//        return error
+//    }
     
     func requestFilter<T,U>(_ response: DataResponse<T,U>, shouldSaveCache: Bool = false) {
         switch response.result {

                    loadCache(responseObject: cacheResponse)
                    let isSendRequest = customCacheRequest.shouldSendRequest(self, cacheResponse: cacheResponse)
                    if isSendRequest {
                        self.request?.validate().responseObject(queue: self.responseQueue, keyPath: self.responseObjectKeyPath, mapToObject: object, context: self.responseObjectContext, completionHandler: { objectResponse in
                            let isUpdateCache = customCacheRequest.shouldUpdateCache(self, response: objectResponse)
                            if isUpdateCache {
                                var response = objectResponse
                                switch response.result {
                                case .success(let obj):
                                    let validate = self.validateResponseWhenRequestSuccess(obj)
                                    if !validate.0 {
                                        response = generateValidateFailResponse(response, serverError: validate.1)
                                    }
                                case .failure(_):
                                    break
                                }
                                self.requestFilter(response, shouldSaveCache: true)
                                completionHandler(false,response)
                            }
                        })
                    }

            completionHandler(true,responseSwiftyJSON)
        }
        
        func validateResponse(request:URLRequest?, response:HTTPURLResponse, data:Data?) -> DataRequest.ValidationResult {
            do {
                let json = try SwiftyJSONResponseSerializer().serialize(request: request, response: response, data: data, error: nil)
                let dataResponse = DataResponse<JSON, AFError>(request: request, response: response, data: data, metrics: nil, serializationDuration: 0, result: .success(json))
                let validate = self.validateResponseWhenRequestSuccess(dataResponse.value)
                guard let error = validate.1 else {
                    return .success(Void())
                }
                if validate.0 {
                    return .success(Void())
                }
                return .failure(error)
            } catch let e {
                return .failure(e)
            }
        }

        func responseSwiftyJSONFromRequest() {
            self.request?.validate({ (request:URLRequest?, response:HTTPURLResponse, data:Data?) -> DataRequest.ValidationResult in
                validateResponse(request: request, response: response, data: data)
            }).responseSwiftyJSON(queue: self.responseQueue, options: self.responseJSONOptions, completionHandler: { swiftyJSONResponse in
                self.requestFilter(swiftyJSONResponse, shouldSaveCache: true)
                completionHandler(false,swiftyJSONResponse)
            })
        }
        
        switch responseDataSource {
        case .server:
            responseSwiftyJSONFromRequest()
        case .cacheIfPossible:
            self.responseSwiftyJSONFromCache(completionHandler: { (loadCacheData: () throws -> DataResponse<JSON,AFError>) in
                do {
