caricamento di un file e modulo Dati in Web Api e angularJS

Question

Sto seguendo una guida in questo blog su come pubblicare i dati del modulo e un file. Sto cercando di caricare il file in una directory sul server hanno seguito, ma non funziona.

questa è la funzione Post

[HttpPost] 
     public async Task<HttpResponseMessage> UploadFile(HttpRequestMessage request) 
     { 
      String root = HttpContext.Current.Server.MapPath("~/Logo/"); 

      if (!request.Content.IsMimeMultipartContent()) 
      { 
       throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); 
      } 

      var data = await Request.Content.ParseMultipartAsync(); 
      var httpRequest = HttpContext.Current.Request; 

      if (data.Files.ContainsKey("file")) 
      { 

       var file = data.Files["file"].File;  // this is getting the file 
       var fileName = data.Files["file"].Filename; // this is getting the fileName 
       // System.Web.HttpPostedFile filePost = data.Files["file"]; 
       String a = root + "" + Path.GetFileName(fileName); 
       string b = a; 
       var postedFile = fileName;             // this is not working 
       var filePath = HttpContext.Current.Server.MapPath("~/Logo/" + fileName); // can someone help please 
       postedFile.SaveAs(filePath);            // I 

      } 

      if (data.Fields.ContainsKey("description")) 
      { 
       var description = data.Fields["description"].Value; 
      } 

      return new HttpResponseMessage(HttpStatusCode.OK) 
      { 
       Content = new StringContent("Thank you for uploading the file...") 
      }; 
     } 

come posso salvare il file nella directory sul server?

Answer 1

Attualmente sto utilizzando il seguente codice per caricare i file di immagine, ma anche lavorare per qualsiasi tipo di file:

public string UploadImage() 
    { 
     HttpRequestMessage request = this.Request; 
     if (!request.Content.IsMimeMultipartContent()) 
     { 
      throw new HttpResponseException(new HttpResponseMessage((HttpStatusCode.UnsupportedMediaType))); 
     } 
     var context = HttpContext.Current.Request; 
     if (context.Files.Count > 0) 
     { 
      var resourcePhoto = new PhotoHelper(HttpContext.Current.Server.MapPath("~")); 
      var file = context.Files.AllKeys.FirstOrDefault(); 
      var result = resourcePhoto.SaveResourceImage(context.Files[file], User.Identity.Name); 
      return result; 
     } 
     else 
     { 
      return null; 
     } 
    } 

E nel SaveResourceImage faccio la seguente:

postedFile.SaveAs(resultPath); 

Questo è tutto.

Answer 2

Servizio

app.factory('myService', ['$http', function ($http) { 
    return { 
     uploadFile: function(url, file) { 
      return $http({ 
       url: url, 
       method: 'POST', 
       data: file, 
       headers: { 'Content-Type': undefined }, //this is important 
       transformRequest: angular.identity //also important 
      }); 
     }, 
     otherFunctionHere: function(url, stuff) { 
      return $http.get(url); 
     } 
    }; 
}]); 

controller

app.controller('MainCtrl', ['$scope', 'myService', function($scope, myService) { 

    $scope.uploadFile = function() { 
     var fileInput = document.getElementById('fileInput'); 
     fileInput.click(); 

     //do nothing if there's no files 
     if(fileInput.files.length === 0) return; 

     var file = fileInput.files[0]; 

     var payload = new FormData(); 
     payload.append("stuff", "some string"); 
     payload.append("file", file); 

     //use the service to upload the file 
     myService.uploadFile('/path/to/API', payload).then(function(response){ 
      //success, file uploaded 
     }).catch(function(response){ 
      //bummer 
     }); 
    } 

}]); 

C# controller

[HttpPost] 
public JsonResult UploadFile(string stuff, HttpPostedFileBase file) 
{ 
    string fileName = Path.GetFileNameWithoutExtension(file.FileName); 
    string extension = Path.GetExtension(file.FileName); 

    //save the file 
    try 
    { 
     file.SaveAs('somePath' + fileName + extension); 
    } 
    catch (IOException exc) 
    { 
     return Json(new { status = 'error', message = exc.Message }); 
    } 

    return Json('horray'); 
} 

Answer 3

ero in grado di regolare la codice con questo frammento e che fa il trucco

var httpPostedFile = HttpContext.Current.Request.Files["file"];             // this is not working 
       var filePath = HttpContext.Current.Server.MapPath("~/Logo/" + fileName); // can someone help please 
       httpPostedFile.SaveAs(filePath); 

Answer 4

Per salvare file su server, è possibile fare uso di MultipartFormDataStreamProvider. Inoltre non penso che sia necessario passare la richiesta come uno dei parametri.

string root = HttpContext.Current.Server.MapPath("~/App_Data"); 
var provider = new MultipartFormDataStreamProvider(root); 

E poi può ottenere gestire al file come

// Read the form data. 
     await Request.Content.ReadAsMultipartAsync(provider); 

     // This illustrates how to get the file names. 
     foreach (MultipartFileData file in provider.FileData) 
     { 
      Trace.WriteLine(file.Headers.ContentDisposition.FileName); 
      Trace.WriteLine("Server file path: " + file.LocalFileName); 
     } 
     return Request.CreateResponse(HttpStatusCode.OK); 

This page su ASP.NET dare una buona panoramica di come farlo ..

Answer 5

ho cercato in questo modo su angolare 1.5 . Quindi ho il controller e il repository nel front end. Non l'ho salvato nel drive locale. Ma c'è un buffer, che possiamo salvare ovunque vogliamo.

Controller:

function submit() { 

     modelTemplateRepository.add(model.modelTemplate, model.file) 
      .then(function(response) { 
       if (response && response.status) { 
        if (response.status === 422) { 
         model.apiError = response.data; 
         model.isSubmitting = false; 
        } 
        else { 
         onSaved(response.data); 
        } 
       } 
      }); 
    } 

Repository:

function add(modelTemplate, file) { 

     var fd = new FormData(); 

     fd.append('file', file); 
     fd.append('modelTemplate',angular.toJson(modelTemplate)); 

     return $http.post(config.ApiEndpoint + '/modeltemplate', fd, 
     { 
      transformRequest: angular.identity, 
      headers: {'Content-Type': undefined} 
     }) 
      .then(addComplete) 
      .catch(function(data) { 
       return angular.fromJson(data); 
      }); 

     function addComplete(response, status, headers, config) { 
      return response; 
     } 
    } 

API:

[HttpPost] 
    [Route("api/modeltemplate")] 
    public async Task<IHttpActionResult> Post() 
    { 

     if (!Request.Content.IsMimeMultipartContent()) 
      throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); 

     var provider = new MultipartMemoryStreamProvider(); 

     await Request.Content.ReadAsMultipartAsync(provider); 

     var file = provider.Contents.First(x => x.Headers.ContentDisposition.Name == "\"file\""); 

     var filename = ""; 
     var buffer = new byte[0]; 

     if (file.Headers.ContentDisposition.FileName != null) 
     { 
      filename = file.Headers.ContentDisposition.FileName.Trim('\"'); 
      buffer = await file.ReadAsByteArrayAsync(); 
     } 

     var formContent = provider.Contents.First(x => x.Headers.ContentDisposition.Name == "\"modelTemplate\""); 
     Task<string> stringContentsTask = formContent.ReadAsStringAsync(); 
     var stringContents = stringContentsTask.Result; 
     var dto = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(stringContents); 

     var result = ApiHelper.Add<dynamic>("modeltemplate", dto); 

     return Ok(result); 
    }