Prześlij zdjęcie/plik z JSON i niestandardowymi nagłówkami za pośrednictwem Swift 3 i Alamofire 4 | iOS | Swift

Question

Potrzebuję wywołać żądanie Multipart z plikiem obrazu i JSON.

Próbowałem tego, ale nadal otrzymuję błąd.

// define parameters 
    let parameters = [ 
    "hometown": "yalikavak", 
    "living": "istanbul" 
    ] 

Alamofire.upload(multipartFormData: { multipartFormData in 
    if let imageData = UIImageJPEGRepresentation(image, 1) { 
     multipartFormData.append(imageData, withName: "file", fileName: "file.png", mimeType: "image/png") 
    } 

    for (key, value) in parameters { 
     multipartFormData.append((value?.data(using: .utf8))!, withName: key) 
    }}, to: "upload_url", method: .post, headers: ["Authorization": "auth_token"], 
     encodingCompletion: { encodingResult in 
      switch encodingResult { 
      case .success(let upload, _, _): 
      upload.response { [weak self] response in 
       guard let strongSelf = self else { 
       return 
       } 
       debugPrint(response) 
      } 
      case .failure(let encodingError): 
      print("error:\(encodingError)") 
      } 
    }) 
} 

Jak wysłać JSON?

Answer 1

Spróbuj ten kod dla wielu przesyłać obrazy w pojedynczym żądaniu, ten kod jest już pracuje.

 // For Pass Valid Parameters & number of Images in Array in Image Upload Function 
    var dicImgData : NSMutableDictionary? = NSMutableDictionary() 

    if let img = UIImage(named: "Your Image") { 
     if let data:Data = UIImagePNGRepresentation(img) { 
      var imageData : NSData = data 
      dicImgData! .setObject(imageData, forKey: "data" as NSCopying) 
      dicImgData! .setObject("file", forKey: "name" as NSCopying) 
      dicImgData! .setObject("file.png", forKey: "fileName" as NSCopying) 
      dicImgData! .setObject("image/png", forKey: "type" as NSCopying) 

      let dicParameter = [ 
       "hometown": "yalikavak", 
       "living": "istanbul" 
      ] 

      self.uploadImage(url: "Your URL", Parameter: dicParameter, Images: [dicImgData]) 
     } 
    } 

Prześlij Funkcja

func uploadImage (url: String, Parameter param : NSDictionary, Images arrImage: NSArray) -> Void 
    { 
     var requestURL : String! = url 
     let headers = [ 
      "Authorization": "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==", 
      "Accept": "application/json", 
      ] 

     print("---------------------") 
     print("Request URL :- \(requestURL)") 
     print("---------------------") 

     Alamofire.upload(multipartFormData: { (data) in 

      for (key, value) in param { 
       data.append((value as! String).data(using: .utf8)!, withName: key as! String) 
      } 

      for imageInfo in arrImage 
      { 
       var dicInfo : NSDictionary! = imageInfo as! NSDictionary 
       data.append(dicInfo["data"] as! Data, withName: dicInfo["name"] as! String, fileName: dicInfo["fileName"] as! String, mimeType: dicInfo["type"] as! String) 
       dicInfo = nil 
      } 

     }, to: requestURL, method: .post , headers:nil, encodingCompletion: { (encodeResult) in 
      switch encodeResult { 
      case .success(let upload, _, _): 

       upload.responseJSON(completionHandler: { (response) in 

        switch response.result 
        { 
        case .success(let responseJSON): 
         guard let dicResponse = responseJSON as? NSDictionary else{ 
          return 
         } 

         print("Response : \((dicResponse))") 

        case .failure(let error): 

         print(error) 

         break 
        } 
       }) 
      case .failure(let error): 
       print(error) 
       break 
      } 
     }) 
    } 

Answer 2

Z danych, które podałeś, dochodzę do wniosku jak podano poniżej.

Kod statusu 400 oznacza, że ​​json przekazywany do api nie był zgodny z dokumentacją API. Na przykład, jeśli oczekują klucza "nazwa" i nie otrzymasz takiego klucza w ogóle.

Inne możliwe przyczyny tego błędu.

Wydaje się, że nie mają żadnej z wymienionych typów zawartości

dodać te linijki kodu, aby zapewnić, że odpowiedź i Twój wniosek są w odpowiednich formatach

Alamofire.request(.GET, "your url", parameters: ["foo": "bar"]) 
     .validate(statusCode: 200..<300) 
     .validate(contentType: ["application/json"]) 
     .response { (_, _, _, error) in 
        println(error) 
     } 

zaakceptowanych nagłówek opowiada serwer, którego potrzebuje twój klient w odpowiedzi na . Nagłówek Content-Type informuje serwer o tym, co klient wysyła w żądaniu.

Jeśli możesz podać więcej informacji, możemy pomóc.

Answer 3

Tutaj zrobiłem moją własną usługę internetową, możesz jej użyć. Ta usługa jest przeznaczona do wysyłania słownika z obrazem i wideo lub obydwoma lub bez niego.

import Foundation 
import Alamofire 
class WebServiceHandler: AnyObject { 

    func uploadWithAlamofire(Parameters params : [NSObject : AnyObject]?,ImageParameters imgparams : [NSObject : AnyObject]?,VideoParameters vidoparam : [NSObject : AnyObject]?,Action action : NSString, success: @escaping (AnyObject) -> Void, failure: @escaping (AnyObject) -> Void) 
    { 
     var base_url = "http://benzatineinfotech.com/webservice/finder/index.php/Web_api/" 
     base_url.append(action as String) 

     Alamofire.upload(multipartFormData: { multipartFormData in 
      if imgparams != nil{ 
       for (key, value) in imgparams! { 
        if let imageData = UIImageJPEGRepresentation(value as! UIImage, 1) { 
         multipartFormData.append(imageData, withName: key as! String, fileName: "\(NSDate().timeIntervalSince1970 * 1000)).jpg", mimeType: "image/jpg") 
        } 
       } 
      } 
      if vidoparam != nil{ 
       for (key, value) in vidoparam! { 
        multipartFormData.append(value as! URL , withName: key as! String, fileName: "\(NSDate().timeIntervalSince1970 * 1000).mp4", mimeType: "application/octet-stream") 
       } 
      } 
      if params != nil 
      { 
       for (key, value) in params! { 
        multipartFormData.append((value as! String).data(using: .utf8)!, withName: key as! String) 
       } 

      } }, to: base_url, method: .post, headers: nil, 
       encodingCompletion: { encodingResult in 
        switch encodingResult { 
        case .success(let upload, _, _): 
         upload.uploadProgress { progress in 
          print(progress.fractionCompleted) 
         } 
         upload.response { [weak self] response in 
          guard self != nil else { 
           return 
          } 
          let responseString = String(data: response.data!, encoding: String.Encoding.utf8) 
          return success(responseString as AnyObject) 

         } 
        case .failure(let encodingError): 
         print("error:\(encodingError)") 
         return failure(encodingError as AnyObject) 
        } 
     }) 
    } 
    func convertToDictionary(text: String) -> [String: Any]? { 
     if let data = text.data(using: .utf8) { 
      do { 
       return try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] 
      } catch { 
       print(error.localizedDescription) 
      } 
     } 
     return nil 
    } 
} 

Zastosowanie:

self.webservice.uploadWithAlamofire(Parameters: dict_params as [NSObject : AnyObject], ImageParameters: imgparam as [NSObject : AnyObject], VideoParameters: videoparam as [NSObject : AnyObject], Action: "write_message", success: { (success) in 
     print(success) 
}) { (error) in 
     print(error) 
}