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