public async Task <List <string> > Post() { if (Request.Content.IsMimeMultipartContent()) { string uploadPath = Path.GetTempPath(); MyStreamProvider streamProvider = new MyStreamProvider(uploadPath); await Request.Content.ReadAsMultipartAsync(streamProvider); List <string> messages = new List <string>(); foreach (var file in streamProvider.FileData) { using (Image originalImage = Image.FromFile(file.LocalFileName)) { await UploadImage(originalImage, Path.GetFileName(file.LocalFileName), file.Headers.ContentType.ToString(), "XL", 600); await UploadImage(originalImage, Path.GetFileName(file.LocalFileName), file.Headers.ContentType.ToString(), "L", 500); await UploadImage(originalImage, Path.GetFileName(file.LocalFileName), file.Headers.ContentType.ToString(), "M", 400); await UploadImage(originalImage, Path.GetFileName(file.LocalFileName), file.Headers.ContentType.ToString(), "S", 300); await UploadImage(originalImage, Path.GetFileName(file.LocalFileName), file.Headers.ContentType.ToString(), "thumb", 200); } } return(messages); } else { HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid Request!"); throw new HttpResponseException(response); } }
public static async Task <HttpResponseMessage> Upload(HttpRequestMessage request, HttpContext httpContext, string url) { var file = ""; if (!request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } string root = HttpContext.Current.Server.MapPath(url); var provider = new MyStreamProvider(root); try { await request.Content.ReadAsMultipartAsync(provider); var json = provider.FormData.GetValues("data")[0]; var aux = (provider.FileData[0].LocalFileName).Split('\\'); file = aux[aux.Length - 1]; JObject jObject = JObject.Parse(json); jObject.Add("fileName", file); return(request.CreateResponse(HttpStatusCode.OK, jObject)); } catch (System.Exception e) { return(request.CreateErrorResponse(HttpStatusCode.InternalServerError, e)); } }
public async Task <List <string> > PostAsync() { if (Request.Content.IsMimeMultipartContent()) { string uploadPath = HttpContext.Current.Server.MapPath("~/uploads"); MyStreamProvider streamProvider = new MyStreamProvider(uploadPath); await Request.Content.ReadAsMultipartAsync(streamProvider); List <string> messages = new List <string>(); foreach (var file in streamProvider.FileData) { FileInfo fi = new FileInfo(file.LocalFileName); messages.Add(Url.Content(String.Concat("~/uploads/", Path.GetFileName(fi.FullName)))); } return(messages); } else { HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid Request!"); throw new HttpResponseException(response); } }
public async Task <List <string> > PostAsync() { if (Request.Content.IsMimeMultipartContent()) { string uploadPath = HttpContext.Current.Server.MapPath("~/uploads"); if (!System.IO.Directory.Exists(uploadPath)) { System.IO.Directory.CreateDirectory(uploadPath); } MyStreamProvider streamProvider = new MyStreamProvider(uploadPath); await Request.Content.ReadAsMultipartAsync(streamProvider); List <string> messages = new List <string>(); foreach (var file in streamProvider.FileData) { FileInfo fi = new FileInfo(file.LocalFileName); messages.Add("File uploaded as " + fi.FullName + " (" + fi.Length + " bytes)"); } return(messages); } else { HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid Request!"); throw new HttpResponseException(response); } }
public async Task <IHttpActionResult> PostAsync(string username) { Response response = new Response(); response.status = "FAILURE"; string filePath = ""; string[] filePath1 = new string[2]; if (Request.Content.IsMimeMultipartContent()) { string uploadPath = HttpContext.Current.Server.MapPath("~/ResumeList/" + username); //Remove images that is save more than 30 minutes string [] files = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory + @"ResumeList\temporary"); foreach (string file in files) { FileInfo fileInfo = new FileInfo(file); double diffTime = (DateTime.Now - fileInfo.LastWriteTime).TotalMinutes; if (diffTime > 30) { File.Delete(file); } } if (Directory.Exists(uploadPath)) { MyStreamProvider streamProvider = new MyStreamProvider(uploadPath); //Save File asychronously await Request.Content.ReadAsMultipartAsync(streamProvider); if (!username.Equals("temporary")) { //Loop file details foreach (var file in streamProvider.FileData) { FileInfo fi = new FileInfo(file.LocalFileName); filePath = uploadPath + "\\" + fi.Name; string informationPath = AppDomain.CurrentDomain.BaseDirectory + @"ResumeList\" + username + "\\Information.txt"; using (System.IO.StreamWriter fileData = new System.IO.StreamWriter(informationPath, true)) { fileData.WriteLine(@"ResumeList" + "/" + username + "/" + fi.Name); } } } } response.status = "SUCCESS"; } else { response.message = "Invalid Request!"; } return(Ok(response)); }
static bool AsyncWriteTest(MemoryStream ms, Encoding encoding, MyStreamProvider myStreamProvider) { XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms); writer.WriteStartElement("Root"); Task writeValueAsynctask = writer.WriteValueAsync(myStreamProvider); writeValueAsynctask.Wait(); Assert.True(myStreamProvider.StreamReleased, "Error, stream not released."); writer.WriteEndElement(); writer.Flush(); return true; }
public static void StreamProvoiderTest() { List <string> ReaderWriterType = new List <string> { "Binary", //"MTOM", //MTOM methods not supported now. //"MTOM", //"MTOM", "Text", "Text", "Text" }; List <string> Encodings = new List <string> { "utf-8", "utf-8", "utf-16", "unicodeFFFE", "utf-8", "utf-16", "unicodeFFFE" }; for (int i = 0; i < ReaderWriterType.Count; i++) { string rwTypeStr = ReaderWriterType[i]; ReaderWriterFactory.ReaderWriterType rwType = (ReaderWriterFactory.ReaderWriterType) Enum.Parse(typeof(ReaderWriterFactory.ReaderWriterType), rwTypeStr, true); Encoding encoding = Encoding.GetEncoding(Encodings[i]); Random rndGen = new Random(); int byteArrayLength = rndGen.Next(100, 2000); byte[] byteArray = new byte[byteArrayLength]; rndGen.NextBytes(byteArray); MyStreamProvider myStreamProvider = new MyStreamProvider(new MemoryStream(byteArray)); bool success = false; bool successBase64 = false; MemoryStream ms = new MemoryStream(); success = WriteTest(ms, rwType, encoding, myStreamProvider); Assert.True(success); success = ReadTest(ms, encoding, rwType, byteArray); Assert.True(success); if (rwType == ReaderWriterFactory.ReaderWriterType.Text) { ms = new MemoryStream(); myStreamProvider = new MyStreamProvider(new MemoryStream(byteArray)); success = AsyncWriteTest(ms, encoding, myStreamProvider); Assert.True(success); successBase64 = AsyncWriteBase64Test(ms, byteArray, encoding, myStreamProvider); Assert.True(successBase64); } } }
public async Task <string> PostAsync() { try { if (Request.Content.IsMimeMultipartContent()) { string uploadPath = HttpContext.Current.Server.MapPath(Resource.UploadFolder); MyStreamProvider streamProvider = new MyStreamProvider(uploadPath); string message = string.Empty; OpenWeatherModel openWeatherMdl = new OpenWeatherModel(); openWeatherMdl.cities = new Dictionary <string, string>(); await Request.Content.ReadAsMultipartAsync(streamProvider); string uploadFilePath = streamProvider.GetLocalFileName(streamProvider.FileData[0].Headers); //Read the contents of CSV file. string csvData = File.ReadAllText(uploadFilePath); //Execute a loop over the file rows and populate cities in the object. foreach (string row in csvData.Split('\n')) { if (!string.IsNullOrEmpty(row)) { openWeatherMdl.cities.Add(row.Split(',')[0], row.Split(',')[1].Replace("\r", "")); } } message = GetWeatherInfo(openWeatherMdl); return(message); } else { HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid Request!"); throw new HttpResponseException(response); } } catch (Exception ex) { Logger.Publish(EventType.Exception, this.GetType().Name, MethodBase.GetCurrentMethod().Name.ToString(), ex.Message, ex.InnerException == null ? string.Empty : ex.InnerException.Message, ex.StackTrace); HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid Request!"); throw new HttpResponseException(response); } }
static bool AsyncWriteTest(MemoryStream ms, Encoding encoding, MyStreamProvider myStreamProvider) { XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms); writer.WriteStartElement("Root"); Task writeValueAsynctask = writer.WriteValueAsync(myStreamProvider); writeValueAsynctask.Wait(); if (myStreamProvider.StreamReleased) { Console.WriteLine("Ok, stream released right after AsyncWriteValue"); } else { Console.WriteLine("Error, stream not released after AsyncWriteValue"); return(false); } writer.WriteEndElement(); writer.Flush(); return(true); }
public async Task <IHttpActionResult> PostFormData() { if (!Request.Content.IsMimeMultipartContent()) { return(BadRequest()); } string root = HttpContext.Current.Server.MapPath("~/Uploads"); MyStreamProvider provider = new MyStreamProvider(root); await Request.Content.ReadAsMultipartAsync(provider); string filename = provider.GetFileName; List <RequestContact> contactsList = ParsingProvider.GetContactsFromFile(Path.Combine(root, filename)); if (contactsList == null) { return(BadRequest("Invalid file")); } Contact contactToAdd = new Contact(); int count = 0; foreach (var contact in contactsList) { Contact addedcontact = await appManager.AddOrUpdateContactAsync(contactToAdd, contact, true); if (addedcontact != null) { count++; } } string res = contactsList.Count - 1 - count == 0 ? $"{count} - Contacts added successfully, 0 - failed" : $"{count} - Contacts added successfully, {contactsList.Count - 1 - count} - failed(please ensure that data entered correctly)"; return(Ok(res)); }
public async Task <List <string> > PostSoundFileAsync() { if (this.Request.Content.IsMimeMultipartContent()) { var uploadPath = HttpContext.Current.Server.MapPath("~/Uploads"); var streamProvider = new MyStreamProvider(uploadPath); await this.Request.Content.ReadAsMultipartAsync(streamProvider); var messages = new List <string>(); foreach (var file in streamProvider.FileData) { var fi = new FileInfo(file.LocalFileName); messages.Add("File uploaded as " + fi.FullName + " (" + fi.Length + " bytes)"); } return(messages); } var response = this.Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid Request!"); throw new HttpResponseException(response); }
static bool AsyncWriteBase64Test(MemoryStream ms, byte[] byteArray, Encoding encoding, MyStreamProvider myStreamProvider) { XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms); writer.WriteStartElement("Root"); Task writeValueBase64Asynctask = writer.WriteBase64Async(byteArray, 0, byteArray.Length); writeValueBase64Asynctask.Wait(); Assert.True(myStreamProvider.StreamReleased, "Error, stream not released."); writer.WriteEndElement(); writer.Flush(); return true; }
static bool WriteTest(MemoryStream ms, ReaderWriterFactory.ReaderWriterType rwType, Encoding encoding, MyStreamProvider myStreamProvider) { XmlWriter writer = ReaderWriterFactory.CreateXmlWriter(rwType, ms, encoding); XmlDictionaryWriter writeD = writer as XmlDictionaryWriter; writeD.WriteStartElement("Root"); writeD.WriteValue(myStreamProvider); if (rwType != ReaderWriterFactory.ReaderWriterType.MTOM) { // stream should be released right after WriteValue Assert.True(myStreamProvider.StreamReleased, "Error, stream not released after WriteValue"); } writer.WriteEndElement(); // stream should be released now for MTOM if (rwType == ReaderWriterFactory.ReaderWriterType.MTOM) { Assert.True(myStreamProvider.StreamReleased, "Error, stream not released after WriteEndElement"); } writer.Flush(); return true; }
public static void StreamProvoiderTest() { List<string> ReaderWriterType = new List<string> { "Binary", //"MTOM", //MTOM methods not supported now. //"MTOM", //"MTOM", "Text", "Text", "Text" }; List<string> Encodings = new List<string> { "utf-8", "utf-8", "utf-16", "unicodeFFFE", "utf-8", "utf-16", "unicodeFFFE" }; for (int i = 0; i < ReaderWriterType.Count; i++) { string rwTypeStr = ReaderWriterType[i]; ReaderWriterFactory.ReaderWriterType rwType = (ReaderWriterFactory.ReaderWriterType) Enum.Parse(typeof(ReaderWriterFactory.ReaderWriterType), rwTypeStr, true); Encoding encoding = Encoding.GetEncoding(Encodings[i]); Random rndGen = new Random(); int byteArrayLength = rndGen.Next(100, 2000); byte[] byteArray = new byte[byteArrayLength]; rndGen.NextBytes(byteArray); MyStreamProvider myStreamProvider = new MyStreamProvider(new MemoryStream(byteArray)); bool success = false; bool successBase64 = false; MemoryStream ms = new MemoryStream(); success = WriteTest(ms, rwType, encoding, myStreamProvider); Assert.True(success); success = ReadTest(ms, encoding, rwType, byteArray); Assert.True(success); if (rwType == ReaderWriterFactory.ReaderWriterType.Text) { ms = new MemoryStream(); myStreamProvider = new MyStreamProvider(new MemoryStream(byteArray)); success = AsyncWriteTest(ms, encoding, myStreamProvider); Assert.True(success); successBase64 = AsyncWriteBase64Test(ms, byteArray, encoding, myStreamProvider); Assert.True(successBase64); } } }
static bool AsyncWriteBase64Test(MemoryStream ms, byte[] byteArray, Encoding encoding, MyStreamProvider myStreamProvider) { XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms); writer.WriteStartElement("Root"); Task writeValueBase64Asynctask = writer.WriteBase64Async(byteArray, 0, byteArray.Length); writeValueBase64Asynctask.Wait(); Assert.True(myStreamProvider.StreamReleased, "Error, stream not released."); writer.WriteEndElement(); writer.Flush(); return(true); }
static bool WriteTest(MemoryStream ms, ReaderWriterFactory.ReaderWriterType rwType, Encoding encoding, MyStreamProvider myStreamProvider) { XmlWriter writer = ReaderWriterFactory.CreateXmlWriter(rwType, ms, encoding); XmlDictionaryWriter writeD = writer as XmlDictionaryWriter; writeD.WriteStartElement("Root"); writeD.WriteValue(myStreamProvider); if (rwType != ReaderWriterFactory.ReaderWriterType.MTOM) { // stream should be released right after WriteValue Assert.True(myStreamProvider.StreamReleased, "Error, stream not released after WriteValue"); } writer.WriteEndElement(); // stream should be released now for MTOM if (rwType == ReaderWriterFactory.ReaderWriterType.MTOM) { Assert.True(myStreamProvider.StreamReleased, "Error, stream not released after WriteEndElement"); } writer.Flush(); return(true); }
public async Task<List<string>> PostAsync(int storyId, int blockId) { sId = storyId.ToString(); bId = blockId.ToString(); if (Request.Content.IsMimeMultipartContent()) { string path = HttpContext.Current.Server.MapPath("~\\App_Data\\Collages.xml"); XDocument doc; doc = XDocument.Load(path); string id = storyId.ToString(); string folderName = HttpContext.Current.Server.MapPath(@"~/Img/" + id); if (!Directory.Exists(folderName)) { System.IO.Directory.CreateDirectory(folderName); } string uploadPath = folderName; MyStreamProvider streamProvider = new MyStreamProvider(uploadPath); await Request.Content.ReadAsMultipartAsync(streamProvider); List<string> messages = new List<string>(); foreach (var file in streamProvider.FileData) { try { FileInfo fi = new FileInfo(file.LocalFileName); messages.Add("File uploaded as " + fi.FullName + " (" + fi.Length + " bytes)"); XElement elem = doc.Element("collages") .Elements("collage") .Elements("story") .Elements("block") .Where(items => items.Element("id").Value == blockId.ToString()).FirstOrDefault(); if (elem.Element("imgPath") == null) { elem.Add(new XElement("imgPath", fi.Name)); } else { elem.Element("imgPath").Value = fi.Name; } doc.Save(path); } catch { return messages; } } return messages; } else { HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid Request!"); throw new HttpResponseException(response); } }
public async Task <List <string> > PostAsync(int storyId, int blockId) { sId = storyId.ToString(); bId = blockId.ToString(); if (Request.Content.IsMimeMultipartContent()) { string path = HttpContext.Current.Server.MapPath("~\\App_Data\\Collages.xml"); XDocument doc; doc = XDocument.Load(path); string id = storyId.ToString(); string folderName = HttpContext.Current.Server.MapPath(@"~/Img/" + id); if (!Directory.Exists(folderName)) { System.IO.Directory.CreateDirectory(folderName); } string uploadPath = folderName; MyStreamProvider streamProvider = new MyStreamProvider(uploadPath); await Request.Content.ReadAsMultipartAsync(streamProvider); List <string> messages = new List <string>(); foreach (var file in streamProvider.FileData) { try { FileInfo fi = new FileInfo(file.LocalFileName); messages.Add("File uploaded as " + fi.FullName + " (" + fi.Length + " bytes)"); XElement elem = doc.Element("collages") .Elements("collage") .Elements("story") .Elements("block") .Where(items => items.Element("id").Value == blockId.ToString()).FirstOrDefault(); if (elem.Element("imgPath") == null) { elem.Add(new XElement("imgPath", fi.Name)); } else { elem.Element("imgPath").Value = fi.Name; } doc.Save(path); } catch { return(messages); } } return(messages); } else { HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid Request!"); throw new HttpResponseException(response); } }
static bool AsyncWriteBase64Test(MemoryStream ms, byte[] byteArray, Encoding encoding, MyStreamProvider myStreamProvider) { XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms); writer.WriteStartElement("Root"); Task writeValueBase64Asynctask = writer.WriteBase64Async(byteArray, 0, byteArray.Length); writeValueBase64Asynctask.Wait(); if (myStreamProvider.StreamReleased) { Console.WriteLine("Ok, stream released right after AsyncWriteValueBase64"); } else { Console.WriteLine("Error, stream not released after AsyncWriteValueBase64"); return false; } writer.WriteEndElement(); writer.Flush(); return true; }