public void Create_returnsErrorWhenFileIsOver50Pages()
{
FileStream fs = new FileStream(TOO_LONG_FILE_PATH, FileMode.Open, FileAccess.Read);
DocumentUploadRequest request = new DocumentUploadRequest();
request.File = fs;
request.DocumentKind = DocumentUploadKind.EVIDENCE_DOCUMENT;
var result = gateway.DocumentUpload.Create(request);
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(ValidationErrorCode.DOCUMENT_UPLOAD_FILE_IS_TOO_LONG, result.Errors.ForObject("DocumentUpload").OnField("File")[0].Code);
}
public void Create_returnsErrorWithUnsupportedFileType()
{
FileStream fs = new FileStream(GIF_EXTENSION_FILE_PATH, FileMode.Open, FileAccess.Read);
DocumentUploadRequest request = new DocumentUploadRequest();
request.File = fs;
request.DocumentKind = DocumentUploadKind.EVIDENCE_DOCUMENT;
var result = gateway.DocumentUpload.Create(request);
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(ValidationErrorCode.DOCUMENT_UPLOAD_FILE_TYPE_IS_INVALID, result.Errors.ForObject("DocumentUpload").OnField("File")[0].Code);
}
public void Create_returnsErrorWithMalformedFile()
{
FileStream fs = new FileStream(MALFORMED_FILE_PATH, FileMode.Open, FileAccess.Read);
DocumentUploadRequest request = new DocumentUploadRequest();
request.File = fs;
request.DocumentKind = DocumentUploadKind.EVIDENCE_DOCUMENT;
var result = gateway.DocumentUpload.Create(request);
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(ValidationErrorCode.DOCUMENT_UPLOAD_FILE_IS_MALFORMED_OR_ENCRYPTED, result.Errors.ForObject("DocumentUpload").OnField("File")[0].Code);
}
public void Create_returnsSuccessfulWithValidRequest()
{
FileStream fs = new FileStream(BT_LOGO_PATH, FileMode.Open, FileAccess.Read);
DocumentUploadRequest request = new DocumentUploadRequest();
request.File = fs;
request.DocumentKind = DocumentUploadKind.EVIDENCE_DOCUMENT;
DocumentUpload documentUpload = gateway.DocumentUpload.Create(request).Target;
Assert.NotNull(documentUpload);
Assert.AreEqual(DocumentUploadKind.EVIDENCE_DOCUMENT, documentUpload.Kind);
Assert.AreEqual("bt_logo.png", documentUpload.Name);
Assert.AreEqual("image/png", documentUpload.ContentType);
Assert.AreEqual(2443m, documentUpload.Size);
}
public void Create_returnsErrorWhenFileIsEmpty()
{
using(StreamWriter writetext = new StreamWriter(new FileStream(EMPTY_FILE_PATH, FileMode.OpenOrCreate, FileAccess.ReadWrite)))
{
}
FileStream fs = new FileStream(EMPTY_FILE_PATH, FileMode.Open, FileAccess.Read);
DocumentUploadRequest request = new DocumentUploadRequest();
request.File = fs;
request.DocumentKind = DocumentUploadKind.EVIDENCE_DOCUMENT;
var result = gateway.DocumentUpload.Create(request);
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(ValidationErrorCode.DOCUMENT_UPLOAD_FILE_IS_EMPTY, result.Errors.ForObject("DocumentUpload").OnField("File")[0].Code);
}
public async Task CreateAsync_throwsWithEmptyFile()
{
DocumentUploadRequest request = new DocumentUploadRequest();
request.DocumentKind = DocumentUploadKind.EVIDENCE_DOCUMENT;
try
{
await gateway.DocumentUpload.CreateAsync(request);
Assert.Fail("Expected Exception.");
}
catch (ArgumentException exception)
{
Assert.AreEqual(exception.Message, "File must not be null");
}
}
public async Task CreateAsync_throwsWithEmptyKind()
{
FileStream fs = new FileStream(BT_LOGO_PATH, FileMode.Open, FileAccess.Read);
DocumentUploadRequest request = new DocumentUploadRequest();
request.File = fs;
try
{
await gateway.DocumentUpload.CreateAsync(request);
Assert.Fail("Expected Exception.");
}
catch (ArgumentException exception)
{
Assert.AreEqual(exception.Message, "DocumentKind must not be null");
}
}
public MainResponse UploadDocumentFile(DocumentUploadRequest documentUploadRequest, string actionBy)
{
string uniqueFileName = null;
string path = null;
if (documentUploadRequest.Documents != null)
{
foreach (IFormFile file in documentUploadRequest.Documents)
{
string uploadsFolder = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot");
uniqueFileName = Guid.NewGuid().ToString() + "_" + file.FileName;
var FilePath = Path.Combine(uploadsFolder, "Resources", "Documents");
path = Path.Combine(FilePath, uniqueFileName);
string filePath = Path.Combine(FilePath, uniqueFileName);
file.CopyTo(new FileStream(filePath, FileMode.Create));
path = path.Replace(uploadsFolder, "").Replace("\\", "/");
var scans = new Scans
{
ExhibitorId = documentUploadRequest.Exhibitor,
DocumentType = documentUploadRequest.DocumentType,
DocumentPath = path,
CreatedBy = actionBy,
CreatedDate = DateTime.Now
};
_scanRepository.Add(scans);
}
_mainResponse.Message = Constants.DOCUMENT_UPLOAD;
_mainResponse.Success = true;
}
else
{
_mainResponse.Message = Constants.NO_DOCUMENT_FOUND;
_mainResponse.Success = false;
}
return(_mainResponse);
}
public void CreateAsync_returnsErrorWithMalformedFile()
{
Task.Run(async () =>
#endif
{
FileStream fs = new FileStream("test/fixtures/malformed_pdf.pdf", FileMode.Open, FileAccess.Read);
DocumentUploadRequest request = new DocumentUploadRequest();
request.File = fs;
request.DocumentKind = DocumentUploadKind.EVIDENCE_DOCUMENT;
var result = await gateway.DocumentUpload.CreateAsync(request);
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(ValidationErrorCode.DOCUMENT_UPLOAD_FILE_IS_MALFORMED_OR_ENCRYPTED, result.Errors.ForObject("DocumentUpload").OnField("File")[0].Code);
}
#if net452
).GetAwaiter().GetResult();
}
public async Task <ActionResult> Upload(DocumentUploadRequest documentUploadRequest)
{
using (var ms = new MemoryStream())
{
documentUploadRequest.File.CopyTo(ms);
var fileBytes = ms.ToArray();
await documentService.Add(new Document
{
Bytes = fileBytes,
Name = documentUploadRequest.File.FileName,
Category = documentUploadRequest.Category,
LastReviewed = documentUploadRequest.LastReviewed,
Key = Guid.NewGuid()
});
}
return(Redirect("/documents"));
}
public void Create_returnsErrorWhenFileIsOver4Mb()
{
using(StreamWriter writetext = new StreamWriter(new FileStream(LARGE_FILE_PATH, FileMode.OpenOrCreate, FileAccess.ReadWrite)))
{
for (int i = 0; i <= 1048577; i++) {
writetext.WriteLine("aaaa");
}
}
FileStream fs = new FileStream(LARGE_FILE_PATH, FileMode.Open, FileAccess.Read);
DocumentUploadRequest request = new DocumentUploadRequest();
request.File = fs;
request.DocumentKind = DocumentUploadKind.EVIDENCE_DOCUMENT;
var result = gateway.DocumentUpload.Create(request);
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(ValidationErrorCode.DOCUMENT_UPLOAD_FILE_IS_TOO_LARGE, result.Errors.ForObject("DocumentUpload").OnField("File")[0].Code);
}
public void CreateAsync_returnsErrorWithUnsupportedFileType()
{
Task.Run(async () =>
#endif
{
FileStream fs = new FileStream("test/fixtures/gif_extension_bt_logo.gif", FileMode.Open, FileAccess.Read);
DocumentUploadRequest request = new DocumentUploadRequest();
request.File = fs;
request.DocumentKind = DocumentUploadKind.EVIDENCE_DOCUMENT;
var result = await gateway.DocumentUpload.CreateAsync(request);
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(ValidationErrorCode.DOCUMENT_UPLOAD_FILE_TYPE_IS_INVALID, result.Errors.ForObject("DocumentUpload").OnField("File")[0].Code);
}
#if net452
).GetAwaiter().GetResult();
}
public DocumentUploadResponse SendChangeRequest(DocumentUploadRequest docUploadRequest)
{
DocumentUploadResponse documentUploadResponse = new DocumentUploadResponse();
documentUploadResponse.IsSuccess = false;
documentUploadResponse.Message = "Document not sent successfully.";
#region Validate Input
if (string.IsNullOrEmpty(docUploadRequest.AuthToken))
{
documentUploadResponse.Message = "Please pass value of all mandatory fields";
return(documentUploadResponse);
}
AuthenticationToken authToken = new Helper().GetAuthenticationToken(docUploadRequest.AuthToken);
if (authToken == null)
{
documentUploadResponse.Message = "Unauthorizes user.";
return(documentUploadResponse);
}
#endregion
try
{
using (uow = new UnitOfWork())
{
User user = uow.UserRepository.GetById(authToken.FkUserID);
EmailHelper emailHelper = new EmailHelper();
emailHelper.SendHtmlEmailWithImage("Document Sent By Customer", docUploadRequest.DocumentName, user, docUploadRequest.ImagePath, docUploadRequest.Description);
documentUploadResponse.IsSuccess = true;
documentUploadResponse.Message = "Document sent successfully.";
}
}
catch
{
}
return(documentUploadResponse);
}
public void CreateAsync_returnsSuccessfulWithValidRequest()
{
Task.Run(async () =>
#endif
{
FileStream fs = new FileStream(BT_LOGO_PATH, FileMode.Open, FileAccess.Read);
DocumentUploadRequest request = new DocumentUploadRequest();
request.File = fs;
request.DocumentKind = DocumentUploadKind.EVIDENCE_DOCUMENT;
Result<DocumentUpload> documentUploadResult = await gateway.DocumentUpload.CreateAsync(request);
DocumentUpload documentUpload = documentUploadResult.Target;
Assert.NotNull(documentUpload);
Assert.AreEqual(DocumentUploadKind.EVIDENCE_DOCUMENT, documentUpload.Kind);
Assert.AreEqual("bt_logo.png", documentUpload.Name);
Assert.AreEqual("image/png", documentUpload.ContentType);
Assert.AreEqual(2443m, documentUpload.Size);
}
#if net452
).GetAwaiter().GetResult();
}
public void CreateAsync_throwsWithEmptyFile()
{
Task.Run(async () =>
#endif
{
DocumentUploadRequest request = new DocumentUploadRequest();
request.DocumentKind = DocumentUploadKind.EVIDENCE_DOCUMENT;
try
{
await gateway.DocumentUpload.CreateAsync(request);
Assert.Fail("Expected Exception.");
}
catch (ArgumentException exception)
{
Assert.AreEqual(exception.Message, "File must not be null");
}
}
#if net452
).GetAwaiter().GetResult();
}
public void CreateAsync_throwsWithEmptyKind()
{
Task.Run(async () =>
#endif
{
FileStream fs = new FileStream("test/fixtures/bt_logo.png", FileMode.Open, FileAccess.Read);
DocumentUploadRequest request = new DocumentUploadRequest();
request.File = fs;
try
{
await gateway.DocumentUpload.CreateAsync(request);
Assert.Fail("Expected Exception.");
}
catch (ArgumentException exception)
{
Assert.AreEqual(exception.Message, "DocumentKind must not be null");
}
}
#if net452
).GetAwaiter().GetResult();
}
/// <summary>
/// Uploads a document.
/// </summary>
/// <param name="documentUploadRequest"></param>
/// <returns></returns>
public async Task <DocumentUploadResult> UploadDocument(DocumentUploadRequest documentUploadRequest)
{
// Validate the request
await _documentUploadRequestValidator.ValidateAndThrowAsync(documentUploadRequest);
Log.Debug("Uploading to endpoint '{endpoint}' with '{certificate}'", _endpoint, _certificate.Subject);
// Create the client
var uploadDocumentClient = new UploadDocumentClient(new Uri(_endpoint), _certificate, _certificate);
DocumentUploadResult documentUploadResult;
try
{
// Create the request
ProvideAndRegisterDocumentSetRequestType provideAndRegisterDocumentSetRequest;
if (!string.IsNullOrWhiteSpace(documentUploadRequest.ReplaceDocumentId))
{
// Replace request
provideAndRegisterDocumentSetRequest = uploadDocumentClient.CreateRequestForReplacement(
documentUploadRequest.DocumentData,
documentUploadRequest.FormatCode,
documentUploadRequest.FormatCodeName,
_facilityType,
_practiceSetting,
documentUploadRequest.ReplaceDocumentId);
}
else
{
// New document request
provideAndRegisterDocumentSetRequest = uploadDocumentClient.CreateRequestForNewDocument(
documentUploadRequest.DocumentData,
documentUploadRequest.FormatCode,
documentUploadRequest.FormatCodeName,
_facilityType,
_practiceSetting);
}
if (Log.IsEnabled(LogEventLevel.Verbose))
{
Log.Verbose("Upload request '{requestJson}'", JsonConvert.SerializeObject(provideAndRegisterDocumentSetRequest));
}
// Create the PCEHR header
CommonPcehrHeader commonPcehrHeader = CreateCommonPcehrHeader(provideAndRegisterDocumentSetRequest.SubmitObjectsRequest);
if (Log.IsEnabled(LogEventLevel.Verbose))
{
Log.Verbose("PCEHR header {header}", JsonConvert.SerializeObject(commonPcehrHeader));
}
// Upload the document
RegistryResponseType registryResponse = uploadDocumentClient.UploadDocument(commonPcehrHeader, provideAndRegisterDocumentSetRequest);
LogSoapMessages(uploadDocumentClient.SoapMessages);
if (Log.IsEnabled(LogEventLevel.Verbose))
{
Log.Verbose("Upload response {responseJson}", JsonConvert.SerializeObject(registryResponse));
}
// Map the response
documentUploadResult = DocumentUploadResultMapper.Map(registryResponse);
}
catch (Exception e)
{
Log.Error(e, "Error uploading document to endpoint '{endpoint}'", _endpoint);
LogSoapMessages(uploadDocumentClient.SoapMessages);
throw;
}
finally
{
uploadDocumentClient.Close();
}
return(documentUploadResult);
}
public async Task <Boolean> PostAsync([FromForm] DocumentUploadRequest docUploadRequest)
{
//string todo = "createprofile";
return(await _uploadService.UploadAsync(docUploadRequest.file));
}
/// <summary>
/// Sends all documents.
/// </summary>
/// <returns></returns>
public async Task SendDocumentsInQueue()
{
var notificationItems = new List <NotificationData>();
// Get all the 'Pending' documents
var pendingDocuments = await _dataStore.FilterDocuments(new[] { DocumentStatus.Pending });
// Set documents statuses to 'Sending'
foreach (var document in pendingDocuments)
{
document.Status = DocumentStatus.Sending;
await _dataStore.UpdateDocument(document);
}
Log.Information("Found '{documentsToSend}' document(s) to send", pendingDocuments.Count);
// Process each document
foreach (var document in pendingDocuments)
{
EventType?newEventType = null;
string newEventMessage = null;
DocumentStatus?newDocumentStatus = null;
bool skipDocument = false;
// Check if current document supercedes a document that hasn't been sent yet then set status back to 'Pending' and do not process document
if (!string.IsNullOrEmpty(document.DocumentIdToReplace))
{
var replaceDocument = await _dataStore.GetDocument(document.DocumentIdToReplace);
if (replaceDocument != null && replaceDocument.Status != DocumentStatus.Sent)
{
newEventType = EventType.Deferred;
newEventMessage = $"Document to supercede ({replaceDocument.DocumentId}) hasn't been sent";
newDocumentStatus = DocumentStatus.Pending;
skipDocument = true;
}
}
if (!skipDocument)
{
var uploadRequest = new DocumentUploadRequest
{
DocumentData = document.DocumentData,
FormatCode = document.FormatCode,
FormatCodeName = document.FormatCodeName
};
// Upload document
bool wasSendSuccessful;
try
{
DocumentUploadResult documentUploadResult = await _mhrDocumentUploadClient.UploadDocument(uploadRequest);
Log.Information("Document with ID '{documentId}' upload status is '{uploadStatus}'", document.DocumentId, documentUploadResult.Status);
wasSendSuccessful = documentUploadResult.Status == DocumentUploadResultStatus.Success;
if (!wasSendSuccessful)
{
// Determine the message
newEventMessage = documentUploadResult.AdditionalInfo;
if (!string.IsNullOrEmpty(documentUploadResult.ErrorCode))
{
newEventMessage = $"Code: {documentUploadResult.ErrorCode} - {newEventMessage}";
}
}
}
catch (Exception e)
{
Log.Error(e, "Error uploading document");
wasSendSuccessful = false;
newEventMessage = e.Message;
}
// Determine the result
if (wasSendSuccessful)
{
newEventType = EventType.Success;
newDocumentStatus = DocumentStatus.Sent;
}
else
{
newEventType = EventType.Failed;
// Check if the retry limit has been reached
if (document.Events.Count(e => e.Type == EventType.Failed) + 1 >= _retryLimit)
{
Log.Information("Retry limit reached for document with ID '{documentId}'", document.DocumentId);
newDocumentStatus = DocumentStatus.RetryLimitReached;
}
else
{
// Change back to pending
newDocumentStatus = DocumentStatus.Pending;
}
}
}
// Add an event
await _dataStore.AddEvent(document, newEventType.Value, newEventMessage);
// Set the status
document.Status = newDocumentStatus.Value;
// Update the document
await _dataStore.UpdateDocument(document);
// Add a notification
notificationItems.Add(new NotificationData
{
DocumentEvent = newEventType.Value,
DocumentId = document.DocumentId
});
}
// Send any notifications
if (notificationItems.Any())
{
await _notificationService.SendNotification(notificationItems);
}
}
