public HttpResponseMessage Upload(HttpRequestMessage request, int deviceId)
{
return(CreateHttpResponseMessage(request, () =>
{
HttpResponseMessage response = null;
var device = _deviceService.GetDevice(deviceId);
if (device == null)
{
response = request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid device.");
}
else
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Content/images/devices");
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart
Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string _localFileName = multipartFormDataStreamProvider
.FileData.Select(m => m.LocalFileName).FirstOrDefault();
// Create response
FileUploadResult result = new FileUploadResult
{
LocalFilePath = _localFileName,
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length
};
// Update database
device.Image = result.FileName;
_deviceService.UpdateDevice(device);
response = request.CreateResponse(HttpStatusCode.OK, result);
}
return response;
}));
}
public async Task <IHttpActionResult> Upload()
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Assets/imgs/ProfileImages");
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
var localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
var fileName = Path.GetFileName(localFileName);
var tmbPath = $"{uploadPath}/tmbs/{fileName}";
ImagesHelper.ToTmb(localFileName, tmbPath);
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
user.PathToPhoto = $"/Assets/imgs/ProfileImages/{fileName}";
user.PathToTmbOfPhoto = $"/Assets/imgs/ProfileImages/tmbs/{fileName}";
var response = await UserManager.UpdateAsync(user);
return(response.Succeeded
? Ok(new { Msg = response.Errors, IsOk = response.Succeeded })
: GetErrorResult(response));
}
public async Task <string> UploadPublicPicture()
{
HttpFileCollection filecol = HttpContext.Current.Request.Files;
PictureValidation.GetInstance().CompleteValidations(filecol);
string uploadPath = PictureHandling.GetInstance().HandlingUpdatePublicDirectories();
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string _localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
//string a = uploadPath.Substring(uploadPath.LastIndexOf("PublicPictures"));
//a = a.Substring(a.IndexOf("\\"));
return(JsonConvert.SerializeObject(new FileResult
{
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length,
LocalFilePath = Cryptography.Encrypt(_localFileName),
}));
}
public HttpResponseMessage UploadImage(HttpRequestMessage request, int employeeId)
{
return(CreateHttpResponseMessage(request, () =>
{
HttpResponseMessage response = null;
var employee = _employeeService.GetEmployee(employeeId);
if (employee == null)
{
response = request.CreateErrorResponse(HttpStatusCode.NotFound, "Employee not found.");
}
else
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Content/images/employees");
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read MIME multipart
Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string _localFileName = multipartFormDataStreamProvider
.FileData.Select(m => m.LocalFileName).FirstOrDefault();
// Create Response
FileUploadResult result = new FileUploadResult
{
LocalFilePath = _localFileName,
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length
};
employee.Image = result.FileName;
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK, result);
}
return response;
}));
}
public async Task <string> UploadPrivatePicture()
{
HttpFileCollection filecol = HttpContext.Current.Request.Files;
PictureValidation.GetInstance().CompleteValidations(filecol);
string username = User.Identity.Name;
string uploadPath = PictureHandling.GetInstance().HandlingUpdatePrivateDirectories(username);
//var uploadPath = HttpContext.Current.Server.MapPath("~/Uploads");
// Generate a provider with a custom class, passing the path( later pass the path to base class).
// This support a multipart upload.
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string _localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
//_localFileName = Cryptography.Decrypt(_localFileName);
//Encrypt
//_localFileName = Cryptography.Encrypt(_localFileName);
// Create response
return(JsonConvert.SerializeObject(new FileResult
{
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length,
LocalFilePath = Cryptography.Encrypt(_localFileName),
}));
}
public async Task <IEnumerable <ImageViewModel> > Add(HttpRequestMessage request)
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Content/images/movies");
var provider = new UploadMultipartFormProvider(uploadPath);
await request.Content.ReadAsMultipartAsync(provider);
var images = new List <ImageViewModel>();
foreach (var file in provider.FileData)
{
var fileInfo = new FileInfo(file.LocalFileName);
images.Add(new ImageViewModel
{
FileName = fileInfo.Name,
CreateDate = fileInfo.CreationTime,
LocalFilePath = fileInfo.DirectoryName,
FileLength = fileInfo.Length / 1024
});
}
return(images);
}
public async Task <IHttpActionResult> Upload(HttpRequestMessage request)
{
//_requiredRepositories = new List<Type>() { typeof(Movie) };
#region Thread
var photos = new List <FileUploadResult>();
HttpResponseMessage response = null;
IHttpActionResult responseMG = null;
var uploadPath = HttpContext.Current.Server.MapPath("~/Content/images/movies");
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
await request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
//string _localFileName = multipartFormDataStreamProvider.FileData.Select(multiData => multiData.LocalFileName).FirstOrDefault();
foreach (var file in multipartFormDataStreamProvider.FileData)
{
var fileInfo = new FileInfo(file.LocalFileName);
photos.Add(new FileUploadResult
{
LocalFilePath = file.LocalFileName,
FileName = fileInfo.Name,
FileLength = fileInfo.Length / 1024
});
}
response = request.CreateResponse(HttpStatusCode.OK, photos);
responseMG = ResponseMessage(response);
return(responseMG);
#endregion Thread
//return CreateHttpResponse(request, _requiredRepositories, async () =>
//{
// HttpResponseMessage response = null;
// var uploadPath = HttpContext.Current.Server.MapPath("~/Content/images/movies");
// var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// await request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
// string _localFileName = multipartFormDataStreamProvider.FileData.Select(multiData => multiData.LocalFileName).FirstOrDefault();
// FileUploadResult fileUploadResult = new FileUploadResult()
// {
// LocalFilePath = _localFileName,
// FileName = Path.GetFileName(_localFileName),
// FileLength = new FileInfo(_localFileName).Length
// };
// response = request.CreateResponse(HttpStatusCode.OK, fileUploadResult);
// return response;
//});
}
public async Task <FileUploadResult> Post()
{
try
{
// Получаем из заголовков идентификатор пользователя
var userId = Request.Headers.GetValues("userId").ToArray <string>()[0];
// Получаем папку для загрузки файлов пользователя
var uploadFolder = ConfigurationManager.AppSettings["UploadsFolder"];
// Формируем путь для загрузки файлов пользователя
var uploadPath = string.Format("{0}/{1}", uploadFolder, userId);
// Если директория не существует, то создает ее
if (!Directory.Exists(uploadPath))
{
Directory.CreateDirectory(uploadPath);
}
// Создаем провайдер загрузки
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Асинхронно читаем данные
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
// Получаем имя файла
string localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
// Создаем ответ клиенту
var result = new FileUploadResult
{
LocalFilePath = localFileName,
FileName = Path.GetFileName(localFileName),
FileLength = new FileInfo(localFileName).Length
};
// Получаем данные о загружаемом файле
var tags = multipartFormDataStreamProvider.FormData;
// Формируем объект класса файл из полученных данных о файле
var musicFile = new MusicFile()
{
id = Guid.Parse(tags["fileGuid"]),
localDevicePathUpload = Path.Combine(tags["filePath"], tags["filename"]),
path = Path.Combine(uploadPath, Path.GetFileName(localFileName)),
userId = Guid.Parse(userId)
};
// Добавляем в БД информацию о принятом файле
musicFile.registerFile();
// Возвращаем результат загрузки клиенту
return(result);
}
catch (Exception ex)
{
var str = ex.Message;
}
return(null);
}
public async Task <HttpResponseMessage> UploadCampaignImage(HttpRequestMessage request, int userId, int campaignId)
{
var camapaign = _studentApi.GetSingleCampaign(campaignId);
if (camapaign == null)
{
return(null);
}
var imagePath = HttpContext.Current.Server.MapPath("~/Content/BursifyUploads/" + userId + "/images");
var directory = new DirectoryInfo(imagePath);
if (!directory.Exists)
{
directory.Create();
}
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(directory.FullName);
// Read the MIME multipart asynchronously
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
var localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).ToList();
var nameOfFile = localFileName[0];
// Create response
if (nameOfFile == null)
{
return(null);
}
var fileUploadResult = new FileUploadResult
{
LocalFilePath = nameOfFile,
FileName = Path.GetFileName(nameOfFile),
FileLength = new FileInfo(nameOfFile).Length
};
camapaign.PicturePath = fileUploadResult.FileName;
//update the user in the database
_studentApi.SaveCampaign(camapaign);
var response = request.CreateResponse(HttpStatusCode.OK, fileUploadResult);
return(response);
}
public HttpResponseMessage Post(HttpRequestMessage request, int movieId)
{
_requiredRepositories = new List <Type>()
{
typeof(Movie)
};
return(CreateHttpResponse(request, _requiredRepositories, () =>
{
HttpResponseMessage response = null;
var movieOld = _moviesRepository.GetSingle(movieId);
if (movieOld == null)
{
response = request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid movie.");
}
else
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Content/images/movies");
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously
Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string _localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
// Create response
FileUploadResult fileUploadResult = new FileUploadResult
{
LocalFilePath = _localFileName,
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length
};
// update database
movieOld.Image = fileUploadResult.FileName;
_moviesRepository.Edit(movieOld);
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK, fileUploadResult);
}
return response;
}));
}
public async Task <FileUploadResult> Post()
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Storage");
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string localFileName = multipartFormDataStreamProvider.FileData.Select(m => m.LocalFileName).FirstOrDefault();
return(new FileUploadResult
{
LocalFilePath = localFileName,
FileName = Path.GetFileName(localFileName),
FileLength = new FileInfo(localFileName).Length
});
}
public async Task <string> UploadPublicPictureCompresser()
{
HttpFileCollection filecol = HttpContext.Current.Request.Files;
PictureValidation.GetInstance().CompleteValidations(filecol);
string uploadPath = PictureHandling.GetInstance().HandlingUpdatePublicDirectories();
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string _localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
string withoutextension = _localFileName.Split('.')[0];
#region Qualitier
var qualitiesparam = HttpContext.Current.Request.Params["qualitier"];
Qualitiers q = JsonConvert.DeserializeObject <Qualitiers>(qualitiesparam);
#endregion
using (System.IO.MemoryStream ms = PictureHandling.GetInstance().Resize(_localFileName, q))
{
////with no compress;
//Image img = System.Drawing.Image.FromStream(ms);
//img.Save(withoutextension + "-th" + ".jpg");
//with compress;
Image img = System.Drawing.Image.FromStream(ms);
EncoderParameters eps = new EncoderParameters(1);
eps.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 90L);
string mimetype = GetMimeType(new System.IO.FileInfo(_localFileName).Extension);
ImageCodecInfo ici = GetEncoderInfo(mimetype);
img.Save(withoutextension + "-th" + ".jpg", ici, eps);
}
return(JsonConvert.SerializeObject(new FileResult
{
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length,
LocalFilePath = Cryptography.Encrypt(_localFileName),
}));
}
public async Task <FileUploadResult> Post()
{
try
{
var path = "~/App_Data/uploads";
if (Request.Headers.Contains("userId"))
{
path += "/" + Request.Headers.GetValues("userId").ToArray <string>()[0];
}
// Получаем путь
var uploadPath = HttpContext.Current.Server.MapPath(path);
// Если директория не существует, то создает ее
if (!Directory.Exists(uploadPath))
{
Directory.CreateDirectory(uploadPath);
}
// Создаем провайдер загрузки
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Асинхронно читаем данные
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
// Получаем имя файла
string localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
// Create response
return(new FileUploadResult
{
LocalFilePath = localFileName,
FileName = Path.GetFileName(localFileName),
FileLength = new FileInfo(localFileName).Length
});
}
catch (Exception ex)
{
var str = ex.Message;
}
return(null);
}
public async Task <string> UploadPrivateDocument()
{
HttpFileCollection filecol = HttpContext.Current.Request.Files;
DocumentValidation.GetInstance().CompleteValidations(filecol);
string username = User.Identity.Name;
string uploadPath = DocumentHandling.GetInstance().HandlingUpdatePrivateDirectories(username);
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string _localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
return(JsonConvert.SerializeObject(new FileResult
{
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length,
LocalFilePath = Cryptography.Encrypt(_localFileName),
}));
}
public async Task <NewDocumentResponse> AddPhoto()
{
try
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Uploads");
if (!Directory.Exists(uploadPath))
{
Directory.CreateDirectory(uploadPath);
}
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
//var ownerEmail = this.Request.Headers.FirstOrDefault(k => k.Key == "ownerEmail").Value.First();
// Read the MIME multipart asynchronously
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
var _localFileName = multipartFormDataStreamProvider.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
var thumbPath = this.CreateThumbnail(_localFileName);
var doc = new Document();
using (DataBaseContext db = new DataBaseContext())
{
doc.Name = Path.GetFileName(_localFileName);
//doc.User = db.Users.Single(u => u.Email == ownerEmail);
doc.Path = _localFileName;
doc.ThubnailPath = thumbPath;
db.Documents.Add(doc);
db.SaveChanges();
}
// Create response
return(new NewDocumentResponse()
{
ID = doc.Id, Link = this.ToUrl(doc.Path), Thumbnail = this.ToUrl(doc.ThubnailPath), Success = true
});
}
catch (Exception ex)
{
return(new NewDocumentResponse {
ErrorMessage = ex.ToString()
});
}
}
public HttpResponseMessage Post(HttpRequestMessage request, int movieId)
{
HttpResponseMessage response = null;
var movie = movieService.GetMovie(movieId);
if (movie == null)
{
response = request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid movie.");
}
else
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Content/images");
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously
Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string _localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
// Create response
FileUploadResult fileUploadResult = new FileUploadResult
{
LocalFilePath = _localFileName,
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length
};
// update database
movie.Image = fileUploadResult.FileName;
movieService.UpdateMovie(movie);
response = request.CreateResponse(HttpStatusCode.OK, fileUploadResult);
}
return(response);
}
public async Task <HttpResponseMessage> PostAsync(HttpRequestMessage request, int productId)
{
HttpResponseMessage response = null;
var productOld = _productRepository.GetSingleProduct(productId);
if (productOld == null)
{
response = request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid product.");
}
else
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Content/images/movies");
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string _localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
// Create response
FileUploadResult fileUploadResult = new FileUploadResult
{
LocalFilePath = _localFileName,
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length
};
// update database
productOld.ImageURI = fileUploadResult.FileName;
_productRepository.UpdateProduct(productOld, productOld.Id);
response = request.CreateResponse(HttpStatusCode.OK, fileUploadResult);
}
return(response);
}
public async Task <FileUploadResult> UploadFile(string userEmail)
{
string _localFileName = "";
string folderName = "";
try
{
folderName = Guid.NewGuid().ToString();
// Prepare a path in which the result file will be
string uploadPath = AppSettings.WorkingDirectory + "/" + folderName;
// Check directroy already exist or not
if (!Directory.Exists(uploadPath))
{
Directory.CreateDirectory(uploadPath);
}
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
_localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
}
catch (Exception)
{
}
// Create response
return(new FileUploadResult
{
LocalFilePath = _localFileName,
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length,
FolderId = folderName
});
}
public async Task <HttpResponseMessage> PostAsync(HttpRequestMessage request, int movieId)
{
HttpResponseMessage response = null;
var movieOld = _moviesRepository.GetSingle(movieId);
if (movieOld == null)
{
response = request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid movie.");
}
else
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Content/images/movies");
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
var localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
// Create response
var fileUploadResult = new FileUploadResult
{
LocalFilePath = localFileName,
FileName = Path.GetFileName(localFileName),
FileLength = new FileInfo(localFileName).Length
};
// update database
movieOld.Image = fileUploadResult.FileName;
_moviesRepository.Edit(movieOld);
_unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK, fileUploadResult);
}
return(response);
}
public async Task <FileUploadResult> Post()
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Uploads");
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string _localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
// Create response
return(new FileUploadResult
{
LocalFilePath = _localFileName,
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length
});
}
public async Task <HttpResponseMessage> Post(HttpRequestMessage request, String entity)
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Resources/" + entity);
Directory.CreateDirectory(uploadPath);
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
var _localFileName = multipartFormDataStreamProvider.FileData.
Select(multiPartData => multiPartData.LocalFileName).
FirstOrDefault();
FileUploadResult fileUploadResult = new FileUploadResult {
LocalFilePath = _localFileName,
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length
};
var response = request.CreateResponse(HttpStatusCode.OK, fileUploadResult);
return(response);
}
public async Task <IEnumerable <FileUploadResult> > Post()
{
var uploadPath = HttpContext.Current.Server.MapPath(_uploadFolder);
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
var fileInfo = multipartFormDataStreamProvider.FileData.Select(i => {
var info = new FileInfo(i.LocalFileName);
return(new FileUploadResult()
{
FileName = info.Name,
LocalFilePath = uploadPath + "/" + _uploadFolder + "/" + info.Name,
FileLength = info.Length / 1024
});
});
// Create response
return(fileInfo);;
}
public async Task <IHttpActionResult> Upload()
{
try
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var paths = GetUploadPath();
if (!Directory.Exists(paths.Item1))
{
Directory.CreateDirectory(paths.Item1);
}
var uploadProvider = new UploadMultipartFormProvider(paths.Item1);
var result = await Request.Content.ReadAsMultipartAsync(uploadProvider);
var originalFileName = GetDeserializedFileName(result.FileData.First());
var file = new FileDTO
{
Description = originalFileName,
FilePath = paths.Item2 + result.FileData.First().LocalFileName.Replace(paths.Item1, ""),
Size = new FileInfo(result.FileData.First().LocalFileName).Length
};
var uploadedFile = fileService.Add(file);
return(Json(uploadedFile, BOT_SERIALIZER_SETTINGS));
}
catch (Exception e)
{
throw new ApplicationException(e.Message);
}
}
public HttpResponseMessage Post(HttpRequestMessage request, int movieId)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
var movieOld = this.moviesRepo.GetSingle(movieId);
if (movieOld == null)
{
response = request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid movie.");
}
else
{
var uploadPath = HttpContext.Current.Server.MapPath("~/Content/images/movies");
var multipartFormDataSP = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously.
Request.Content.ReadAsMultipartAsync(multipartFormDataSP);
string localFileName = multipartFormDataSP.FileData.Select(m => m.LocalFileName).FirstOrDefault();
//Create response.
FileUploadResult fileUploadResult = new FileUploadResult
{
LocalFilePath = localFileName,
FileName = Path.GetFileName(localFileName),
FileLength = new FileInfo(localFileName).Length
};
// Update db
movieOld.Image = fileUploadResult.FileName;
this.moviesRepo.Edit(movieOld);
this.unitOfWork.Commit();
response = request.CreateResponse(HttpStatusCode.OK, fileUploadResult);
}
return response;
}));
}
public async Task<IHttpActionResult> Upload()
{
try
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var paths = GetUploadPath();
if (!Directory.Exists(paths.Item1))
{
Directory.CreateDirectory(paths.Item1);
}
var uploadProvider = new UploadMultipartFormProvider(paths.Item1);
var result = await Request.Content.ReadAsMultipartAsync(uploadProvider);
var originalFileName = GetDeserializedFileName(result.FileData.First());
var file = new FileDTO
{
Description = originalFileName,
FilePath = paths.Item2 + result.FileData.First().LocalFileName.Replace(paths.Item1, ""),
Size = new FileInfo(result.FileData.First().LocalFileName).Length
};
var uploadedFile = fileService.Add(file);
return Json(uploadedFile, BOT_SERIALIZER_SETTINGS);
}
catch (Exception e)
{
throw new ApplicationException(e.Message);
}
}
public async Task <FileUploadResult> UploadExcel(string vAGT_CODE)
{
try
{
var uploadPath = CommissionSystemREST.Properties.Settings.Default.Commission_Docs;
string year = DateTime.Now.Year.ToString();
var dbSavePath = "/" + year + "/" + vAGT_CODE;
uploadPath = uploadPath + "/" + year + "/" + vAGT_CODE;
if (!Directory.Exists(uploadPath))
{
System.IO.Directory.CreateDirectory(uploadPath);
}
var multipartFormDataStreamProvider = new UploadMultipartFormProvider(uploadPath);
// Read the MIME multipart asynchronously
await Request.Content.ReadAsMultipartAsync(multipartFormDataStreamProvider);
string AgentCode = multipartFormDataStreamProvider.FormData["AgentCode"];
string DocTypeID = multipartFormDataStreamProvider.FormData["DocTypeID"];
string UserID = multipartFormDataStreamProvider.FormData["UserID"];
string DocDescription = multipartFormDataStreamProvider.FormData["DocDescription"];
string _localFileName = multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.LocalFileName).FirstOrDefault();
dbSavePath = dbSavePath + "/" + multipartFormDataStreamProvider
.FileData.Select(multiPartData => multiPartData.Headers.ContentDisposition.FileName).FirstOrDefault().Replace("\"", "");
DataTable Dt = ConvertExceltoDatatable(_localFileName, vAGT_CODE, UserID); // DPTSManualUpload / ReceiptManualUpload
if (vAGT_CODE == "DPTSManualUpload")
{
BulkCopyDPTS(Dt, UserID);
}
else if (vAGT_CODE == "ReceiptManualUpload")
{
BulkCopyRECEIPT(Dt);
}
UploadDoc uploadedDoc = new UploadDoc();
uploadedDoc.Id = 0;
uploadedDoc.AgtCode = AgentCode;
uploadedDoc.DocTypeId = Convert.ToInt32(DocTypeID);
uploadedDoc.DocUrl = dbSavePath;
uploadedDoc.CreatedBy = UserID;
uploadedDoc.CreatedDate = null;
uploadedDoc.EffectiveEndDate = null;
uploadedDoc.DocDescription = vAGT_CODE; // DPTSManualUpload / ReceiptManualUpload
SaveUploadDocl(uploadedDoc);
// Create response
return(new FileUploadResult
{
LocalFilePath = _localFileName,
FileName = Path.GetFileName(_localFileName),
FileLength = new FileInfo(_localFileName).Length
});
}
catch (Exception ex)
{
throw;
}
}
