public static async Task ParseFiles(Stream data, string contentType, Action <string, Stream> fileProcessor) { var streamCotent = new StreamContent(data); streamCotent.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType); if (streamCotent.IsMimeMultipartContent()) { var provider = await streamCotent.ReadAsMultipartAsync(); foreach (var httpContent in provider.Contents) { var filename = httpContent.Headers.ContentDisposition.FileName; using (var fileContents = await httpContent.ReadAsStreamAsync()) { if (string.IsNullOrWhiteSpace(filename)) { fileProcessor(httpContent.Headers.ContentDisposition.Name.Trim('\"'), fileContents); continue; } fileProcessor(filename.Trim('\"'), fileContents); } } } else { var formdata = await streamCotent.ReadAsFormDataAsync(); var str = await streamCotent.ReadAsStringAsync(); var stream = await streamCotent.ReadAsStreamAsync(); } }
public static async void SaveFile(Stream data, string contentType) { StreamContent streamContent = new StreamContent(data); streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType); MultipartMemoryStreamProvider provider = await streamContent.ReadAsMultipartAsync(); foreach (HttpContent httpContent in provider.Contents) { string fileName = httpContent.Headers.ContentDisposition.FileName; if (string.IsNullOrWhiteSpace(fileName)) { continue; } using (Stream fileContents = await httpContent.ReadAsStreamAsync()) { using (Stream filestream = File.Create(FileManager.BaseDir + "assets/images/" + fileName.Replace("\"", ""))) { fileContents.CopyTo(filestream); filestream.Close(); } } } }
public async Task <bool> Upload() { try { var fileuploadPath = ConfigurationManager.AppSettings["FileUploadLocation"]; var provider = new MultipartFormDataStreamProvider(fileuploadPath); var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); foreach (var header in Request.Content.Headers) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } await content.ReadAsMultipartAsync(provider); //Code for renaming the random file to Original file name string uploadingFileName = provider.FileData.Select(x => x.LocalFileName).FirstOrDefault(); string originalFileName = String.Concat(fileuploadPath, "\\" + (provider.Contents[0].Headers.ContentDisposition.FileName).Trim(new Char[] { '"' })); if (File.Exists(originalFileName)) { File.Delete(originalFileName); } File.Move(uploadingFileName, originalFileName); //Code renaming ends... return(true); } catch (Exception) { return(false); } }
public static async Task <InMemoryMultipartFormDataStreamProvider> ReadRequestContent(HttpContent content) { // Append two bytes to the end of the stream, to prevent the weird IOException issue // http://stackoverflow.com/a/17290999/187996 Stream requestStream = await content.ReadAsStreamAsync(); Stream concatenatedStream = new MemoryStream(); requestStream.CopyTo(concatenatedStream); concatenatedStream.Seek(0, SeekOrigin.End); StreamWriter writer = new StreamWriter(concatenatedStream); writer.WriteLine(); writer.Flush(); concatenatedStream.Position = 0; StreamContent streamContent = new StreamContent(concatenatedStream); foreach (var header in content.Headers) { streamContent.Headers.Add(header.Key, header.Value); } var result = new InMemoryMultipartFormDataStreamProvider(); await streamContent.ReadAsMultipartAsync(result); return(result); }
public async Task <string> Upload() { try { var fileuploadPath = AppSettings.FileFolderPath; var provider = new MultipartFormDataStreamProvider(fileuploadPath); var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); foreach (var header in Request.Content.Headers) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } await content.ReadAsMultipartAsync(provider); //Code for renaming the random file to Original file name string uploadingFileName = provider.FileData.Select(x => x.Headers.ContentDisposition.FileName).FirstOrDefault(); uploadingFileName = Path.Combine(fileuploadPath, uploadingFileName.Replace("\"", "")); string originalFileName = Path.Combine(fileuploadPath, Guid.NewGuid() + Path.GetExtension(uploadingFileName)); if (File.Exists(originalFileName)) { File.Delete(originalFileName); } File.Move(provider.FileData.FirstOrDefault().LocalFileName, originalFileName); //Code renaming ends... return(Path.GetFileName(originalFileName)); } catch (Exception) { return(""); } }
public HttpResponseMessage Post() { Stream reqStream = Request.Content.ReadAsStreamAsync().Result; MemoryStream tempStream = new MemoryStream(); reqStream.CopyTo(tempStream); tempStream.Seek(0, SeekOrigin.End); StreamWriter writer = new StreamWriter(tempStream); writer.WriteLine(); writer.Flush(); tempStream.Position = 0; StreamContent streamContent = new StreamContent(tempStream); foreach (var header in Request.Content.Headers) { streamContent.Headers.Add(header.Key, header.Value); } var result = new HttpResponseMessage(HttpStatusCode.OK); if (Request.Content.IsMimeMultipartContent()) { var task = streamContent.ReadAsMultipartAsync <MultipartMemoryStreamProvider>(new MultipartMemoryStreamProvider()); task.Wait(); MultipartMemoryStreamProvider provider = task.Result; using (var _repo = new WebsiteFileRepository(UnitOfWork)) { foreach (HttpContent content in provider.Contents) { WebsiteFile newFile = new WebsiteFile(); newFile.Id = Guid.NewGuid(); Stream stream = content.ReadAsStreamAsync().Result; string filePath = HostingEnvironment.MapPath("~/Images/"); string fileName = content.Headers.ContentDisposition.FileName.Replace("\"", ""); string fullPath = Path.Combine(filePath, fileName); using (var fileStream = File.Create(fullPath)) { stream.Seek(0, SeekOrigin.Begin); stream.CopyTo(fileStream); } //Add To DB newFile.Filename = fileName; _repo.InsertOrUpdate(newFile); } UnitOfWork.Save(); } return(result); } else { throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotAcceptable, "This request is not properly formatted")); } }
/// <summary> /// Initialize<br/> /// 初始化<br/> /// </summary> /// <param name="parentContext">Parent context</param> /// <param name="owinRequest">Original http request</param> public OwinHttpRequestWrapper( OwinHttpContextWrapper parentContext, IOwinRequest owinRequest) { ParentContext = parentContext; OwinRequest = owinRequest; OwinContent = new StreamContent(OwinRequest.Body); var contentType = OwinRequest.ContentType ?? ""; if (!string.IsNullOrEmpty(contentType)) { OwinContent.Headers.Add("Content-Type", contentType); } OwinFormCollection = new Lazy <NameValueCollection>(() => { if (contentType.StartsWith("application/x-www-form-urlencoded")) { return(OwinContent.ReadAsFormDataAsync().Result); } return(null); }); OwinMultipartFormCollection = new Lazy <Dictionary <string, IList <HttpContent> > >(() => { if (contentType.StartsWith("multipart/form-data")) { var result = new Dictionary <string, IList <HttpContent> >(); var provider = OwinContent.ReadAsMultipartAsync().Result; foreach (var content in provider.Contents) { var key = content.Headers.ContentDisposition.Name.Trim('"'); result.GetOrCreate(key, () => new List <HttpContent>()).Add(content); } return(result); } return(null); }); HttpContentReadResults = new Dictionary <HttpContent, string>(); }
public async Task <IHttpActionResult> Upload(int id) { if (!Request.Content.IsMimeMultipartContent("form-data")) { return(BadRequest("Unsupported media type")); } try { var provider = new MultipartFormDataStreamProvider(HttpContext.Current.Server.MapPath("~/uploads/")); var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); foreach (var header in Request.Content.Headers) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } await content.ReadAsMultipartAsync(provider); using (var context = new DocumentEntities()) { foreach (var file in provider.FileData) { using (var ts = new TransactionScope()) { var documentMeta = new DocumentMeta { CollectionId = id, FileName = file.Headers.ContentDisposition.Name.Trim(new char[] { '"' }).Replace("&", "and"), UploadTime = DateTime.Now }; context.DocumentMeta.Add(documentMeta); context.SaveChanges(); var documentContent = new DocumentContent { Id = documentMeta.Id, RowGuid = Guid.NewGuid(), Data = new Byte[0] }; context.DocumentContent.Add(documentContent); context.SaveChanges(); using (var stream = File.OpenRead(file.LocalFileName)) { DocumentContentHelper.AddContentData(documentContent.Id, context, stream); } ts.Complete(); } } } return(Ok()); } catch (Exception ex) { return(BadRequest(ex.GetBaseException().Message)); } }
private static IEnumerable <HttpContent> GetMultipartContent(Stream stream, string contentType) { var content = new StreamContent(stream); content.Headers.Add("Content-Type", contentType); return(content.ReadAsMultipartAsync().Result.Contents); }
public async Task CameraImage(HttpListenerContext context) { //var logger = LogManager.GetCurrentClassLogger(); context.Response.ContentType = "application/json"; try { //.Net Framework var request = context.Request; var streamContent = new StreamContent(request.InputStream); streamContent.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(request.ContentType); var provider = await streamContent.ReadAsMultipartAsync(); //.Net Core //https://docs.microsoft.com/zh-cn/aspnet/core/mvc/models/file-uploads foreach (var content in provider.Contents) { if (!string.IsNullOrEmpty(content.Headers.ContentDisposition.FileName)) { var fileName = content.Headers.ContentDisposition.FileName; this.Log.Info($"ContentType:{content.Headers.ContentType}"); this.Log.Info($"FileName:{content.Headers.ContentDisposition.FileName}"); var fileStream = await content.ReadAsStreamAsync(); //处理文件 var newPath = $"E:\\Test\\{fileName.Replace("\"","")}"; using (var file = File.OpenWrite(newPath)) { await fileStream.CopyToAsync(file); } } else { var value = await content.ReadAsStringAsync(); this.Log.Info($"{content.Headers.ContentDisposition.Name}:{value}"); } this.Log.Info(Environment.NewLine); } await Task.Delay(10000); var resultJson = $"{{\"Code\":\"200\",\"Message\":\"Successfully\"}}"; var resultByte = Encoding.UTF8.GetBytes(resultJson); context.Response.StatusCode = 200; context.Response.ContentLength64 = resultByte.Length; context.Response.OutputStream.Write(resultByte, 0, resultByte.Length); } catch (Exception e) { this.Log.Error(e, e.Message); var resultJson = $"{{\"Code\":\"500\",\"Message\":\"{e.Message}\"}}"; var resultByte = Encoding.UTF8.GetBytes(resultJson); context.Response.StatusCode = 200; context.Response.ContentLength64 = resultByte.Length; context.Response.OutputStream.Write(resultByte, 0, resultByte.Length); } }
public async Task <IHttpActionResult> PostPhoto() { var studentid = ""; string root = HttpContext.Current.Server.MapPath("~/App_Data"); var provider = new MultipartFormDataStreamProvider(root); Stream reqStream = Request.Content.ReadAsStreamAsync().Result; MemoryStream tempStream = new MemoryStream(); reqStream.Position = 0; reqStream.CopyTo(tempStream); tempStream.Seek(0, SeekOrigin.End); StreamWriter writer = new StreamWriter(tempStream); writer.WriteLine(); writer.Flush(); tempStream.Position = 0; StreamContent streamContent = new StreamContent(tempStream); foreach (var header in Request.Content.Headers) { streamContent.Headers.Add(header.Key, header.Value); } try { var filesReadToProvider = await streamContent.ReadAsMultipartAsync(provider); var image_name = filesReadToProvider.FormData["name"]; studentid = filesReadToProvider.FormData["studentid"]; } catch (Exception e) { } Photo p = new Photo(); var file = HttpContext.Current.Request.Files.Count > 0 ? HttpContext.Current.Request.Files[0] : null; if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (file != null) { file.SaveAs(System.Web.HttpContext.Current.Server.MapPath("~/Scripts/dist/assets/Images/") + file.FileName); p.image_name = file.FileName; p.studentid = studentid; } db.Photos.Add(p); await db.SaveChangesAsync(); return(Ok(p)); }
public void FormData(Stream stream) { StreamContent streamContent = new StreamContent(stream); streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse(WebOperationContext.Current.IncomingRequest.ContentType); var task = Task.Run(() => streamContent.ReadAsMultipartAsync()); task.Wait(); var httpContents = from contents in task.Result.Contents where !string.IsNullOrEmpty(contents.Headers.ContentDisposition.FileName) select contents; Debug.WriteLine(httpContents.Skip(1).First().Headers.ContentDisposition); }
public async Task <IActionResult> UploadToBlob( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "call")] HttpRequest req, IBinder binder, CancellationToken cancellationToken) { using var streamContent = new StreamContent(req.Body) { Headers = { ContentType = MediaTypeWithQualityHeaderValue.Parse(req.ContentType) } }; var content = await streamContent.ReadAsMultipartAsync(cancellationToken); var allowedContents = content.Contents.Where(hc => _allowContentType.Contains(hc.Headers.ContentType.MediaType.ToLower())).ToArray(); if (allowedContents.Any() == false) { return(new BadRequestResult()); } var callId = Guid.NewGuid(); async Task UploadBlob(HttpContent httpContent1) { var fileName = httpContent1.Headers.ContentDisposition.FileName?.Replace("\"", string.Empty); if (string.IsNullOrWhiteSpace(fileName)) { return; } var blobName = $"calls/{fileName}"; var attribute = new BlobAttribute(blobName, FileAccess.Write) { Connection = "AzureWebJobsStorage" }; var stream = await httpContent1.ReadAsStreamAsync(); await using var blob = await binder.BindAsync <Stream>(attribute, cancellationToken); await stream.CopyToAsync(blob, cancellationToken); } var tasks = allowedContents.Select(UploadBlob); await Task.WhenAll(tasks); return(new AcceptedResult()); }
public async Task <IHttpActionResult> Upload(Guid profileId) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var provider = new MultipartFileStreamProvider(Path.GetTempPath()); var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); foreach (var header in Request.Content.Headers) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } var tsk = await content.ReadAsMultipartAsync(provider); var result = new List <AudioFile>(); var docfiles = new List <string>(); foreach (var fileData in tsk.FileData) { AudioFile audioFile = null; // Sometimes the filename has a leading and trailing double-quote character // when uploaded, so we trim it; otherwise, we get an illegal character exception var fileName = Path.GetFileName(fileData.Headers.ContentDisposition.FileName.Trim('"')); var mediaType = fileData.Headers.ContentType.MediaType; var localFileName = fileData.LocalFileName; using (var fileStream = File.OpenRead(fileData.LocalFileName)) { fileStream.Position = 0; audioFile = new AudioFile(); audioFile.QrProfileId = profileId; audioFile.UploadedByUserId = this.User.Identity.GetUserId(); audioFile.UploadedOn = DateTime.Now; audioFile.Extension = Path.GetExtension(fileData.Headers.ContentDisposition.FileName.Replace("\"", "")); db.AudioFiles.Add(audioFile); var service = new BlobService(); await service.UploadBlob(audioFile.Id.ToString(), mediaType, fileStream, BlobHelper.Repository.Audio); await db.SaveChangesAsync(); } result.Add(audioFile); File.Delete(fileData.LocalFileName); } return(Ok(result)); } catch (InvalidDataException ex) { return(BadRequest(ex.Message)); } }
public async Task <ResponseStatus> Upload() { ResponseStatus status = new ResponseStatus(); try { //var file = Request.Form.Files[0]; var fileuploadPath = HttpContext.Current.Server.MapPath("~/Images");; var provider = new MultipartFormDataStreamProvider(fileuploadPath); var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); foreach (var header in Request.Content.Headers) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } await content.ReadAsMultipartAsync(provider); string uploadingFileName = provider.FileData.Select(x => x.LocalFileName).FirstOrDefault(); var type = provider.FormData["type"]; var name = provider.FormData["name"]; string cid = Convert.ToString(provider.FormData["Id"]); string filename = String.Concat(type, name, RandomNumber(1000, 50000) + ".jpg"); string originalFileName = String.Concat(fileuploadPath, "\\" + (filename).Trim(new Char[] { '"' })); if (File.Exists(originalFileName)) { File.Delete(originalFileName); } File.Move(uploadingFileName, originalFileName); ApplicationUser user = appDbContex.Users.Where(a => a.Id == cid).SingleOrDefault(); if (user != null) { user.profilepic = "http://api.greenshops.in/Images/" + filename; await appDbContex.SaveChangesAsync(); } status.status = true; status.message = "Profile pic updated successfully"; // status.filePath = "http://api.clickperfect.me/Images/" + filename; } catch (Exception ex) { status.status = false; status.message = ex.ToString(); } return(status); }
public async Task <object> Uploadfile(int id) { try { var fileuploadPath = string.Concat(System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath, "..\\", ConfigurationManager.AppSettings["WebAppFolderName"].ToString(), "\\Documents"); var provider = new MultipartFormDataStreamProvider(fileuploadPath); var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); //byte[] arr = System.Threading.Tasks.Task foreach (var header in Request.Content.Headers) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } await content.ReadAsMultipartAsync(provider); string uploadingFileName = provider.FileData.Select(x => x.LocalFileName).FirstOrDefault(); //string originalFileName = String.Concat(fileuploadPath, "\\", "_ESTB_" + id.ToString(), "_Photo.jpg"); var filename = string.Concat(id.ToString(), "_", (provider.Contents[0].Headers.ContentDisposition.FileName).Trim(new Char[] { '"' })) .Replace(" ", "_") .Replace("-", "_") .ToUpper(); string originalFileName = String.Concat(fileuploadPath, "\\" + filename.ToString()); if (File.Exists(originalFileName)) { File.Delete(originalFileName); } File.Move(uploadingFileName, originalFileName); EstablishmentManagement.GetInstance.UpdateEstablishment(id, filename.ToString()); //} return(new Response { Code = id.ToString(), Status = "Updated", Message = string.Format("File '{0}' uploaded successfully", filename.ToString()) }); } catch (Exception ex) { return(new Response { Code = "-1", Status = "Error", Message = string.Format("Failed to upload because: {0}", ex.Message) }); } }
public static async Task ParseFiles(Stream data, MediaTypeHeaderValue contentType, Action <string, Stream> fileProcessor, File file) { var streamContent = new StreamContent(data); streamContent.Headers.ContentType = contentType; var provider = await streamContent.ReadAsMultipartAsync(); foreach (var httpContent in provider.Contents) { var fileName = httpContent.Headers.ContentDisposition.FileName; if (!string.IsNullOrWhiteSpace(fileName)) { using (Stream fileContents = await httpContent.ReadAsStreamAsync()) { fileProcessor(fileName, fileContents); } } else { string content = await httpContent.ReadAsStringAsync(); switch (httpContent.Headers.ContentDisposition.Name.Trim('\"')) { case "fields[name]": file.Name = content; break; case "fields[email]": file.Email = content; break; case "fields[title]": file.Title = content; break; case "fields[description]": file.Description = content; break; case "fields[video_url]": file.Video_Url = content; break; default: break; } } } }
public T Deserialize <T>(IRestResponse response) { var result = new ConvertApiResponse(); var streamContent = new StreamContent(GenerateStreamFromString(response.Content)); streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse(response.ContentType); var provider = streamContent.ReadAsMultipartAsync().Result; if (response.StatusCode == HttpStatusCode.OK) { result.Files = new List <ConvertedFiles>(); foreach (var content in provider.Contents) { var file = new ConvertedFiles { Name = Helper.GetFileName(content.Headers.ContentDisposition), Size = (int)content.Headers.ContentDisposition.Size.GetValueOrDefault(0), Data = content.Headers.ContentLocation == null?content.ReadAsByteArrayAsync().Result : null, Url = content.Headers.ContentLocation }; result.Files.Add(file); } } else { result.ApiError = new ConvertApiResponse.ApiErrorData(); foreach (var content in provider.Contents) { IEnumerable <string> conversionCode; var conversionCodeExist = content.Headers.TryGetValues("Code", out conversionCode); if (conversionCodeExist) { result.ApiError.StatusCode = int.Parse(conversionCode.First()); result.ApiError.ReasonPhrase = content.ReadAsStringAsync().Result; } IEnumerable <string> parameterValidation; var parameterValidationExist = content.Headers.TryGetValues("Parameter", out parameterValidation); if (parameterValidationExist) { result.ApiError.ParametersError.Add(new KeyValuePair <string, string>(parameterValidation.First(), content.ReadAsStringAsync().Result)); } } } return((T)(object)result); }
private bool ProcessOutputTestFiles(Request req, string mimeType) { var streamContent = new StreamContent(req.HttpRequest.InputStream, (int)req.HttpRequest.ContentLength64); streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse(req.HttpRequest.ContentType); var provider = streamContent.ReadAsMultipartAsync().Result; foreach (var httpContent in provider.Contents) { if (httpContent.Headers.ContentType.MediaType != mimeType) { return(false); } } return(true); }
public async Task TestGetAssetKnownTextureByteRange_0dash1_5dash8_CorrectMimeTypes() { var response = GetAsset(_capId, _knownTextureAsset.Id, ranges: new List <Range> { new Range(0, 1), new Range(5, 8) }); using (var stream = response.GetResponseStream()) using (var contentStream = new StreamContent(stream)) { contentStream.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(response.ContentType); var content = await contentStream.ReadAsMultipartAsync(); foreach (var section in content.Contents) { var contentType = section.Headers.ContentType; Assert.AreEqual("image/x-j2c", contentType.MediaType); } } }
public async Task <object> UploadPhoto(string UserType, int id) { try { var fileuploadPath = string.Concat(System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath, "..\\", ConfigurationManager.AppSettings["WebAppFolderName"].ToString(), "\\Themes\\Profiles\\"); var provider = new MultipartFormDataStreamProvider(fileuploadPath); var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); //byte[] arr = System.Threading.Tasks.Task foreach (var header in Request.Content.Headers) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } await content.ReadAsMultipartAsync(provider); string uploadingFileName = provider.FileData.Select(x => x.LocalFileName).FirstOrDefault(); string originalFileName = String.Concat(fileuploadPath, "\\", UserType + "_Profile_" + id.ToString(), "_Photo.jpg"); //string originalFileName = String.Concat(fileuploadPath, "\\" + (provider.Contents[0].Headers.ContentDisposition.FileName).Trim(new Char[] { '"' })); var filename = provider.Contents[0].Headers.ContentDisposition.FileName; if (File.Exists(originalFileName)) { File.Delete(originalFileName); } File.Move(uploadingFileName, originalFileName); //} return(new Response { Status = "Updated", Message = "Updated Successfully" }); } catch (Exception ex) { return(new Response { Status = "Error", Message = "Error" }); } }
async Task <MergeResult> MergeImpl(IOwinContext context) { var content = new StreamContent(context.Request.Body); content.Headers.ContentType = MediaTypeHeaderValue.Parse(context.Request.ContentType); var result = new MergeResult(); result.Graph = new Graph(); var provider = await content.ReadAsMultipartAsync(); foreach (var httpContent in provider.Contents) { var fileName = httpContent.Headers.ContentDisposition.FileName; if (string.IsNullOrWhiteSpace(fileName)) { continue; } using (Stream fileContent = await httpContent.ReadAsStreamAsync()) { using (TextReader reader = new StreamReader(fileContent)) { string data = await reader.ReadToEndAsync(); JToken jsonLd = JToken.Parse(data); if (result.JsonLdContext == null) { result.JsonLdContext = (JObject)jsonLd["@context"]; result.JsonLdFrame = (string)jsonLd["@type"]; } IGraph graph = Common.GraphFromJson(jsonLd); result.Graph.Merge(graph, false); } } } return(result); }
public async Task TestGetAssetKnownTextureByteRange_0dash1_5dash8_CorrectData() { var response = GetAsset(_capId, _knownTextureAsset.Id, ranges: new List <Range> { new Range(0, 1), new Range(5, 8) }); using (var stream = response.GetResponseStream()) using (var contentStream = new StreamContent(stream)) { contentStream.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(response.ContentType); var content = await contentStream.ReadAsMultipartAsync(); Assert.AreEqual(2, content.Contents.Count()); var section1 = content.Contents.First(); Assert.AreEqual(_knownTextureAsset.Data.Take(2), await section1.ReadAsByteArrayAsync()); var section2 = content.Contents.Skip(1).First(); Assert.AreEqual(_knownTextureAsset.Data.Skip(5).Take(8 - 5 + 1), await section2.ReadAsByteArrayAsync()); } }
public async Task <HttpResponseMessage> UploadFile() { var bucket = this.GetBucket(); var rootPath = FileConfig.MapPath(bucket, ""); //var filePath = FileConfig.MapPath(fileName); var rootUrl = Request.RequestUri.AbsoluteUri.Replace(Request.RequestUri.AbsolutePath, string.Empty); if (Request.Content.IsMimeMultipartContent()) { var streamProvider = new CustomMultipartFormDataStreamProvider(rootPath, bucket); //new MultipartFormDataStreamProvider(@"C:\tmp", Int32.MaxValue) var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); foreach (var header in Request.Content.Headers) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } var task = await content.ReadAsMultipartAsync(streamProvider).ContinueWith(t => { if (t.IsFaulted || t.IsCanceled) { return(this.ApiResult(ApiStatusCodes.NormalError, "存储文件失败")); } var fileInfo = streamProvider.FileData.Select(i => { var info = new FileInfo(i.LocalFileName); return(new FileDesc(info.Name, rootUrl + "/" + info.Name, info.Length / 1024)); }); ; return(this.ApiResult(fileInfo.ToList())); }); return(task); } else { return(this.ApiResult(ApiStatusCodes.NormalError, "表单文件格式不正确")); } }
public async Task TestGetAssetKnownTextureByteRange_0dash1_5dash8_CorrectContentRanges() { var response = GetAsset(_capId, _knownTextureAsset.Id, ranges: new List <Range> { new Range(0, 1), new Range(5, 8) }); using (var stream = response.GetResponseStream()) using (var contentStream = new StreamContent(stream)) { contentStream.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(response.ContentType); var content = await contentStream.ReadAsMultipartAsync(); Assert.AreEqual(2, content.Contents.Count()); var section1 = content.Contents.First(); var contentRange1 = section1.Headers.ContentRange; Assert.AreEqual($"bytes 0-1/{_knownTextureAsset.Data.Length}", contentRange1.ToString()); var section2 = content.Contents.Skip(1).First(); var contentRange2 = section2.Headers.ContentRange; Assert.AreEqual($"bytes 5-8/{_knownTextureAsset.Data.Length}", contentRange2.ToString()); } }
public static async Task ParseFiles(Stream data, string contentType, Action <string, Stream> fileProcessor) { var streamContent = new StreamContent(data); streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType); var provider = await streamContent.ReadAsMultipartAsync(); foreach (var httpContent in provider.Contents) { var fileName = httpContent.Headers.ContentDisposition.FileName; if (string.IsNullOrWhiteSpace(fileName)) { continue; } using (Stream fileContents = await httpContent.ReadAsStreamAsync()) { fileProcessor(fileName, fileContents); } } }
public async Task <bool> Upload() { try { var fileuploadPath = ConfigurationManager.AppSettings["FileUploadLocation"]; var provider = new MultipartFormDataStreamProvider(fileuploadPath); var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); foreach (var header in Request.Content.Headers) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } await content.ReadAsMultipartAsync(provider); return(true); } catch (Exception) { // todo: add in exeption logging nlog/log4net or something more advanced return(false); } }
/// <summary> /// create multiple records at once using a batch /// </summary> /// <param name="entityCollection"></param> /// <param name="datalist"></param> /// <returns></returns> public async Task <CRMBatchResult> Create(string entityCollection, object[] datalist) { await CheckAuthToken(); var httpClient = new HttpClient(); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _crmWebAPIConfig.AccessToken); httpClient.DefaultRequestHeaders.Add("OData-MaxVersion", "4.0"); httpClient.DefaultRequestHeaders.Add("OData-Version", "4.0"); var batchid = "batch_" + Guid.NewGuid().ToString(); MultipartContent batchContent = new MultipartContent("mixed", batchid); var changesetID = "changeset_" + Guid.NewGuid().ToString(); MultipartContent changeSetContent = new MultipartContent("mixed", changesetID); int contentID = 1; foreach (var data in datalist) { HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, _crmWebAPIConfig.APIUrl + entityCollection); req.Content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json"); req.Version = new Version(major: 1, minor: 1); var content = new HttpMessageContent(req); content.Headers.Remove("Content-Type"); content.Headers.TryAddWithoutValidation("Content-Type", "application/http"); content.Headers.TryAddWithoutValidation("Content-Transfer-Encoding", "binary"); content.Headers.TryAddWithoutValidation("Content-ID", contentID.ToString()); contentID++; changeSetContent.Add(content); } batchContent.Add(changeSetContent); HttpRequestMessage batchRequest = new HttpRequestMessage(HttpMethod.Post, _crmWebAPIConfig.APIUrl + "$batch"); batchRequest.Content = batchContent; var batchstring = await batchRequest.Content.ReadAsStringAsync(); var response = await httpClient.SendAsync(batchRequest); var responseString = response.Content.ReadAsStringAsync(); MultipartMemoryStreamProvider batchStream = await response.Content.ReadAsMultipartAsync();; var changesetStream = batchStream.Contents.FirstOrDefault(); StreamContent changesetFixedContent = FixupChangeStreamDueToBug(changesetStream); var changesetFixedStream = await changesetFixedContent.ReadAsMultipartAsync(); CRMBatchResult finalResult = new CRMBatchResult(); finalResult.ResultItems = new List <CRMBatchResultItem>(); foreach (var responseContent in changesetFixedStream.Contents) { var fixedREsponseContent = FixupToAddCorrectHttpContentType(responseContent); var individualResponseString = await fixedREsponseContent.ReadAsStringAsync(); var indivdualResponse = await fixedREsponseContent.ReadAsHttpResponseMessageAsync(); var idString = indivdualResponse.Headers.GetValues("OData-EntityId").FirstOrDefault(); idString = idString.Replace(_crmWebAPIConfig.APIUrl + entityCollection, "").Replace("(", "").Replace(")", ""); CRMBatchResultItem resultItem = new CRMBatchResultItem(); resultItem.EntityID = Guid.Parse(idString); finalResult.ResultItems.Add(resultItem); } return(finalResult); }
public async Task <List <string> > Upload() { if (Request.Content.IsMimeMultipartContent("form-data")) { try { string commonid = Guid.NewGuid().ToString("N"); string folder = ConfigurationManager.AppSettings["FileUploadLocation"] + commonid + "\\"; var path = System.Web.HttpContext.Current.Server.MapPath(folder); if (Directory.Exists(path)) { logger.Info("Path Already Exists."); } else { Directory.CreateDirectory(path); } var fileuploadPath = path; var provider = new MultipartFormDataStreamProvider(fileuploadPath); var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); foreach (var header in Request.Content.Headers) { logger.Info(header.Key + " " + header.Value); content.Headers.TryAddWithoutValidation(header.Key, header.Value); } await content.ReadAsMultipartAsync(provider); logger.Info(provider.FileData.Count); foreach (MultipartFileData i in provider.FileData) { logger.Error(i.LocalFileName); } string originalFileName = ""; string uploadingFileName = ""; string userEmail = provider.FormData.GetValues("email").FirstOrDefault(); logger.Info(userEmail); if (provider.Contents.Count == 0) { logger.Info("Provide Atleast Onefile."); HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, "Provide Atleast Onefile."); throw new HttpResponseException(response); } foreach (MultipartFileData file in provider.FileData) { uploadingFileName = file.LocalFileName; originalFileName = Path.Combine(fileuploadPath, (file.Headers.ContentDisposition.FileName).Trim(new Char[] { '"' })); logger.Debug(uploadingFileName + " " + originalFileName); File.Move(uploadingFileName, originalFileName); try { StoreDB(originalFileName.ToString(), commonid, userEmail); } catch (Exception e) { logger.Info(e); } } //string body = $"Please goto these link to download your files. {prefixURL + "/api/FileUpload/?key=" + commonid}"; string body = $"Please goto these link to download your files. {prefixURL + commonid}"; sendMail("File Uploaded Successfully.", body, userEmail); return(new List <string>() { prefixURL + "/api/FileUpload/?key=" + commonid }); } catch (Exception e) { logger.Info(e); HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, e); throw new HttpResponseException(response); } } else { HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid Request!"); throw new HttpResponseException(response); } }
public async Task <ResponseStatus> Upload() { ResponseStatus status = new ResponseStatus(); try { //var file = Request.Form.Files[0]; // var file = Request.Form.Files[0]; var fileuploadPath = HttpContext.Current.Server.MapPath("~/Images");; var provider = new MultipartFormDataStreamProvider(fileuploadPath); var content = new StreamContent(HttpContext.Current.Request.GetBufferlessInputStream(true)); foreach (var header in Request.Content.Headers) { content.Headers.TryAddWithoutValidation(header.Key, header.Value); } await content.ReadAsMultipartAsync(provider); string uploadingFileName = provider.FileData.Select(x => x.LocalFileName).FirstOrDefault(); var type = provider.FormData["type"]; var name = provider.FormData["name"]; string pid = Convert.ToString(provider.FormData["PId"]); string id = Convert.ToString(provider.FormData["id"]); if (id == "undefined") { var guId = Guid.NewGuid(); id = guId.ToString(); } // string cid = Convert.ToString(provider.FormData["PId"]); string filename = String.Concat(type, name, RandomNumber(1000, 50000) + ".jpg"); string originalFileName = String.Concat(fileuploadPath, "\\" + (filename).Trim(new Char[] { '"' })); if (File.Exists(originalFileName)) { File.Delete(originalFileName); } File.Move(uploadingFileName, originalFileName); productimages productimages = appDbContex.Productimages.Where(a => a.id == id).SingleOrDefault(); if (productimages != null) { productimages.image = "http://api.greenshops.in/Images/" + filename; await appDbContex.SaveChangesAsync(); } else { productimages productimages1 = new productimages() { id = id, image = "http://api.greenshops.in/Images/" + filename, productid = pid, deleted = false, createAt = DateTime.Now }; appDbContex.Productimages.Add(productimages1); await appDbContex.SaveChangesAsync(); } status.status = true; status.message = "uploaded"; // status.filePath = "http://api.clickperfect.me/Images/" + filename; } catch (Exception ex) { status.status = false; status.message = ex.ToString(); } return(status); }