मोया/अलामोफायर - यूआरएल एन्कोडेड पैराम्स एक ही कुंजी के साथ

Question

मैं MoyaAlamofire के शीर्ष पर निर्मित नेटवर्किंग परत के लिए स्विफ्ट फ्रेमवर्क का उपयोग कर रहा हूं।

वर्तमान में, मैं यूआरएल एन्कोडेड पैरामीटर के साथ अनुरोध भेजने की कोशिश कर रहा हूं जिसमें एक ही कुंजी है।

अर्थात http://some-site/request?param=v1&param=v2&param=v3

मैं पहले से ही समूह के लिए कोशिश की है इस तरह कुछ भी नहीं है लेकिन सेट या NSSet या सरणी में इन पैरामीटर वांछित परिणाम प्राप्त करने में मदद करता है।

["param": ["v1", "v2", "v3"]];

["param": Set(arrayLiteral: "v1", "v2", "v3")]

कोई मदद या तो मोया के साथ या Alamofire के साथ ही की सराहना की जाएगी।

संपादित करें:

एपीआई रूटर सेटअप

import Moya 

// MARK:- Enum Declaration 

enum ApiRouter { 
    case XAuth(login: String, password: String) 
    case SomeRequest(params: [String]) 
} 

// MARK:- Moya Path 

extension ApiRouter: MoyaPath { 
    var path: String { 
     switch self { 
     case .XAuth: 
      return "/authorization" 
     case .SomeRequest: 
      return "/some-request" 
     } 
    } 
} 

// MARK:- Moya Target 

extension ApiRouter: MoyaTarget { 
    private var base: String { 
     return "http://some-site" 
    } 
    var baseURL: NSURL { 
     return NSURL(string: base)! 
    } 

