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