अलमॉफायर का उपयोग करते हुए मापदंडों के साथ फाइल अपलोड करना

Question

मैं एक फ़ाइल का उपयोग करके अपलोड करने का प्रयास कर रहा हूं Alamofire। फ़ाइल ( NSUrl) का उपयोग करते समय अपलोड ठीक काम करता है , हालांकि, मुझे यह पता नहीं लगता कि NSDataविकल्प का उपयोग कैसे करें ?

यह मेरे पास एक परीक्षण के रूप में है:

 var url:NSURL = NSURL.URLWithString("http://localhost:8080/bike.jpeg")

 var err: NSError?
 var imageData :NSData = NSData.dataWithContentsOfURL(url,options: NSDataReadingOptions.DataReadingMappedIfSafe, error: &err)

 Alamofire.upload(.POST, "http://localhost:8080/rest/service/upload/test.png", imageData)
        .progress { (bytesWritten, totalBytesWritten, totalBytesExpectedToWrite) in
            println(totalBytesWritten)
        }
        .responseJSON { (request, response, JSON, error) in
            println(request)
            println(response)
           println(JSON)
 }

मुझे एक स्थिति कोड 415 मिल रहा है?

इसके अलावा, मैं अपलोड में अतिरिक्त पैरामेट्स कैसे भेज सकता हूं?

धन्यवाद

संपादित करें

मैं सही सामग्री-प्रकार सेट नहीं कर रहा था:

var manager = Manager.sharedInstance
manager.session.configuration.HTTPAdditionalHeaders = ["Content-Type": "application/octet-stream"]


let imageData: NSMutableData = NSMutableData.dataWithData(UIImageJPEGRepresentation(imageTest.image, 30));

Alamofire.upload(.POST, "http://localhost:8080/rest/service/upload?attachmentName=file.jpg",  imageData)
        .progress { (bytesWritten, totalBytesWritten, totalBytesExpectedToWrite) in
            println(totalBytesWritten)
        }
        .responseString { (request, response, JSON, error) in
            println(request)
            println(response)
            println(JSON)
}

फिर भी यह पता नहीं लगाया जा सकता है कि अपलोड के साथ अतिरिक्त पैरामीटर कैसे भेजें।

Comments

"MultartFormData.appendBodyPart (डेटा: image1Data, नाम:" फ़ाइल ", fileName:" myImage.png ", mimeType:" image / png ") का उपयोग करें" "यह छोटा हो सकता है अन्यथा त्रुटि" वर्ण 0 के आसपास अमान्य मान "प्राप्त करें

— Avijit Nagare

Answer 1

यहाँ एक सरल कार्य है जिसके लिए लक्ष्य अपलोड url, पैरामीटर और imageData की आवश्यकता है और URLRequestConvertible और NSData को लौटाता है जो Alamofire.upload को पैरामीटर के साथ एक छवि अपलोड करने की आवश्यकता है।

