/// <summary> /// Get uploaded count /// </summary> /// <param name="aSessionId">Session identifier</param> /// <param name="aMimeTypeId">Mime type identifier</param> /// <returns>Uploaded count</returns> public async Task <int> GetUploadedCountAsync(string aSessionId, MimeTypeId aMimeTypeId) { return(await _hrEntities.SpontaneousResumes.CountAsync( resume => resume.SessionId == aSessionId && resume.FileType == aMimeTypeId.ToString()) .ConfigureAwait(false)); }
public async Task <IHttpActionResult> PostAsync(MimeTypeId mimeId) { if (!Request.Content.IsMimeMultipartContent()) { return(BadRequest(Resources.UploadingNotSupported)); } var context = HttpContext.Current; #region Checking the upload limit var sessionId = context.GetSessionId(); var uploadCount = await _resumeManagerRepository.GetUploadedCountAsync(sessionId, mimeId).ConfigureAwait(false); if (uploadCount >= mimeId.GetUploadLimit()) { return(BadRequest(string.Format(Resources.ExceededUploadedLimit, mimeId))); } #endregion var provider = new MultipartMemoryStreamProvider(); await Request.Content.ReadAsMultipartAsync(provider).ConfigureAwait(false); foreach (var content in provider.Contents) { #region Checking media types var headers = content.Headers; var mediaType = headers.ContentType.MediaType; var contentLength = headers.ContentLength; var availableMimeTypes = mimeId.GetMimeTypes(); if (availableMimeTypes.All(availableMimeType => availableMimeType != mediaType)) { return(BadRequest(string.Format(Resources.WrongMimeType, mediaType))); } #endregion var fileName = headers.ContentDisposition.FileName.Trim('\"'); var fileBytes = await content.ReadAsByteArrayAsync().ConfigureAwait(false); var newResume = new SpontaneousResume { SessionId = sessionId, File = fileBytes, FileName = fileName, FileType = mimeId.ToString(), FileSize = contentLength ?? default(decimal) }; if (!await _resumeManagerRepository.UploadFileAsync(newResume).ConfigureAwait(false)) { return(BadRequest(string.Format(Resources.FileExists, fileName))); } } return(Ok(Resources.FileUploaded)); }
public async Task <IEnumerable <UploadedFileInfo> > GetAsync(MimeTypeId mimeId) { var context = HttpContext.Current; var sessionId = context.GetSessionId(); var uploadedFileInfos = await _resumeManagerRepository.GetFilesAsync(sessionId, mimeId).ConfigureAwait(false); return(uploadedFileInfos); }
/* * /// <summary> * /// Getting wild card mask * /// </summary> * /// <param name="mimeTypeId">Mime type Id</param> * /// <returns>Wild card mask</returns> * public static string GetWildCardMask(this MimeTypeId mimeTypeId) * { * return mimeTypeId.GetType() * .GetField(mimeTypeId.ToString()) * .GetCustomAttributes(typeof(MediaTypeAttribute), false) * .Cast<MediaTypeAttribute>() * .First() * .Wildcard; * } */ /// <summary> /// Getting all mime type strings /// </summary> /// <param name="mimeTypeId">Mime type Id</param> /// <returns>Mime type</returns> public static string[] GetMimeTypes(this MimeTypeId mimeTypeId) { return(mimeTypeId.GetType() .GetField(mimeTypeId.ToString()) .GetCustomAttributes(typeof(MediaTypeAttribute), false) .Cast <MediaTypeAttribute>() .First() .MediaTypes); }
/// <summary> /// Getting the upload limit /// </summary> /// <param name="mimeId">The mime type id</param> /// <returns>The upload limit</returns> public static int GetUploadLimit(this MimeTypeId mimeId) { int uploadLimit; switch (mimeId) { case MimeTypeId.Pdf: uploadLimit = _PdfUploadLimit; break; case MimeTypeId.Zip: uploadLimit = _ZipUploadLimit; break; default: throw new ArgumentOutOfRangeException("mimeId", mimeId, null); } return(uploadLimit); }
/// <summary> /// Getting all files /// </summary> /// <param name="aSessionId">Session identifier</param> /// <param name="aMimeTypeId">Mime type identifier</param> /// <returns>All files</returns> public async Task <IEnumerable <UploadedFileInfo> > GetFilesAsync(string aSessionId, MimeTypeId aMimeTypeId) { var resumes = _hrEntities.SpontaneousResumes.Where( resume => resume.SessionId == aSessionId && resume.FileType == aMimeTypeId.ToString()); var uploads = new List <UploadedFileInfo>(); await resumes.ForEachAsync(resume => { uploads.Add(new UploadedFileInfo { Name = resume.FileName, Size = resume.FileSize, Content = resume.File, MimeType = resume.FileType }); }).ConfigureAwait(false); return(uploads); }
public async Task DeleteAsyncTestAsync(string fileToDelete, MimeTypeId mimeTypeId) { string route = string.Format("{0}/del/", BaseRoute); switch (mimeTypeId) { case MimeTypeId.None: var resumeRepo = new Mock <IResumeManagerRepository>(); resumeRepo .Setup(repository => repository.DeleteAsync(HttpContextExtensions.DummySessionId, fileToDelete)) .Returns(Task.FromResult(false)); var formData = new FormDataCollection(new List <KeyValuePair <string, string> > { new KeyValuePair <string, string>(SessionLimitedFileUploadController.FileFormDataKey, fileToDelete) }); var controller = new SessionLimitedFileUploadController(resumeRepo.Object) { Configuration = new HttpConfiguration(), Request = new HttpRequestMessage { Method = HttpMethod.Delete, RequestUri = new Uri(string.Format("{0}:{1}{2}", CommonEnvFactory.TestHostAddress, CommonEnvFactory.TestPort, route)) } }; Assert.IsFalse(UploadFileInfoFactory.PdfFiles.Union(UploadFileInfoFactory.ZipFiles).Any(fileInfo => fileInfo.Name == fileToDelete)); var beforePdfCount1 = UploadFileInfoFactory.PdfFiles.Count; var beforeZipCount1 = UploadFileInfoFactory.ZipFiles.Count; var responseMessage = await controller.DeleteAsync(formData).ConfigureAwait(false); var afterPdfCount1 = UploadFileInfoFactory.PdfFiles.Count; var afterZipCount1 = UploadFileInfoFactory.ZipFiles.Count; Assert.IsTrue(responseMessage.StatusCode == HttpStatusCode.BadRequest); Assert.IsTrue(beforePdfCount1 == afterPdfCount1); Assert.IsTrue(beforeZipCount1 == afterZipCount1); break; case MimeTypeId.Pdf: var pdfResumeRepo = new Mock <IResumeManagerRepository>(); pdfResumeRepo .Setup(repository => repository.DeleteAsync(HttpContextExtensions.DummySessionId, fileToDelete)) .Returns(() => DeletePdfAsync(fileToDelete)); var pdfFormData = new FormDataCollection(new List <KeyValuePair <string, string> > { new KeyValuePair <string, string>(SessionLimitedFileUploadController.FileFormDataKey, fileToDelete) }); var pdfController = new SessionLimitedFileUploadController(pdfResumeRepo.Object) { Configuration = new HttpConfiguration(), Request = new HttpRequestMessage { Method = HttpMethod.Delete, RequestUri = new Uri(string.Format("{0}:{1}{2}", CommonEnvFactory.TestHostAddress, CommonEnvFactory.TestPort, route)) } }; var beforePdfCount2 = UploadFileInfoFactory.PdfFiles.Count; var pdfFound = UploadFileInfoFactory.PdfFiles.Any(file => fileToDelete == file.Name); Assert.IsTrue(pdfFound); var message = await pdfController.DeleteAsync(pdfFormData).ConfigureAwait(false); var afterPdfCount2 = UploadFileInfoFactory.PdfFiles.Count; pdfFound = UploadFileInfoFactory.PdfFiles.Any(file => fileToDelete == file.Name); Assert.IsFalse(pdfFound); Assert.IsTrue(message.StatusCode == HttpStatusCode.OK); Assert.IsTrue(beforePdfCount2 == afterPdfCount2 + 1); break; case MimeTypeId.Zip: var zipResumeRepo = new Mock <IResumeManagerRepository>(); zipResumeRepo .Setup(repository => repository.DeleteAsync(HttpContextExtensions.DummySessionId, fileToDelete)) .Returns(() => DeleteZipAsync(fileToDelete)); var zipFormData = new FormDataCollection(new List <KeyValuePair <string, string> > { new KeyValuePair <string, string>(SessionLimitedFileUploadController.FileFormDataKey, fileToDelete) }); var zipController = new SessionLimitedFileUploadController(zipResumeRepo.Object) { Configuration = new HttpConfiguration(), Request = new HttpRequestMessage { Method = HttpMethod.Delete, RequestUri = new Uri(string.Format("{0}:{1}{2}", CommonEnvFactory.TestHostAddress, CommonEnvFactory.TestPort, route)) } }; var beforeZipCount3 = UploadFileInfoFactory.ZipFiles.Count; var zipFound = UploadFileInfoFactory.ZipFiles.Any(file => fileToDelete == file.Name); Assert.IsTrue(zipFound); var httpResponseMessage = await zipController.DeleteAsync(zipFormData).ConfigureAwait(false); var afterZipCount3 = UploadFileInfoFactory.ZipFiles.Count; zipFound = UploadFileInfoFactory.ZipFiles.Any(file => fileToDelete == file.Name); Assert.IsFalse(zipFound); Assert.IsTrue(httpResponseMessage.StatusCode == HttpStatusCode.OK); Assert.IsTrue(beforeZipCount3 == afterZipCount3 + 1); break; default: throw new ArgumentOutOfRangeException("mimeTypeId", mimeTypeId, null); } }