    var parameters: [String: AnyObject] { 
     switch self { 
     case .XAuth(let login, let password): 
      return [ 
       "email": login, 
       "password": password 
      ] 
     case .SomeRequest(let params): 
      return [ 
       "params": params 
      ] 
    } 

    var method: Moya.Method { 
     switch self { 
     case .XAuth: 
      return .POST 
     case .SomeRequest, 
      return .GET 
     } 
    } 

    var sampleData: NSData { 
     switch self { 
     case .XAuth: 
      return "{}".dataUsingEncoding(NSUTF8StringEncoding) 
     case .ServiceRequests: 
      return "{}".dataUsingEncoding(NSUTF8StringEncoding) 
     } 
    } 
} 

एपीआई प्रदाता सेटअप

let endpointsClosure = { (target: ApiRouter) -> Endpoint<ApiRouter> in 
    let endpoint = Endpoint<ApiRouter>(
     URL: target.baseURL.URLByAppendingPathComponent(target.path).absoluteString!, 
     sampleResponse: EndpointSampleResponse.Success(200, { target.sampleData }), 
     method: target.method, 
     parameters: target.parameters, 
     parameterEncoding: parameterEncoding(target) 
    ) 
    switch target { 
    case .XAuth: 
     return endpoint 
    default: 
     let token = "some-token" 
     return endpoint.endpointByAddingHTTPHeaderFields(["Authorization": "Bearer: \(token)"]) 
    } 
} 

func parameterEncoding(target: ApiRouter) -> Moya.ParameterEncoding { 
    switch target { 
    case .XAuth: 
     return .JSON 
    case .SomeRequest: 
     return .URL 
    } 
} 

let apiProvider = MoyaProvider(endpointsClosure: endpointsClosure) 

apiProvider.request(ApiRouter.SomeRequest(params: ["v1", "v2", "v3"], completion: { (data, statusCode, response, error) in 
    /* ... */ 
}) 

धन्यवाद: यहाँ मूल विचार देने के लिए कुछ नमूना कोड है।

Answer 1

तो मुझे एक समाधान मिला जो वास्तव में बहुत सरल और स्पष्ट है।

के बाद से वहाँ कैसे संग्रह प्रकार सांकेतिक शब्दों में बदलना करने के लिए कोई प्रकाशित विनिर्देश है, Alamofire [] (जोड़कर सरणी मूल्यों के लिए कुंजी के लिए foo [] = 1 & के सम्मेलन इस प्रकार है: पढ़ना Alamofire के प्रलेखन मैं इस पाया foo [] = 2), और नेस्टेड शब्दकोश मानों के लिए स्क्वायर ब्रैकेट से घिरी कुंजी को जोड़ना (foo [bar] = baz)।

तो, यह मामलों के लिए वहाँ कस्टमParameterEncoding विकल्प जो बंद है जहाँ आप वास्तव में कैसे आप मापदंडों का गठन किया जा करना चाहते हैं की अपनी खुद की कार्यान्वयन निर्दिष्ट कर सकते हैं लगता है।

Here एक ही प्रश्न के साथ एक ही प्रश्न है।

Answer 2

आप सरल स्ट्रिंग प्रारूप का उपयोग कर बना सकते हैं और एक अनुरोध यूआरएल के रूप में यह पारित कर सकते हैं:

http://some-site/request?param=v1&param=v2&param=v3

String url: String = String(format: "http://some-site/request?param=%@&param=%@&param=%@", v1, v2, v3) 

आशा इस मदद करता है!

Answer 3

मोया एक अच्छा विचार है, लेकिन मुझे वास्तव में लगता है कि कुछ सोच के साथ, हम बिना किसी कोड के स्विफ्ट का उपयोग करके नेटवर्क एब्स्ट्रक्शन लेयर का निर्माण कर सकते हैं।

हमारा लक्ष्य है:

• लचीलापन, संपादित करने या नई अंतिमबिंदुओं कुशलतापूर्वक
• पठनीयता, जोड़ने एक नज़र
• कोड सुरक्षा में कैसे हमारे एपीआई काम का एक अच्छा विचार है करने के लिए करने में सक्षम हो, टाइप किए गए पैरामीटर के साथ सभी प्री-संकलन भलाई (समापन, सत्यापन) की अनुमति देने के लिए हम एक्सकोड से अपेक्षा करते हैं।
• आसान डीबगिंग, जिसका अर्थ है से पहले और वेब के बाद लॉग डालने का तो अनुरोध करता

यहाँ है कि मैं क्या साथ dummy project एक पर समाप्त हो गया है:

public class API { 

public static let baseURL: String = "http://colourlovers.com/api" 

public enum Endpoints { 

    case Colors(String) 
    case Palettes(String) 
    case Patterns(String) 

    public var method: Alamofire.Method { 
     switch self { 
     case .Colors, 
      .Palettes, 
      .Patterns: 
      return Alamofire.Method.GET 
     } 
    } 

    public var path: String { 
     switch self { 
     case .Colors: 
      return baseURL+"/colors" 
     case .Palettes: 
      return baseURL+"/palettes" 
     case .Patterns: 
      return baseURL+"/patterns" 
     } 
    } 

    public var parameters: [String : AnyObject] { 
     var parameters = ["format":"json"] 
     switch self { 
     case .Colors(let keywords): 
      parameters["keywords"] = keywords 
      break 
     case .Palettes(let keywords): 
      parameters["keywords"] = keywords 
      break 
     case .Patterns(let keywords): 
      parameters["keywords"] = keywords 
      break 
     } 
     return parameters 
    } 
} 

public static func request(
    endpoint: API.Endpoints, 
    completionHandler: Response<AnyObject, NSError> -> Void) 
    -> Request { 

     let request = Manager.sharedInstance.request(
      endpoint.method, 
      endpoint.path, 
      parameters: endpoint.parameters, 
      encoding: .URL, 
      headers: nil 
      ).responseJSON { response in 

       if (response.result.error) != nil { 
        DDLogError("\n<----\n" + response.result.error!.description) 
        completionHandler(response) 
       } else { 
        DDLogInfo("\n<----\n" + response.response!.description) 
        completionHandler(response) 
       } 
     } 
     DDLogInfo("\n---->\n" + request.description) 
     return request 
    } 
}