// this function creates the required URLRequestConvertible and NSData we need to use Alamofire.upload
func urlRequestWithComponents(urlString:String, parameters:Dictionary<String, String>, imageData:NSData) -> (URLRequestConvertible, NSData) {

    // create url request to send
    var mutableURLRequest = NSMutableURLRequest(URL: NSURL(string: urlString)!)
    mutableURLRequest.HTTPMethod = Alamofire.Method.POST.rawValue
    let boundaryConstant = "myRandomBoundary12345";
    let contentType = "multipart/form-data;boundary="+boundaryConstant
    mutableURLRequest.setValue(contentType, forHTTPHeaderField: "Content-Type")



    // create upload data to send
    let uploadData = NSMutableData()

    // add image
    uploadData.appendData("\r\n--\(boundaryConstant)\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
    uploadData.appendData("Content-Disposition: form-data; name=\"file\"; filename=\"file.png\"\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
    uploadData.appendData("Content-Type: image/png\r\n\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
    uploadData.appendData(imageData)

    // add parameters
    for (key, value) in parameters {
        uploadData.appendData("\r\n--\(boundaryConstant)\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
        uploadData.appendData("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n\(value)".dataUsingEncoding(NSUTF8StringEncoding)!)
    }
    uploadData.appendData("\r\n--\(boundaryConstant)--\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)



    // return URLRequestConvertible and NSData
    return (Alamofire.ParameterEncoding.URL.encode(mutableURLRequest, parameters: nil).0, uploadData)
}    

इसका उपयोग कैसे करें (इसे देखें और भेजें अनुरोध) का एक उदाहरण है:

// init paramters Dictionary
var parameters = [
    "task": "task",
    "variable1": "var"
]

// add addtionial parameters
parameters["userId"] = "27"
parameters["body"] = "This is the body text."

// example image data
let image = UIImage(named: "177143.jpg")
let imageData = UIImagePNGRepresentation(image)



// CREATE AND SEND REQUEST ----------

let urlRequest = urlRequestWithComponents("http://example.com/uploadText/", parameters: parameters, imageData: imageData)

Alamofire.upload(urlRequest.0, urlRequest.1)
    .progress { (bytesWritten, totalBytesWritten, totalBytesExpectedToWrite) in
        println("\(totalBytesWritten) / \(totalBytesExpectedToWrite)")
    }
    .responseJSON { (request, response, JSON, error) in
        println("REQUEST \(request)")
        println("RESPONSE \(response)")
        println("JSON \(JSON)")
        println("ERROR \(error)")
}    

और अगर आपको लक्ष्य url के लिए php फ़ाइल की आवश्यकता है (उसी निर्देशिका में 'अपलोड' फ़ोल्डर के साथ):

// get picture variables
$file       = $_FILES['file']['tmp_name'];
$fileName   = $_FILES['file']['name'];
$fileType   = $_FILES['file']['type'];

// check extension
$allowedExts = array("jpg", "jpeg", "png");
$rootName = reset(explode(".", $fileName));
$extension = end(explode(".", $fileName));

// create new file name
$time = time();
$newName = $rootName.$time.'.'.$extension;

// temporarily save file
$moved = move_uploaded_file($_FILES["file"]["tmp_name"], "uploads/".$newName );
if ($moved) $path = "uploads/".$newName;

$body = $_POST['body'];
$userId = $_POST['userId'];


$time = time();
if ($moved) {
    $fullUrl = "http://antiblank.com/testPhotoUpload/".$path;
    $arrayToSend = array('status'=>'success','time'=>$time,'body'=>$body,'userId'=>$userId, "imageURL"=>$fullUrl);
} else {
    $arrayToSend = array('status'=>'FAILED','time'=>$time,'body'=>$body,'userId'=>$userId);
}

header('Content-Type:application/json');
echo json_encode($arrayToSend);

Comments

नमस्ते, मैं पहले से ही इस पद्धति का उपयोग करता हूं और अच्छी तरह से काम करता हूं। लेकिन सर्वर साइड में वे अनुरोध प्रकार को बदलते हैं JSON.after कि यह विधि काम नहीं कर रही है। मैं डेटा को json के रूप में अपलोड करना चाहता हूं ... क्या आप कृपया मेरी मदद कर सकते हैं

— mychar

लगभग सही है, इस लाइन नाम में अपलोड करें .Data.appendData ("Content-Disposition: form-data; name = \" file \ "; filename = \" file.png \ "r \ n" .dataUsingEncoding (NSUTF8StringEncoding)!) \ "फ़ाइल \", वास्तव में फ़ाइल का मुख्य नाम है जो सर्वर..जैसे पेपरक्लिप से निपटेगा।

— Albert.Qing

Mines पहले काम कर रहा था और अब NSCocoaErrorDomain कोड 3840 प्राप्त कर रहा है, किसी ने भी इस मुद्दे को हल किया है?

— गॉडफादर

@antiblank इस कोड को साझा करने के लिए धन्यवाद। क्या आप ओह को सलाह दे सकते हैं कि इस फ़ंक्शन को कैसे बदला जाए ताकि यह या तो NSData को स्वीकार कर सके या चित्र पैरामीटर के लिए अशक्त हो, क्योंकि उपयोगकर्ताओं के पास यह विकल्प है कि वे मेरे वेब सेवा कॉल में चित्र अपलोड करें या नहीं। क्या मैं NSData की जगह किसी भी प्रकार के ऑबजेक्ट का उपयोग कर सकता हूं

— user2363025

हम हेडर सहित यह कैसे कर सकते हैं?

— पूनम

Answer 2

स्विफ्ट 3 और 4 के माध्यम से पैरामीटर और कस्टम हेडर के साथ फोटो / फाइल अपलोड करें और 4 और अल्मोफायर 4

// import Alamofire
func uploadWithAlamofire() {
  let image = UIImage(named: "bodrum")!

  // 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)")
          }
  })
}

स्विफ्ट 2 और अलमोफायर 3 के माध्यम से

  // import Alamofire
  func uploadWithAlamofire() {
    let image = UIImage(named: "myImage")!

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

    // Begin upload
    Alamofire.upload(.POST, "upload_url",
      // define your headers here
      headers: ["Authorization": "auth_token"],
      multipartFormData: { multipartFormData in

        // import image to request
        if let imageData = UIImageJPEGRepresentation(image, 1) {
          multipartFormData.appendBodyPart(data: imageData, name: "file", fileName: "myImage.png", mimeType: "image/png")
        }

        // import parameters
        for (key, value) in parameters {
          multipartFormData.appendBodyPart(data: value.dataUsingEncoding(NSUTF8StringEncoding)!, name: key)
        }
      }, // you can customise Threshold if you wish. This is the alamofire's default value
      encodingMemoryThreshold: Manager.MultipartFormDataEncodingMemoryThreshold,
      encodingCompletion: { encodingResult in
        switch encodingResult {
        case .Success(let upload, _, _):
          upload.responseJSON { response in
            debugPrint(response)
          }
        case .Failure(let encodingError):
          print(encodingError)
        }
    })
  }

वर्तमान स्विफ्ट संस्करण: https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#uploading-data-to-a-server

Comments

क्या कोई निकाय मुझे इन नीचे दी गई लाइनों के बारे में बता सकता है यदि letData = UIImageJPEGRepresentation (छवि, 1) {multipartFormData.append (imageData, withName: "file", fileame: "file.png", mimeType: "image / png")} के लिए बताएं। (कुंजी, मान) मापदंडों में {multipartFormData.append ((मान .data (.utf8)) का उपयोग करें !, withName: कुंजी)}}

— रवि ओझा

यह अगर काम नहीं करेगा parametersहै [String:Any]क्योंकि value.data(using: .utf8))!लिए मान्य नहीं है Any Type। क्या आपके पास सुझाव है कि इसे कैसे हल किया जाए?

— Chlebta

Answer 3

यहाँ एक समाधान है जो एंटीमाइकैंस के उत्तर के आधार पर अल्मोफायर 3.0 का उपयोग कर रहा है:

 let parameters = [
            "par1": "value",
            "par2": "value2"]    

 let URL = "YOUR_URL.php"

 let image = UIImage(named: "image.png")

 Alamofire.upload(.POST, URL, multipartFormData: {
                multipartFormData in

                if let _image = image {
                    if let imageData = UIImageJPEGRepresentation(_image, 0.5) {
                        multipartFormData.appendBodyPart(data: imageData, name: "file", fileName: "file.png", mimeType: "image/png")
                    }
                }

                for (key, value) in parameters {
                    multipartFormData.appendBodyPart(data: value.dataUsingEncoding(NSUTF8StringEncoding)!, name: key)
                }

            }, encodingCompletion: {
                encodingResult in

                switch encodingResult {
                case .Success(let upload, _, _):
                     upload.responseObject { (response: Response<UploadData, NSError>) -> Void in

                     switch response.result {
                     case .Success:
                         completionHandler?(success: true)
                     case .Failure(let error):
                         completionHandler?(success: false)
                     }

                 }
                case .Failure(let encodingError):
                    print(encodingError)
                }
        })

Comments

आप इस अपलोड को कैसे रद्द करेंगे? अन्य उत्तरों में मैं लोगों को एक var को अपलोड करने का आश्वासन देते हुए देख रहा हूं, लेकिन जब मैं ऐसा करता हूं तो टाइप का अनुमान लगाया जाता है (), इस प्रकार तरीकों को इस पर कॉल करने की अनुमति नहीं देता है? धन्यवाद।

— सीन लिनटर्न

@ SeanLintern88: आप अनुरोध-ऑब्जेक्ट पर रद्द () कॉल कर सकते हैं। कुछ इस तरह: upload.cancel ()। आप चर के लिए अनुरोध-वस्तु को असाइन कर सकते हैं और रद्द कर सकते हैं ()

— EdFunke

case .Success(let upload, _, _) uploadनहीं मिल रहा। क्या मैं कुछ भूल रहा हूँ?

— फतिहिलदिज़हन २३'१६

@fatihyildizhan encodingResultएक एनम है MultipartFormDataEncodingResult। .Success Case(: निम्नलिखित मानकों है request: Request, streamingFromDisk: Bool, streamFileURL: NSURL?) तो uploadएक अनुरोध है। क्या आपने जोड़ा import Alamofire?

— एडफकेके

आप इसके साथ प्रगति कैसे करते हैं?

— hris.to

Answer 4

स्विफ्ट 2.2 अल्मोफायर 3.3.1 के लिए एडफंक के जवाब को बढ़ाना

Alamofire.upload(.POST, urlString, multipartFormData: {
            multipartFormData in
            if let _image = self.profilePic.image {
                if let imageData = UIImagePNGRepresentation(_image) {
                    multipartFormData.appendBodyPart(data: imageData, name: "user_image", fileName: "file.png", mimeType: "image/png")
                }
            }
            for (key, value) in userInfo {
                multipartFormData.appendBodyPart(data: value.dataUsingEncoding(NSUTF8StringEncoding)!, name: key)
            }
            }, encodingCompletion: { encodingResult in
                switch encodingResult {
                case .Success(let upload, _, _):
                    upload.responseJSON { response in
                        debugPrint(response)
                    }
                case .Failure(let encodingError):
                    print(encodingError)
                }
            }
        )

Answer 5

मल्टीपार्ट अपलोड को अल्मोफायर के अगले (1.3.0) रिलीज के साथ शामिल किया जाना है। इस बीच, इस थ्रेड में जानकारी का उपयोग करते हुए, मैंने एक वर्ग बनाया है जो अपलोडिंग फ़ाइलों को सरल करता है और एक या अधिक फ़ाइलों के साथ अनुरोध में अतिरिक्त पैरामीटर (नियमित "इनपुट") भी शामिल है। यह मानते हुए कि फाइलें एक विशेष प्रकार या राउटर के उपयोग की हैं।

FileUploader.swift:

import Foundation
import Alamofire

private struct FileUploadInfo {
  var name:String
  var mimeType:String
  var fileName:String
  var url:NSURL?
  var data:NSData?

  init( name: String, withFileURL url: NSURL, withMimeType mimeType: String? = nil ) {
    self.name = name
    self.url = url
    self.fileName = name
    self.mimeType = "application/octet-stream"
    if mimeType != nil {
      self.mimeType = mimeType!
    }
    if let _name = url.lastPathComponent {
      fileName = _name
    }
    if mimeType == nil, let _extension = url.pathExtension {
      switch _extension.lowercaseString {

      case "jpeg", "jpg":
        self.mimeType = "image/jpeg"

      case "png":
        self.mimeType = "image/png"

      default:
        self.mimeType = "application/octet-stream"
      }
    }
  }

  init( name: String, withData data: NSData, withMimeType mimeType: String ) {
    self.name = name
    self.data = data
    self.fileName = name
    self.mimeType = mimeType
  }
}

class FileUploader {

  private var parameters = [String:String]()
  private var files = [FileUploadInfo]()
  private var headers = [String:String]()

  func setValue( value: String, forParameter parameter: String ) {
    parameters[parameter] = value
  }

  func setValue( value: String, forHeader header: String ) {
    headers[header] = value
  }

  func addParametersFrom( #map: [String:String] ) {
    for (key,value) in map {
      parameters[key] = value
    }
  }

  func addHeadersFrom( #map: [String:String] ) {
    for (key,value) in map {
      headers[key] = value
    }
  }

  func addFileURL( url: NSURL, withName name: String, withMimeType mimeType:String? = nil ) {
    files.append( FileUploadInfo( name: name, withFileURL: url, withMimeType: mimeType ) )
  }

  func addFileData( data: NSData, withName name: String, withMimeType mimeType:String = "application/octet-stream" ) {
    files.append( FileUploadInfo( name: name, withData: data, withMimeType: mimeType ) )
  }

  func uploadFile( request sourceRequest: NSURLRequest ) -> Request? {
    var request = sourceRequest.mutableCopy() as! NSMutableURLRequest
    let boundary = "FileUploader-boundary-\(arc4random())-\(arc4random())"
    request.setValue( "multipart/form-data;boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
    let data = NSMutableData()

    for (name, value) in headers {
      request.setValue(value, forHTTPHeaderField: name)
    }

    // Amazon S3 (probably others) wont take parameters after files, so we put them first        
    for (key, value) in parameters {
      data.appendData("\r\n--\(boundary)\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
      data.appendData("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n\(value)".dataUsingEncoding(NSUTF8StringEncoding)!)
    }

    for fileUploadInfo in files {
      data.appendData( "\r\n--\(boundary)\r\n".dataUsingEncoding(NSUTF8StringEncoding)! )
      data.appendData( "Content-Disposition: form-data; name=\"\(fileUploadInfo.name)\"; filename=\"\(fileUploadInfo.fileName)\"\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
      data.appendData( "Content-Type: \(fileUploadInfo.mimeType)\r\n\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
      if fileUploadInfo.data != nil {
        data.appendData( fileUploadInfo.data! )
      }
      else if fileUploadInfo.url != nil, let fileData = NSData(contentsOfURL: fileUploadInfo.url!) {
        data.appendData( fileData )
      }
      else { // ToDo: report error
        return nil
      }
    }

    data.appendData("\r\n--\(boundary)--\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

    return Alamofire.upload( request, data )
  }

}

इसका उपयोग इस तरह किया जाएगा:

// This example uploads a file called example.png found in the app resources

let fileURL = NSBundle.mainBundle().URLForResource("example", withExtension: "png")
let fileUploader = FileUploader()
// we can add multiple files
// this would be equivalent to: <input type="file" name="myFile"/>
fileUploader.addFileURL(fileURL!, withName: "myFile")
// we can add NSData objects directly
let data = UIImage(named: "sample")
fileUploader.addFileData( UIImageJPEGRepresentation(data,0.8), withName: "mySecondFile", withMimeType: "image/jpeg" )
// we can also add multiple aditional parameters
// this would be equivalent to: <input type="hidden" name="folderName" value="sample"/>
fileUploader.setValue( "sample", forParameter: "folderName" )
// put your server URL here
var request = NSMutableURLRequest( URL: NSURL(string: "http://myserver.com/uploadFile" )! )
request.HTTPMethod = "POST"
fileUploader.uploadFile(request: request)

इसे देखें या इस gist से डाउनलोड करें: https://gist.github.com/ncerezo/b1991f8dfac01cb162c0

Comments

नमस्ते, क्या आपके उदाहरण के मामले में, iOS पक्ष में अपलोडिंग प्रक्रिया की सफलता या बल्कि विफलता की जांच करने का कोई तरीका है? जवाब के लिए धन्यवाद।

— जिगि वोंग

हां बिल्कुल। जैसा कि मैंने उल्लेख किया है, अपलोडफाइल (अनुरोध) विधि एक अनुरोध वस्तु देता है, बिल्कुल आलमोफायर.क्वेस्ट विधि की तरह, ताकि आप बस श्रृंखला की प्रगति और / या प्रतिक्रिया बंद कर सकें। उदाहरण के लिए: fileUploader.uploadFile (रिक्वेस्ट: रिक्वेस्ट) .response {(रिक्वेस्ट, रिस्पॉन्स, डेटा, एरर) में ....}

— nereerezo

Answer 6

@ एंटीब्लैंक के उत्तर में कोड मेरे लिए काम नहीं कर रहा था। मैंने कुछ बदलाव किए हैं और यह अब काम कर रहा है:

func urlRequestWithComponents(urlString:String, parameters:NSDictionary) -> (URLRequestConvertible, NSData) {

    // create url request to send
    var mutableURLRequest = NSMutableURLRequest(URL: NSURL(string: urlString)!)
    mutableURLRequest.HTTPMethod = Alamofire.Method.POST.rawValue
    //let boundaryConstant = "myRandomBoundary12345"
    let boundaryConstant = "NET-POST-boundary-\(arc4random())-\(arc4random())"
    let contentType = "multipart/form-data;boundary="+boundaryConstant
    mutableURLRequest.setValue(contentType, forHTTPHeaderField: "Content-Type")


    // create upload data to send
    let uploadData = NSMutableData()

    // add parameters
    for (key, value) in parameters {

        uploadData.appendData("\r\n--\(boundaryConstant)\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

        if value is NetData {
            // add image
            var postData = value as NetData


            //uploadData.appendData("Content-Disposition: form-data; name=\"\(key)\"; filename=\"\(postData.filename)\"\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

            // append content disposition
            var filenameClause = " filename=\"\(postData.filename)\""
            let contentDispositionString = "Content-Disposition: form-data; name=\"\(key)\";\(filenameClause)\r\n"
            let contentDispositionData = contentDispositionString.dataUsingEncoding(NSUTF8StringEncoding)
            uploadData.appendData(contentDispositionData!)


            // append content type
            //uploadData.appendData("Content-Type: image/png\r\n\r\n".dataUsingEncoding(NSUTF8StringEncoding)!) // mark this. 
            let contentTypeString = "Content-Type: \(postData.mimeType.getString())\r\n\r\n"
            let contentTypeData = contentTypeString.dataUsingEncoding(NSUTF8StringEncoding)
            uploadData.appendData(contentTypeData!)
            uploadData.appendData(postData.data)

        }else{
            uploadData.appendData("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n\(value)".dataUsingEncoding(NSUTF8StringEncoding)!)
        }
    }
    uploadData.appendData("\r\n--\(boundaryConstant)--\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)



    // return URLRequestConvertible and NSData
    return (Alamofire.ParameterEncoding.URL.encode(mutableURLRequest, parameters: nil).0, uploadData)
}

उपयोग:

let docDir:AnyObject = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0]
let imagePath = docDir + "/myPic.jpg"

var imageData = NSData(contentsOfFile: imagePath, options: NSDataReadingOptions.DataReadingMappedIfSafe, error: nil)
var parameters = [
            "pic"           :NetData(nsData: imageData!, filename: "customName.jpg"),
            "otherParm"     :"Value"
        ]


    let urlRequest = self.urlRequestWithComponents("http://www.example.com/upload.php", parameters: parameters)

नेटगाटा https://github.com/nghialv/Net/blob/master/Net/NetData.swift से

upload.php कोड:

<?php
// In PHP versions earlier than 4.1.0, $HTTP_POST_FILES should be used instead
// of $_FILES.

$uploaddir = 'uploads/';
// PS: custom filed name : pic
$uploadfile = $uploaddir . basename($_FILES['pic']['name']);

if (move_uploaded_file($_FILES['pic']['tmp_name'], $uploadfile)) {
   $array = array ("code" => "1", "message" => "successfully");  
} else {
   $array = array ("code" => "0", "message" => "Possible file upload attack!".$_FILES['pic']['name']); 
}

echo json_encode ( $array );  

?>

Comments

यह अच्छा होगा यदि आप बताएं कि आपने क्या बदलाव किया है। क्या यह एक सरल सुधार था जो @ एंटीब्लैंक के उत्तर को संपादित कर सकता है?

— लुइज़ क्रूज़

हाय milz, हाँ सिर्फ @antiblank जवाब से कुछ बदलाव, कोड मुझे बहुत मदद कर रहा है। साभार

— विन्सेन्ट यान

Answer 7

छोटा संस्करण @antiblank और @VincentYan उत्तरों पर आधारित है।

कक्षा

class Photo {
    class func upload(image: UIImage, filename: String) -> Request {
        let route = Router.CreatePhoto()
        var request = route.URLRequest.mutableCopy() as NSMutableURLRequest
        let boundary = "NET-POST-boundary-\(arc4random())-\(arc4random())"
        request.setValue("multipart/form-data;boundary="+boundary,
                         forHTTPHeaderField: "Content-Type")

        let parameters = NSMutableData()
        for s in ["\r\n--\(boundary)\r\n",
                  "Content-Disposition: form-data; name=\"photos[photo]\";" +
                    " filename=\"\(filename)\"\r\n",
                  "Content-Type: image/png\r\n\r\n"] {
            parameters.appendData(s.dataUsingEncoding(NSUTF8StringEncoding)!)
        }
        parameters.appendData(UIImageJPEGRepresentation(image, 1))
        parameters.appendData("\r\n--\(boundary)--\r\n"
                               .dataUsingEncoding(NSUTF8StringEncoding)!)
        return Alamofire.upload(request, parameters)
    }
}

प्रयोग

let rep = (asset as ALAsset).defaultRepresentation()
let ref = rep.fullResolutionImage().takeUnretainedValue()
Photo.upload(UIImage(CGImage: ref)!, filename: rep.filename())
    .progress { (bytesWritten, totalBytesWritten, totalBytesExpectedToWrite) in
        println(totalBytesWritten)
    }
    .responseJSON { (request, response, JSON, error) in
        println(JSON)
    }

Comments

@TomoMatsumotto जब मैंने आपके कोड का उपयोग करने की कोशिश की तो मुझे "आइडेंटिफाइड आइडेंटिफ़ायर 'राउटर का उपयोग" नाम की त्रुटि हो रही है, मुझे लगता है कि राउटर एक एनम है जिसे आप यहाँ उपयोग कर रहे हैं। क्या आप उत्तर को अपडेट कर सकते हैं? थैंक्यू

— अनकहथरा

@Ankahathara या तो एक राउटर एनम बनाएं या राउटर का उपयोग करने के बजाय मैन्युअल रूप से NSURLRequest बनाएं। github.com/Alamofire/Alamofire

— टॉम

Answer 8

हालांकि ऐसे अन्य उत्तर हैं जो सलाह देते हैं कि मल्टीपार्ट अनुरोधों को मैन्युअल रूप से कैसे बनाया जाए, आप शायद एएफएन नेटवर्किंग के साथ रहना चाहते हैं। भले ही यह ऑब्जेक्टिव-सी में लिखा गया है, फिर भी आप इसे अपने स्विफ्ट प्रोजेक्ट्स में देख सकते हैं ( सेम प्रोजेक्ट में स्विफ्ट और ऑब्जेक्टिव-सी देखें )। वैसे भी, AFN Networking का उपयोग करके एक मल्टीपार्ट अनुरोध सबमिट करने के लिए स्विफ्ट कोड निम्नानुसार है:

let data = UIImagePNGRepresentation(image)

let manager = AFHTTPSessionManager()

manager.POST(uploadURLString, parameters: nil, constructingBodyWithBlock: { formData in
    formData.appendPartWithFileData(data, name: "image", fileName: "test.png", mimeType: "image/png")
}, success: { operation, responseObject in
    println(responseObject)
}) { operation, error in
    println(error)
}

Xcode कष्टप्रद को इस id<AFMultipartFormData>पैरामीटर को पहचानने में समस्याएं हैं formData, इसलिए आप appendPartWithFileDataविधि या इसके मापदंडों के विशिष्ट संपादक कोड को पूरा करने का आनंद नहीं लेते हैं , लेकिन जब आप इसे संकलित करते हैं, और इसे चलाते हैं, तो यह ठीक काम करता है।

Comments

यह एक अच्छा बिंदु है, लेकिन मुझे लगता है कि "मैनुअल" टुकड़ा अलामॉफायर 3 में कुछ हद तक छोटा है। इस उत्तर को ऊपर (नीचे) देखें: stackoverflow.com/a/34961720/8047 ... धन्यवाद

— Dan Rosenstark

Answer 9

आपके अनुरोध में सामग्री प्रकार गुम होने के कारण आपको 415 मिल रहे हैं । नीचे Swift 2 और AlamoFire पर चित्र अपलोड करने के लिए एक कुल soution है

import UIKit
import Alamofire

class ViewController: UIViewController {

@IBOutlet var imageView: UIImageView!
@IBOutlet var btnUpload: UIButton!
override func viewDidLoad() {
    super.viewDidLoad()
}

func successDataHandler(responseData:String){

    print ("IMAGE UPLOAD SUCCESSFUL    !!!")

}

func failureDataHandler(errorData:String){

    print ("  !!!   IMAGE UPLOAD FAILURE   !!! ")

}

@IBAction func actionUpload(sender: AnyObject) {

    let URL = "http://m8coreapibeta.azurewebsites.net/api/cards/SaveImages"

    let postDataProlife:[String:AnyObject] = ["CardId":(dataCardDetail?.userId)!,"ImageType":1,"ImageData":imageView.image!]

    uplaodImageData(URL, postData: postDataProlife, successHandler: successDataHandler, failureHandler: failureDataHandler)
}

func uplaodImageData(RequestURL: String,postData:[String:AnyObject]?,successHandler: (String) -> (),failureHandler: (String) -> ()) -> () {

    let headerData:[String : String] = ["Content-Type":"application/json"]

    Alamofire.request(.POST,RequestURL, parameters: postData, encoding: .URLEncodedInURL, headers: headerData).responseString{ response in
        switch response.result {
        case .Success:
            print(response.response?.statusCode)
            successHandler(response.result.value!)
        case .Failure(let error):
            failureHandler("\(error)")
        }
    }
}
}

Answer 10

नीचे स्विफ्ट और Php कोड हैं

स्विफ्ट कोड -> Apple स्विफ्ट संस्करण 3.0.1 (स्विफ्टलैंग -800.0.58.6 क्लैंग -800.0.42.1) लक्ष्य: x86_64-apple-macosx10.9

   class  func upload(jsonObject: AnyObject , files : Array<Any>? = nil  , completionHandler :  CompletionBlock? = nil ,failureHandler : FailureBlock? = nil )
{

    Alamofire.upload(multipartFormData:
        { (multipartFormData) in

            if let  filesO = files
            {
                for i in (filesO.enumerated())
                {
                    let image = UIImage(named: "\(i.element)")

                    let data = UIImageJPEGRepresentation(image!, 1)!

                    multipartFormData.append(data, withName: "imgFiles[]" , fileName: "\( NSUUID().uuidString).jpeg" , mimeType: "image/jpeg")
                  // imgFiles[] give array in Php Side
                  // imgFiles   will give string in PHP String


                }

            }


            for  (key, value)  in jsonObject as! [String : String]
            {

                 multipartFormData.append(value.data(using: String.Encoding.utf8)!, withName: key)

            }}          
    },
                     to:baseURL)

PHP कोड पैरामीटर और फ़ाइल प्राप्त करने के लिए

यहाँ पैरामीटर $ _Request में हैंडल हैं

और फ़ाइलें $ _File में संभाल रहे हैं

$ _File डेटा में प्रारूप (ऐरे, शब्दकोश या स्ट्रिंग) स्विफ्ट पक्ष में अनुरोध पर निर्भर करेगा, यहां इस लाइन को कोड में देखें

multipartFormData.append (डेटा, withName: "imgFiles []", fileName: "(NSUUID ()। uuidString) .jpeg), mimeType:" image / jpeg ")।

Php साइड withName: "imgFiles []" नाम, प्रारूप, प्रकार की सरणी देता है

उदाहरण के लिए

"नाम": ["06748B86-478E-421B-8470-6262755AC149.jpeg", "E70269E9-FB54-4BFD-B807-7E418C81540D.jpeg"], "प्रकार": ["छवि / jpeg") "छवि" ], "tmp_name": ["/ tmp / phpz3UAPq", "/ tmp / phpCAPExG"], "त्रुटि": [0,0], "आकार": [27794952067259]}

PHP कोड

 if (isset($_FILES['imgFiles']) and strlen($orderId) > 0) {

        foreach ($_FILES['imgFiles']['tmp_name'] as $key => $tmp_name) {

            $file_name = $key . $_FILES['imgFiles']['name'][$key];
            $file_size = $_FILES['imgFiles']['size'][$key];
            $file_tmp = $_FILES['imgFiles']['tmp_name'][$key];
            $file_type = $_FILES['imgFiles']['type'][$key];
 if (is_dir("$desired_dir/" . $file_name) == false) {
                //move_uploaded_file($file_tmp, "user_data/" . $file_name);
                move_uploaded_file($file_tmp, $desired_dir . "/" .
           $file_name);
            } else {         //rename the file if another one exist
                $new_dir = $desired_dir . "/" . $file_name . time();
                rename($file_tmp, $new_dir);
            }

Answer 11

मैंने एंटीब्लैंक का जवाब लिया और पूरे हैंडलर के साथ 1 फंक्शन में यह सब लपेटा। सोचा कि यह किसी के लिए उपयोगी हो सकता है। यह थोड़ा 'मोटा' है तो एंटीब्लैंक का जवाब है क्योंकि मैं बस PHP फ़ाइल (JSON नहीं) से एक स्ट्रिंग प्रतिक्रिया ले रहा हूं।

यहाँ आप इसे कैसे कहते हैं:

let imageData = UIImagePNGRepresentation(myImageView.image)

uploadImage("http://www.example.com/image_upload.php", imageData: imageData, subdir: "images", filename: "imageID.png")
    { (req, res, str, err) -> Void in
        // do whatever you want to to for error handling and handeling success
    }

यहाँ समारोह ही है:

func uploadImage(urlToPHPFile: String, imageData: NSData, subdir: String, filename: String, completionHandler:(request:NSURLRequest, response:NSURLResponse?, responseString:String?, error: NSError?) -> ()) {

    func urlRequestWithComponents(urlString:String, parameters:Dictionary<String, String>, imageData:NSData) -> (URLRequestConvertible, NSData) {
        // create url request to send
        var mutableURLRequest = NSMutableURLRequest(URL: NSURL(string: urlString)!)
        mutableURLRequest.HTTPMethod = Method.POST.rawValue
        let boundaryConstant = "myRandomBoundary12345";
        let contentType = "multipart/form-data;boundary="+boundaryConstant
        mutableURLRequest.setValue(contentType, forHTTPHeaderField: "Content-Type")

        // create upload data to send
        let uploadData = NSMutableData()

        // add image
        uploadData.appendData("\r\n--\(boundaryConstant)\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
        uploadData.appendData("Content-Disposition: form-data; name=\"file\"; filename=\"file.png\"\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
        uploadData.appendData("Content-Type: image/png\r\n\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
        uploadData.appendData(imageData)

        // add parameters
        for (key, value) in parameters {
            uploadData.appendData("\r\n--\(boundaryConstant)\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
            uploadData.appendData("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n\(value)".dataUsingEncoding(NSUTF8StringEncoding)!)
        }
        uploadData.appendData("\r\n--\(boundaryConstant)--\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)

        // return URLRequestConvertible and NSData
        return (ParameterEncoding.URL.encode(mutableURLRequest, parameters: nil).0, uploadData)
    }

    let parameters = [
        "subdir" : subdir,
        "filename": filename
    ]
    let urlRequest = urlRequestWithComponents(urlToPHPFile, parameters, imageData)

    AlamoFire.upload(urlRequest.0, urlRequest.1)
        .responseString(completionHandler: { [weak self] (req, res, str, err) -> Void in
            if let strongSelf = self {
                completionHandler(request: req, response: res, responseString: str, error: err)

            }
        }
    )
}

और यहाँ php फ़ाइल है।

$subdir = $_POST['subdir'];
$filename = $_POST["filename"];

$targetPath = $subdir.'/'.$filename;

$moved = move_uploaded_file($_FILES["file"]["tmp_name"], $targetPath );
if ($moved) {
    echo "OK";
}
else {
    echo "Error: file not uploaded";
}