public static void UploadImage(IImageFile imageFile, MultipartFileData file = null)
{
try
{
if (GetContainers().ToList().Find(itm => itm == imageFile.GetContainer()) != null)
{
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["StorageConnectionString"]);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(imageFile.GetContainer());
CloudBlockBlob imageBlob = container.GetBlockBlobReference(imageFile.GetFileName());
if (file != null)
{
// Data is in local upload folder
imageBlob.UploadFromFile(file.LocalFileName, FileMode.Open);
}
else
{
// Data is in imageFile FileData
imageBlob.UploadFromByteArray(imageFile.GetFileData(), 0, imageFile.GetFileSize() - 1);
}
}
else
{
throw new Exception("Container not found");
}
}
catch (Exception e)
{
throw e;
}
}
private string GetDeserializedFileName(MultipartFileData fileData)
{
var fileName = GetFileName(fileData);
return(JsonConvert.DeserializeObject(fileName).ToString());
//return JsonConvert.SerializeObject(fileName).ToString();
}
public async Task <string> Upload()
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var root = HttpContext.Current.Server.MapPath("~/temp_files");
if (!Directory.Exists(root))
{
Directory.CreateDirectory(root);
}
var provider = new MultipartFormDataStreamProvider(root);
// Read the form data.
await Request.Content.ReadAsMultipartAsync(provider);
MultipartFileData file = provider.FileData[0];
// var id = new Guid(provider.FormData["id"]);
var fileName = file.Headers.ContentDisposition.FileName.Trim('"');
fileName = Guid.NewGuid() + Path.GetExtension(fileName);
File.Copy(file.LocalFileName, Path.Combine(root, fileName));
var PhotoUrl = "/temp_files/" + fileName;
return(PhotoUrl);
}
public async Task <IHttpActionResult> PostFormData()
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
return(NotFound());
}
string root = HttpContext.Current.Server.MapPath("~/App_Data");
var provider = new MultipartFormDataStreamProvider(root);
try
{
// Read the form data.
await Request.Content.ReadAsMultipartAsync(provider);
bool isDeleteAll = false;
string[] values = provider.FormData.GetValues("IsDelete");
if (values != null && values.Length > 0)
{
isDeleteAll = values[0] == "on" ? true : false;
}
MultipartFileData file = provider.FileData[0];
string fullName = file.LocalFileName;
int rowAffected = await this.roomRepository.BatchImport(file.LocalFileName, isDeleteAll);
return(Ok(rowAffected));
}
catch (System.Exception)
{
return(BadRequest());
}
}
public Task <DataFile> Upload(string database = null)
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
database = ValidateDatabaseName(database);
string root = System.Web.HttpContext.Current.Server.MapPath(DataConfig.uploadDir);
MultipartFormDataStreamProvider provider = new MultipartFormDataStreamProvider(root);
Task <DataFile> task = Request.Content.ReadAsMultipartAsync(provider).ContinueWith(o => {
MultipartFileData data = provider.FileData.First();
string path = data.LocalFileName;
string fileName = data.Headers.ContentDisposition.FileName;
DataFile file = new DataFile(path, fileName, database);
if (file.dataType == DataType.Archive)
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
IDatabaseContext context = DatabaseContextFactory.CreateDatabaseContext(database);
DataLoaderHandler loaderHandler = new DataLoaderHandler(context);
loaderHandler.ImportData(file);
return(file);
});
return(task);
}
public async Task <IHttpActionResult> PostForNewResearch()
{
if (!Request.Content.IsMimeMultipartContent())
{
return(new System.Web.Http.Results.StatusCodeResult(HttpStatusCode.UnsupportedMediaType, Request));
}
string savepath = WebApiApplication.SERVERPATH + "download/research";
var result = new MultipartFormDataStreamProvider(savepath);
Research_detail data = new Research_detail();
try
{
await Request.Content.ReadAsMultipartAsync(result);
//READ JSON DATA PART
JObject datareceive = JObject.Parse(result.FormData.GetValues(result.FormData.AllKeys[0])[0]);
data.curri_id = datareceive["curri_id"].ToString();
data.name = datareceive["name"].ToString();
data.year_publish = Convert.ToInt32(datareceive["year_publish"]);
JArray tlist = (JArray)datareceive["researcher"];
foreach (JObject item in tlist)
{
Teacher_with_t_name t = new Teacher_with_t_name
{
teacher_id = Convert.ToInt32(item["teacher_id"])
};
data.researcher.Add(t);
}
//evidence_real_code evidence_name secret teacher_id
//GET FILENAME WITH CHANGE FILENAME TO HAVE ITS EXTENSION
MultipartFileData file = result.FileData[0];
FileInfo fileInfo = new FileInfo(file.LocalFileName);
string newfilename = string.Format("{0}.{1}", fileInfo.Name.Substring(9), file.Headers.ContentDisposition.FileName.Split('.').LastOrDefault().Split('\"').FirstOrDefault());
data.file_name = "download/research/" + newfilename;
File.Move(string.Format("{0}/{1}", savepath, fileInfo.Name), string.Format("{0}/{1}", savepath, newfilename));
object resultfromdb = await datacontext.InsertNewResearchWithSelect(data);
if (resultfromdb.GetType().ToString() != "System.String")
{
return(Ok(resultfromdb));
}
else
{
if (File.Exists(string.Format("{0}/{1}", savepath, newfilename)))
{
File.Delete(string.Format("{0}/{1}", savepath, newfilename));
}
return(InternalServerError(new Exception(resultfromdb.ToString())));
}
}
catch (System.Exception e)
{
return(InternalServerError(e));
}
}
private async Task <bool> ReadPart(MultipartFormDataStreamProvider provider)
{
try
{
return(await Request.Content.ReadAsMultipartAsync(provider).ContinueWith <bool>(x =>
{
if (x.IsFaulted || x.IsCanceled)
{
return false;
}
ResumableConfiguration configuration = GetUploadConfiguration(x.Result);
int chunkNumber = GetChunkNumber(x.Result);
// Rename generated file
MultipartFileData chunk = x.Result.FileData[0]; // Only one file in multipart message
RenameChunk(chunk, chunkNumber, configuration.Identifier);
// Assemble chunks into single file if they're all here
TryAssembleFile(configuration);
return true;
}));
}
catch
{
return(false);
}
}
//ajout de l'avatar
public async Task <HttpResponseMessage> PostFichier()
{
Utilisateur user = UserHelper.getUser(User, db);
string dataDirectory = "Images/";
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
string root = HttpContext.Current.Server.MapPath("~/" + dataDirectory);
var provider = new MultipartFormDataStreamProvider(root);
HttpResponseMessage ret = new HttpResponseMessage(HttpStatusCode.Created);
try
{
// Read the form data.
await Request.Content.ReadAsMultipartAsync(provider);
if (provider.FileData.Count == 1)
{
MultipartFileData file = provider.FileData.First();
string type = file.Headers.ContentDisposition.Name;
string type2 = type.TrimStart('"');
string[] type3 = type2.Split('_');
string localName = file.LocalFileName.Substring(file.LocalFileName.LastIndexOf("\\") + 1);
string url = Request.RequestUri.AbsoluteUri;
Fichier fichier = new Fichier()
{
Titre = file.Headers.ContentDisposition.FileName,
Chemin = file.LocalFileName,
FichierTypeId = Int32.Parse(type3[0]),
contentType = file.Headers.ContentType.ToString(),
url = ""
};
//Trace.WriteLine(file.Headers.ContentDisposition.FileName);
//Trace.WriteLine("Server file path: " + file.LocalFileName);
user.Fichier = fichier;
await db.SaveChangesAsync();
fichier.url = url.Substring(0, url.IndexOf("api")) + "api/fichiers/" + fichier.Id;
await db.SaveChangesAsync();
return(ret);
}
else
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
}
catch (Exception e)
{
HttpResponseMessage err = new HttpResponseMessage(HttpStatusCode.InternalServerError);
err.Content = new StringContent(e.ToString());
return(err);
}
}
public async Task <string> FileUpload(MultipartFileData file)
{
try
{
var credentials = new StorageCredentials(Constant.AccountName, Constant.AccessKeyValue);
var account = new CloudStorageAccount(credentials, useHttps: true);
var client = account.CreateCloudBlobClient();
var container = client.GetContainerReference("photos");
container.CreateIfNotExists();
container.SetPermissions(new BlobContainerPermissions {
PublicAccess = BlobContainerPublicAccessType.Blob
});
var cloudBlockBlob = container.GetBlockBlobReference(file.Headers.ContentDisposition.FileName.Trim('\"'));
await cloudBlockBlob.UploadFromStreamAsync(File.OpenRead(file.LocalFileName));
var uri = cloudBlockBlob.Uri.AbsoluteUri;
return(uri.ToString());
}
catch (Exception e)
{
Debug.WriteLine(e);
return(null);
}
}
/// <summary>
/// 保存附件信息到数据库
/// </summary>
/// <param name="provider"></param>
/// <param name="folder">保存文件夹</param>
/// <returns></returns>
private Attachment SaveAttchment(PoseidonMultipartFormDataStreamProvider provider, string folder)
{
MultipartFileData file = provider.FileData[0];
Attachment attachment = new Attachment();
attachment.FileName = Path.GetFileName(file.LocalFileName);
attachment.OriginName = file.Headers.ContentDisposition.FileName;
attachment.Extension = Path.GetExtension(file.LocalFileName);
attachment.ContentType = file.Headers.ContentType.MediaType;
attachment.UploadTime = DateTime.Now;
attachment.Size = new FileInfo(file.LocalFileName).Length;
attachment.Folder = folder;
attachment.MD5Hash = Hasher.GetFileMD5Hash(file.LocalFileName);
if (file.Headers.Contains("md5hash"))
{
string md5 = file.Headers.GetValues("md5hash").ToList().First();
if (attachment.MD5Hash != md5)
{
throw new Exception("文件哈希计算不匹配");
}
}
attachment.Name = provider.FormData["name"];
attachment.Remark = provider.FormData["remark"];
BusinessFactory <AttachmentBusiness> .Instance.Create(attachment);
return(attachment);
}
public async Task <HttpResponseMessage> Post()
{
if (!Request.Content.IsMimeMultipartContent() || CurrentSite.Updator.NowBusy)
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
try
{
CurrentSite.Updator.CleanUpPluginUpdateDownloadFolder();
var provider = new MultipartFormDataStreamProvider(CurrentSite.Updator.GetPluginUpdateDownloadFolder());
await Request.Content.ReadAsMultipartAsync(provider);
MultipartFileData fileData = provider.FileData.Single();
string fileName = fileData.Headers.ContentDisposition.FileName.Replace("\"", "");
string newFIleName = Path.Combine(Path.GetDirectoryName(fileData.LocalFileName), fileName);
File.Move(fileData.LocalFileName, newFIleName);
CurrentSite.Updator.UpdatePluginOnly(newFIleName);
}
catch (Exception ex)
{
throw ex;
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
public async Task <IHttpActionResult> PostToAddGalleryWithPicture()
{
if (!Request.Content.IsMimeMultipartContent())
{
return(new System.Web.Http.Results.StatusCodeResult(HttpStatusCode.UnsupportedMediaType, Request));
}
string savepath = WebApiApplication.SERVERPATH + "myImages/gallery";
var result = new MultipartFormDataStreamProvider(savepath);
Gallery_detail data = new Gallery_detail();
try
{
await Request.Content.ReadAsMultipartAsync(result);
//READ JSON DATA PART
JObject datareceive = JObject.Parse(result.FormData.GetValues(result.FormData.AllKeys[0])[0]);
data.curri_id = datareceive["curri_id"].ToString();
data.name = datareceive["name"].ToString();
data.date_created = DateTime.Now.GetDateTimeFormats(new System.Globalization.CultureInfo("en-US"))[5];
data.aca_year = Convert.ToInt32(datareceive["aca_year"]);
data.personnel_id = Convert.ToInt32(datareceive["personnel_id"]);
JArray tlist = (JArray)datareceive["pictures"];
int fileind = 0;
foreach (JObject item in tlist)
{
Picture p = new Picture
{
caption = item["caption"].ToString()
};
MultipartFileData file = result.FileData[fileind++];
FileInfo fileInfo = new FileInfo(file.LocalFileName);
string newfilename = string.Format("{0}.{1}", fileInfo.Name.Substring(9), file.Headers.ContentDisposition.FileName.Split('.').LastOrDefault().Split('\"').FirstOrDefault());
p.file_name = "myImages/gallery/" + newfilename;
File.Move(string.Format("{0}/{1}", savepath, fileInfo.Name), string.Format("{0}/{1}", savepath, newfilename));
data.pictures.Add(p);
}
object resultfromdb = await datacontext.InsertNewGalleryWithSelect(data);
if (resultfromdb.GetType().ToString() != "System.String")
{
return(Ok(resultfromdb));
}
else
{
return(InternalServerError(new Exception(resultfromdb.ToString())));
}
}
catch (System.Exception e)
{
return(InternalServerError(e));
}
}
private TimeSpan GetFileExpiry(MultipartFileData file)
{
if (!file.Headers.Expires.HasValue)
{
return(_commonSettings.FileExpiry);
}
return(file.Headers.Expires.Value - DateTimeOffset.Now);
}
/*
**
** Upload
**
*/
public virtual HttpResponseMessage UploadFile(Client currentClient, Document entity, HttpRequestMessage Request, IHomeRepository homeRepo, IDocumentLogRepository logRepo)
{
MyMultipartFileStreamProvider provider;
Boolean isImage = false;
ValidateNull(entity);
if (entity != null && ((IDocumentRepository)repo).GetDocumentById(entity.Id, currentClient.Id) == null)
{
validationDictionnary.AddModelError(TypeOfName.GetNameFromType <Document>(), GenericError.FORBIDDEN_RESOURCE_OR_DOES_NO_EXIST);
}
if (!((DocumentValidation)validation).UploadValidationBeforeProvider(validationDictionnary, currentClient, entity, Request))
{
throw new ManahostValidationException(validationDictionnary);
}
provider = new MyMultipartFileStreamProvider(ManahostUploadFileSystem.GetUploadFolderPath(WebApiApplication.UPLOAD_FOLDER_ROOT, currentClient.Id, (Boolean)entity.IsPrivate));
try
{
IEnumerable <HttpContent> parts = null;
Task.Factory.StartNew(() => parts = Request.Content.ReadAsMultipartAsync(provider).Result.Contents,
CancellationToken.None,
TaskCreationOptions.LongRunning, // guarantees separate thread
TaskScheduler.Default).Wait();
MultipartFileData file = provider.FileData.First();
if (!((DocumentValidation)validation).UploadValidationAfterProvider(validationDictionnary, currentClient, file))
{
throw new ManahostValidationException(validationDictionnary);
}
if (isImage = ManahostUploadFileSystem.imageExtension.Any(s => entity.Title.EndsWith(s, StringComparison.OrdinalIgnoreCase)))
{
ImageCompressAndThumbnail(file.LocalFileName);
}
if ((Boolean)entity.IsPrivate && currentClient != null)
{
EncryptFileOnUpload(file.LocalFileName, DocumentUtils.GetEncryptionPassword(homeRepo, currentClient), isImage);
}
if (!UpdateEntitiesOnUpload(currentClient, entity, file.LocalFileName, isImage, logRepo))
{
throw new ManahostValidationException(validationDictionnary);
}
}
catch (Exception e)
{
if (validationDictionnary.IsValid)
{
validationDictionnary.AddModelError(String.Format(GenericNames.MODEL_STATE_FORMAT, TypeOfName.GetNameFromType <Document>(), "Upload"), GenericError.INVALID_GIVEN_PARAMETER);
}
if (entity.Url != null)
{
DocumentUtils.DeleteAllFile(entity.Url, isImage);
}
repo.Delete(entity);
repo.Save();
throw new ManahostValidationException(validationDictionnary, e.StackTrace);
}
return(BuildStringContent.BuildFromRequestOK(Request));
}
/// <summary>
/// Upload an image to blob storage but also generate a unique filename
/// </summary>
/// <param name="wolfImageData">MultipartFileData passed as part of the POST request</param>
/// <returns>CloubBlockBlob which has info about the file</returns>
public static async Task <CloudBlockBlob> UploadWolfImageAsync(MultipartFileData wolfImageData)
{
var newFilename = Guid.NewGuid() + Path.GetExtension(wolfImageData.Headers.ContentDisposition.FileName.Replace("\"", ""));
var blockBlob = _originalImageContainer.GetBlockBlobReference(newFilename);
await blockBlob.UploadFromFileAsync(wolfImageData.LocalFileName);
return(blockBlob);
}
public async Task <HttpResponseMessage> Post(string id)
{
try
{
if (!this.Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
string root = HttpContext.Current.Server.MapPath("~/App_Data/" + id + "/");
try
{
Directory.Delete(root, true);
}
catch
{
// can throw error if directory not found
}
// create root path if does not exists
new System.IO.FileInfo(root).Directory.Create();
var provider = new MultipartFormDataStreamProvider(root);
// Read the form data.
await Request.Content.ReadAsMultipartAsync(provider);
MultipartFileData file = null;
string fileName = provider.FileData[0].Headers.ContentDisposition.FileName.Replace("\"", "");
if (!string.IsNullOrWhiteSpace(fileName))
{
file = provider.FileData[0];
}
else
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
if (file != null)
{
//read file data and delete temporary file
string file1 = file.LocalFileName;
string fileNameWithExtension = fileName.Substring(fileName.LastIndexOf('\\') + 1);
// move temp file into dir
File.Copy(file1, root + fileNameWithExtension, true);
System.IO.File.Delete(file1);
HttpResponseMessage resp = Request.CreateResponse(HttpStatusCode.OK);
resp.Content = new StringContent(root + fileNameWithExtension);
resp.Content.Headers.ContentType = new MediaTypeHeaderValue("text/html");
return(resp);
}
}
catch (System.Exception e)
{
_tracer.Error(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, e.StackTrace);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
return(new HttpResponseMessage(HttpStatusCode.InternalServerError));
}
public async Task <IHttpActionResult> PutForUpload()
{
if (!Request.Content.IsMimeMultipartContent())
{
return(new System.Web.Http.Results.StatusCodeResult(HttpStatusCode.UnsupportedMediaType, Request));
}
string savepath = WebApiApplication.SERVERPATH + "download/aunbook";
var result = new MultipartFormDataStreamProvider(savepath);
try
{
await Request.Content.ReadAsMultipartAsync(result);
//READ JSON DATA PART
JObject datareceive = JObject.Parse(result.FormData.GetValues(result.FormData.AllKeys[0])[0]);
datacontext.aca_year = Convert.ToInt32(datareceive["aca_year"]);
datacontext.curri_id = datareceive["curri_id"].ToString();
datacontext.date = DateTime.Now.GetDateTimeFormats(new System.Globalization.CultureInfo("en-US"))[5];
datacontext.personnel_id = Convert.ToInt32(datareceive["personnel_id"]);
//GET FILENAME WITH CHANGE FILENAME TO HAVE ITS EXTENSION
MultipartFileData file = result.FileData[0];
FileInfo fileInfo = new FileInfo(file.LocalFileName);
string newfilename = string.Format("{0}.{1}", fileInfo.Name.Substring(9), file.Headers.ContentDisposition.FileName.Split('.').LastOrDefault().Split('\"').FirstOrDefault());
datacontext.file_name = "download/aunbook/" + newfilename;
File.Move(string.Format("{0}/{1}", savepath, fileInfo.Name), string.Format("{0}/{1}", savepath, newfilename));
string oldfilename = datacontext.file_name;
object resultfromdb = await datacontext.InsertOrUpdate();
if (resultfromdb == null)
{
string delpath = WebApiApplication.SERVERPATH;
//Check whether file name property chenge? (Changes mean there is to-be delete file)
if (datacontext.file_name != oldfilename)
{
//Check whether file exists!
if (File.Exists(string.Format("{0}{1}", delpath, datacontext.file_name)))
{
File.Delete(string.Format("{0}{1}", delpath, datacontext.file_name));
}
}
return(Ok());
}
else
{
return(InternalServerError(new Exception(resultfromdb.ToString())));
}
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
public ActionResult Upload(PhotoData model)
{
ViewBag.Message = "Your application description page.";
if (model != null)
{
MultipartFileData f = model.image;
string vendorId = model.vendorId;
}
return(View());
}
} // DownloadDirs
private async Task saveUpload(Guid clientId, Guid noteId, MultipartFileData fileData)
{
var uploadDir = await openFileShare();
var shareDir = uploadDir.GetDirectoryReference(clientId.ToString());
await shareDir.CreateIfNotExistsAsync();
var shareFile = shareDir.GetFileReference(noteId.ToString());
await shareFile.UploadFromFileAsync(fileData.LocalFileName, FileMode.Open);
} // saveUpload
public KerkesRequest(MultipartFormDataStreamProvider provider)
{
Id = provider.FormData.GetValues("Id").FirstOrDefault();
Titulli = provider.FormData.GetValues("Titulli").FirstOrDefault();
StatusId = provider.FormData.GetValues("StatusId").FirstOrDefault();
Pershkrimi = provider.FormData.GetValues("Pershkrimi").FirstOrDefault();
Dokumenti = provider.FileData.FirstOrDefault();
DataKerkeses = provider.FormData.GetValues("DataKerkeses").FirstOrDefault();
DataPerfundimit = provider.FormData.GetValues("DataPerfundimit").FirstOrDefault();
}
private string GenerateFileName(MultipartFileData fileData)
{
string fileName = GetDeserializedFileName(fileData);
if (!string.IsNullOrEmpty(fileName))
{
fileName = string.Format("{0}{1}", Guid.NewGuid().ToString("N").ToString(), Path.GetExtension(fileName));
}
return(fileName);
}
public async Task <HttpResponseMessage> Post(string nameIdentifier)
{
try
{
Check.IsNotEmptyOrWhiteSpace(nameIdentifier, "nameIdentifier");
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
string root = Path.GetTempPath();
MultipartFormDataStreamProvider streamProvider = new MultipartFormDataStreamProvider(root);
await Request.Content.ReadAsMultipartAsync(streamProvider);
MultipartFileData multipartFileData = streamProvider.FileData.First();
byte[] fileContent;
using (FileStream fileSource = new FileStream(multipartFileData.LocalFileName, FileMode.Open, FileAccess.Read))
{
fileContent = await fileSource.GetBytesAsync();
}
string fileName = multipartFileData.Headers.ContentDisposition.FileName.Trim(new char[] { '\"' });
string fileExtension = Path.GetExtension(fileName);
string contentType = MimeMapping.GetMimeMapping(fileName);
Task.Factory.StartNew(() => System.IO.File.Delete(multipartFileData.LocalFileName));
User impersonatedUser = IdentityHelper.GetUser(this.userService, nameIdentifier);
this.fileService.ValidateForUpload(fileName, impersonatedUser.UserId);
DataFile dataFile = new DataFile
{
FileContent = fileContent,
ContentType = contentType,
FileName = fileName,
CreatedBy = impersonatedUser.UserId,
FileExtentsion = fileExtension
};
IFileHandler fileHandler = this.fileHandlerFactory.GetFileHandler(contentType, impersonatedUser.UserId);
var uploadedDataDetails = fileHandler.Upload(dataFile);
if (!uploadedDataDetails.Any() || uploadedDataDetails.Any(dd => dd.FileDetail.FileId == 0))
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, MessageStrings.UploadFailed));
}
return(Request.CreateResponse <IEnumerable <DataDetail> >(HttpStatusCode.OK, uploadedDataDetails));
}
catch (ArgumentException ex)
{
message = string.Format(CultureInfo.CurrentCulture, MessageStrings.Argument_Error_Message_Template, ex.ParamName);
status = HttpStatusCode.BadRequest;
}
return(Request.CreateErrorResponse(status, message));
}
public async Task <string> UploadPresentationImage(int id)
{
string ret = null;
int maxSizeKb = 1024;
string root = string.Empty;
string format = string.Empty;
MultipartFileData file = null;
string fileName = string.Empty;
string targetFileName = string.Empty;
string originalPhysicalPath = string.Empty;
MultipartFormDataStreamProvider provider = null;
if (id > 0)
{
if (!this.Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
root = System.Web.HttpContext.Current.Server.MapPath("~/App_Data/Uploads");
provider = new MultipartFormDataStreamProvider(root);
await this.Request.Content.ReadAsMultipartAsync(provider);
file = provider.FileData.FirstOrDefault();
if (file != null)
{
originalPhysicalPath = file.LocalFileName;
if (File.Exists(originalPhysicalPath))
{
if ((new FileInfo(originalPhysicalPath).Length / maxSizeKb) > maxSizeKb || string.IsNullOrEmpty((format = GetImageFormat(originalPhysicalPath))))
{
File.Delete(originalPhysicalPath);
}
else
{
fileName = string.Format("{0}.{1}", id, format);
targetFileName = Path.Combine(Path.GetDirectoryName(originalPhysicalPath), fileName);
if (File.Exists(targetFileName))
{
File.Delete(targetFileName);
}
File.Move(originalPhysicalPath, targetFileName);
ret = string.Format("{0}://{1}/static/{2}", Request.RequestUri.Scheme, Request.RequestUri.Host, fileName);
}
}
}
}
return(ret);
}
private void RenameChunk(MultipartFileData chunk, int chunkNumber, string identifier)
{
string sGeneratedFileName = chunk.LocalFileName;
string sChunkFileName = GetChunkFileName(chunkNumber, identifier);
if (File.Exists(sChunkFileName))
{
File.Delete(sChunkFileName);
}
File.Move(sGeneratedFileName, sChunkFileName);
}
public static IImageFile CreateFullImageModel(string container, string fileName, Collection <MultipartFileData> fileData)
{
MultipartFileData file = fileData[0];
var fileBytes = File.ReadAllBytes(file.LocalFileName.ToString());
var fileSize = fileBytes.Length;
var imageFile = CreateImageModel(container, fileName, fileSize, file.Headers.ContentType.ToString());
imageFile.SetFileData(fileBytes);
return(imageFile);
}
public void RenameChunk(MultipartFileData chunk, int chunkNumber, string identifier)
{
var generatedFileName = chunk.LocalFileName;
var chunkFileName = GetChunkFileName(chunkNumber, identifier);
if (File.Exists(chunkFileName))
{
File.Delete(chunkFileName);
}
File.Move(generatedFileName, chunkFileName);
}
public static string GetImagePathFromRequest(MultipartFileData image, string mapPath)
{
string imagePath = null;
var imageFileName = Path.GetFileName(image.LocalFileName + (".jpg"));
imagePath = NextAvailableFilename(Path.Combine(HostingEnvironment.MapPath(ConfigurationManager.AppSettings[mapPath]), imageFileName));
File.Move(image.LocalFileName, imagePath);
imagePath = Path.GetFileName(imagePath);
return(imagePath);
}
public async Task <string> PostAsync()
{
/*var task = this.Request.Content.ReadAsStreamAsync();
* task.Wait();
* Stream requestStream = task.Result;*/
try
{
string root = HttpContext.Current.Server.MapPath("~/App_Data");
var provider = new MultipartFormDataStreamProvider(root);
await Request.Content.ReadAsMultipartAsync(provider);
MultipartFileData file = provider.FileData[0];
string filename = file.LocalFileName;
string newfilename = file.Headers.ContentDisposition.FileName.Trim(new char[] { '\"' });
string newfilepath = root + '\\' + newfilename;
try
{
File.Delete(newfilepath);
File.Move(filename, newfilepath);
}
catch (Exception e)
{
Trace.WriteLine(e);
}
try
{
using (Mat src = new Mat(newfilepath, ImreadModes.Color))
using (Mat gray = new Mat())
using (Mat dst = src.Clone())
{
Cv2.CvtColor(src, gray, ColorConversionCodes.BGR2GRAY);
MSER mser = MSER.Create();
Point[][] msers;
Rect[] bboxes;
mser.DetectRegions(gray, out msers, out bboxes);
}
}
catch (Exception e)
{
Trace.WriteLine(e);
}
}
catch (IOException)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
return(JsonConvert.SerializeObject(new { Dummy = "descriptor" }));
}
///
// Add the constructors you need and call base
//
public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
{
string filename = GetLocalFileName(headers);
string localFilePath = Path.Combine(_rootPath, Path.GetFileName(filename));
// Add local file name
MultipartFileData fileData = new MultipartFileData(headers, localFilePath);
_fileData.Add(fileData);
var stream = File.Create(localFilePath, _bufferSize, FileOptions.Asynchronous);
return(new CryptoStream(stream, new FromBase64Transform(), CryptoStreamMode.Write));
}
public async Task <IHttpActionResult> CreateOrganisation()
{
string root = HttpContext.Current.Server.MapPath("~/App_Data");
var provider = new MultipartFormDataStreamProvider(root);
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var name = "";
var email = "";
MultipartFileData picture = null;
try
{
await Request.Content.ReadAsMultipartAsync(provider);
name = provider.FormData.Get("name");
email = provider.FormData.Get("email");
if (provider.FileData.Count != 0)
{
picture = provider.FileData[0];
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
User user = _userManager.ReadUser(email);
if (user.Organisation != null)
{
return(BadRequest("You already have an organisation"));
}
string imagePath = null;
if (picture != null && picture.LocalFileName.Length > 0)
{
imagePath = FileHelper.GetImagePathFromRequest(picture, "OrganisationsImgPath");
}
Organisation org = _userManager.CreateOrganisation(name, imagePath, user);
return(Ok(org.Id));
}
public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
{
if (parent == null)
{
throw Error.ArgumentNull("parent");
}
if (headers == null)
{
throw Error.ArgumentNull("headers");
}
string localFilePath;
try
{
string filename = this.GetLocalFileName(headers);
localFilePath = Path.Combine(this._rootPath, Path.GetFileName(filename));
}
catch (Exception e)
{
throw Error.InvalidOperation(e, Resources.MultipartStreamProviderInvalidLocalFileName);
}
// Add local file name
MultipartFileData fileData = new MultipartFileData(headers, localFilePath);
this._fileData.Add(fileData);
return File.Create(localFilePath, this._bufferSize, FileOptions.Asynchronous);
}
