PromiseKit + Alamofire

PromiseKit+Alamofire.swift

import PromiseKit
import Alamofire

enum HttpHeaders: String {
    case authorization = "Authorization"
}

enum BearerToken: String {
    case title = "Bearer "
}

enum ApiVersions: String {
    case title = "ApiVersion"
}

public enum MicroServicesAPI {
    case ClientServices
    case ClientDebugServices
}

public enum ApiVersionAPI {
    case versionV1_0
}

//APIManager
public class APIServiceManager {
    
    /**
     Base Http Request Generator
     - Parameter url: 請求資源位置
     - Parameter parameters: Parameters
     - Parameter method: HTTPMethod
     - Parameter encoding: URLEncoding
     */
    public func requestGenerator(route: APIServicesURLProtocol, parameters: Parameters? = nil,
                                 method: HTTPMethod = .get, encoding: ParameterEncoding = URLEncoding.default,
                                 microServicesAPI: MicroServicesAPI = .ClientServices) -> DataRequest {
        
        var url = ""
        
        switch microServicesAPI {
        case .ClientServices:
            url = ServicesURL.baseURL
        case .ClientDebugServices:
            url = ServicesURL.debugURL
        }
        
        url += route.url
       
        var headers = HTTPHeaders()

        if let currectToken = AuthManager.shared.currectToken {
            
            headers.update(name: HttpHeaders.authorization.rawValue, value: BearerToken.title.rawValue + currectToken)
        
            RentLogger.shared.info("📝 API Parameters body: 📝\n \(String(describing: parameters))")
            return AF.request(url,
                              method: method,
                              parameters: parameters,
                              encoding: encoding,
                              headers: headers) { (req) in
                req.timeoutInterval = Config.REQUEST_TIMEOUT
            }
            
        } else {
            
            return AF.request(
                url,
                method: method,
                parameters: parameters,
                encoding: encoding,
                headers: headers
            )
        }
        
    }
    
    /**
     Base API Producer
     - Parameter dataRequest: 請求數據
     - Parameter type: 回應模型
     - Returns: Promise.
     */
    public func setupResponse<T: Codable>(_ dataRequest: DataRequest, type: T.Type) -> Promise<T> {
        return Promise<T>.init(resolver: { (resolver) in
            dataRequest.validate().responseJSON(queue: DispatchQueue.global(qos: .utility), options: JSONSerialization.ReadingOptions.mutableContainers, completionHandler: { (response) in
            
                RentLogger.shared.info("✅ Response setupResponse Value: ✅\n \(response.value ?? "")")
                RentLogger.shared.info("🌐 Response API URL: 🌐\n \(response.request?.debugDescription ?? "")")
                
                let apiName = response.request?.debugDescription.replacingOccurrences(of: Config.BASE_URL, with: "") ?? ""
                
                switch response.result {
                
                case .success(let json):
                    do {
                        let decoder: JSONDecoder = JSONDecoder()
                        let jsonData = try JSONSerialization.data(withJSONObject: json, options: .prettyPrinted)
                        let content = try decoder.decode(T.self, from: jsonData)
                        resolver.fulfill(content)
                    } catch let error {
                        resolver.reject(error)
                    }
                    
                case .failure(let aferror):
              
                    switch (aferror) {
                    case .invalidURL:
                        resolver.resolve(nil, aferror)
                    case .parameterEncodingFailed:
                        resolver.resolve(nil, aferror)
                    case .multipartEncodingFailed:
                        resolver.resolve(nil, aferror)
                    case .responseValidationFailed:
                        resolver.resolve(nil, aferror)
                    case .responseSerializationFailed:
                        resolver.resolve(nil, aferror)
                    case .createUploadableFailed:
                        resolver.resolve(nil, aferror)
                    case .createURLRequestFailed:
                        resolver.resolve(nil, aferror)
                    case .downloadedFileMoveFailed:
                        ()
                    case .explicitlyCancelled:
                        ()
                    case .parameterEncoderFailed:
                        ()
                    case .requestAdaptationFailed:
                        ()
                    case .requestRetryFailed:
                        ()
                    case .serverTrustEvaluationFailed:
                        ()
                    case .sessionDeinitialized:
                        ()
                    case .sessionInvalidated:
                        ()
                    case .sessionTaskFailed:
                        ()
                    case .urlRequestValidationFailed:
                        ()
                    }
                    
                    resolver.reject(aferror)
                    
                    RentLogger.shared.error("❌ failure setupResponse: ❌ \(String(describing: self))")
                    RentLogger.shared.error("❌ failure setupResponse: ❌ \(aferror.localizedDescription)")
               
                }
                
            })
        }
        )
    }
}