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;
}
