public async Task SQL_File_FileRead_doesFileRead()
{
uploaded_data ud = new uploaded_data
{
Checksum = "checksum1",
Extension = "extension",
CurrentFile = "currentFile1",
UploaderId = 223,
UploaderType = "uploader_type",
FileLocation = "file_location",
FileName = "fileName",
WorkflowState = Constants.WorkflowStates.PreCreated
};
dbContext.uploaded_data.Add(ud);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
// Act
UploadedData Ud = await sut.FileRead();
// Assert
Assert.NotNull(ud);
Assert.NotNull(Ud);
Assert.AreEqual(Ud.Checksum, ud.Checksum);
Assert.AreEqual(Ud.Extension, ud.Extension);
Assert.AreEqual(Ud.CurrentFile, ud.CurrentFile);
Assert.AreEqual(Ud.UploaderId, ud.UploaderId);
Assert.AreEqual(Ud.UploaderType, ud.UploaderType);
Assert.AreEqual(Ud.FileLocation, ud.FileLocation);
Assert.AreEqual(Ud.FileName, ud.FileName);
Assert.AreEqual(Ud.Id, ud.Id);
Assert.AreEqual(Constants.WorkflowStates.PreCreated, ud.WorkflowState);
}
public void Process(UploadedData data)
{
var models = new List <DataModel>();
var lines = _reader.ReadLines(data.FilePath);
foreach (var line in lines)
{
models.Add(_mapper.MapLine(line));
}
_dataPersister.Save(models);
}
public async Task <OperationResult> Delete(int id)
{
UploadedData uploadedData =
await _dbContext.UploadedDatas.SingleOrDefaultAsync(x => x.Id == id);
if (uploadedData != null)
{
await uploadedData.Delete(_dbContext);
return(new OperationResult(true));
}
return(new OperationResult(false));
}
public ActionResult Index(HttpPostedFileBase uploadedFile)
{
var file = Request.Files[0];
UploadedData uploadedData = null;
if (file.FileName.EndsWith(".csv"))
{
var fileStream = file.InputStream;
uploadedData = _transactionService.UploadTransactions(fileStream);
}
TempData["UploadedData"] = uploadedData;
return(View(uploadedData));
}
public async Task SQL_UploadedData_FileRead_DoesReturnOneUploadedData()
{
// Arrance
string checksum = "";
string extension = "jpg";
string currentFile = "Hello.jpg";
int uploaderId = 1;
string fileLocation = @"c:\here";
string fileName = "Hello.jpg";
// Act
uploaded_data dU = new uploaded_data
{
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now,
Extension = extension,
UploaderId = uploaderId,
UploaderType = Constants.UploaderTypes.System,
WorkflowState = Constants.WorkflowStates.PreCreated,
Version = 1,
Local = 0,
FileLocation = fileLocation,
FileName = fileName,
CurrentFile = currentFile,
Checksum = checksum
};
dbContext.uploaded_data.Add(dU);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
UploadedData ud = await sut.FileRead();
// Assert
Assert.NotNull(ud);
Assert.AreEqual(dU.Id, ud.Id);
Assert.AreEqual(dU.Checksum, ud.Checksum);
Assert.AreEqual(dU.Extension, ud.Extension);
Assert.AreEqual(dU.CurrentFile, ud.CurrentFile);
Assert.AreEqual(dU.UploaderId, ud.UploaderId);
Assert.AreEqual(dU.UploaderType, ud.UploaderType);
Assert.AreEqual(dU.FileLocation, ud.FileLocation);
Assert.AreEqual(dU.FileName, ud.FileName);
// Assert.AreEqual(dU.local, ud.);
}
public void SQL_UploadedData_FileRead_DoesReturnOneUploadedData()
{
// Arrance
string checksum = "";
string extension = "jpg";
string currentFile = "Hello.jpg";
int uploaderId = 1;
string fileLocation = @"c:\here";
string fileName = "Hello.jpg";
// Act
uploaded_data dU = new uploaded_data();
dU.created_at = DateTime.Now;
dU.updated_at = DateTime.Now;
dU.extension = extension;
dU.uploader_id = uploaderId;
dU.uploader_type = Constants.UploaderTypes.System;
dU.workflow_state = Constants.WorkflowStates.PreCreated;
dU.version = 1;
dU.local = 0;
dU.file_location = fileLocation;
dU.file_name = fileName;
dU.current_file = currentFile;
dU.checksum = checksum;
DbContext.uploaded_data.Add(dU);
DbContext.SaveChanges();
UploadedData ud = sut.FileRead();
// Assert
Assert.NotNull(ud);
Assert.AreEqual(dU.id, ud.Id);
Assert.AreEqual(dU.checksum, ud.Checksum);
Assert.AreEqual(dU.extension, ud.Extension);
Assert.AreEqual(dU.current_file, ud.CurrentFile);
Assert.AreEqual(dU.uploader_id, ud.UploaderId);
Assert.AreEqual(dU.uploader_type, ud.UploaderType);
Assert.AreEqual(dU.file_location, ud.FileLocation);
Assert.AreEqual(dU.file_name, ud.FileName);
//Assert.AreEqual(dU.local, ud.);
}
public async Task <IActionResult> UploadUploadedDataPdf(UploadedDataPDFUploadModel pdfUploadModel)
{
try
{
var core = _core.GetCore();
var saveFolder = Path.Combine(await core.Result.GetSdkSetting(Settings.fileLocationPdf), Path.Combine("pdfFiles"));
Directory.CreateDirectory(saveFolder);
string fileName = $"ItemCase_{pdfUploadModel.ItemCaseId}_{DateTime.Now.Ticks}.pdf";
if (pdfUploadModel.File.Length > 0)
{
using (var stream = new FileStream(Path.Combine(saveFolder, fileName), FileMode.Create))
{
await pdfUploadModel.File.CopyToAsync(stream);
}
}
if (core.Result.GetSdkSetting(Settings.swiftEnabled).ToString().ToLower() == "true")
{
await core.Result.PutFileToStorageSystem(Path.Combine(saveFolder, fileName), fileName);
}
UploadedData uploadedData = new UploadedData();
uploadedData.FileLocation = saveFolder;
uploadedData.FileName = fileName;
uploadedData.ItemCaseId = pdfUploadModel.ItemCaseId;
await uploadedData.Create(_dbContext);
return(new OkResult());
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_core.LogException(e.Message);
return(new BadRequestResult());
}
}
public async Task <OperationResult> Update(UploadedDataModel uploadedDataModel)
{
UploadedData uploadedData =
await _dbContext.UploadedDatas.SingleOrDefaultAsync(x => x.Id == uploadedDataModel.Id);
if (uploadedData != null)
{
uploadedData.Checksum = uploadedDataModel.Checksum;
uploadedData.Extension = uploadedDataModel.Extension;
uploadedData.CurrentFile = uploadedDataModel.CurrentFile;
uploadedData.FileLocation = uploadedDataModel.FileLocation;
uploadedData.FileName = uploadedDataModel.FileName;
uploadedData.UploaderType = uploadedDataModel.UploaderType;
uploadedData.ItemCaseId = uploadedDataModel.ItemCaseId;
await uploadedData.Update(_dbContext);
return(new OperationResult(true));
}
return(new OperationResult(false));
}
public void SQL_File_FileRead_doesFileRead()
{
uploaded_data ud = new uploaded_data();
ud.checksum = "checksum1";
ud.extension = "extension";
ud.current_file = "currentFile1";
ud.uploader_id = 223;
ud.uploader_type = "uploader_type";
ud.file_location = "file_location";
ud.file_name = "fileName";
//ud.id = 111;
ud.workflow_state = Constants.WorkflowStates.PreCreated;
DbContext.uploaded_data.Add(ud);
DbContext.SaveChanges();
// Act
UploadedData Ud = sut.FileRead();
// Assert
Assert.NotNull(ud);
Assert.NotNull(Ud);
Assert.AreEqual(Ud.Checksum, ud.checksum);
Assert.AreEqual(Ud.Extension, ud.extension);
Assert.AreEqual(Ud.CurrentFile, ud.current_file);
Assert.AreEqual(Ud.UploaderId, ud.uploader_id);
Assert.AreEqual(Ud.UploaderType, ud.uploader_type);
Assert.AreEqual(Ud.FileLocation, ud.file_location);
Assert.AreEqual(Ud.FileName, ud.file_name);
Assert.AreEqual(Ud.Id, ud.id);
Assert.AreEqual(Constants.WorkflowStates.PreCreated, ud.workflow_state);
}
public async Task <IActionResult> Upload()
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got {Request.ContentType}"));
}
// Used to accumulate all the form url encoded key value pairs in the
// request.
var formAccumulator = new KeyValueAccumulator();
string targetFilePath = null;
var boundary = MultipartRequestHelper.GetBoundary(
MediaTypeHeaderValue.Parse(Request.ContentType),
_defaultFormOptions.MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary, HttpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
ContentDispositionHeaderValue contentDisposition;
var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out contentDisposition);
if (hasContentDispositionHeader)
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
targetFilePath = Path.GetTempFileName();
using (var targetStream = System.IO.File.Create(targetFilePath))
{
await section.Body.CopyToAsync(targetStream);
_logger.LogInformation($"Copied the uploaded file '{targetFilePath}'");
}
}
else if (MultipartRequestHelper.HasFormDataContentDisposition(contentDisposition))
{
// Content-Disposition: form-data; name="key"
//
// value
// Do not limit the key name length here because the
// multipart headers length limit is already in effect.
var key = HeaderUtilities.RemoveQuotes(contentDisposition.Name);
var encoding = GetEncoding(section);
using (var streamReader = new StreamReader(
section.Body,
encoding,
detectEncodingFromByteOrderMarks: true,
bufferSize: 1024,
leaveOpen: true))
{
// The value length limit is enforced by MultipartBodyLengthLimit
var value = await streamReader.ReadToEndAsync();
if (String.Equals(value, "undefined", StringComparison.OrdinalIgnoreCase))
{
value = String.Empty;
}
formAccumulator.Append(key, value);
if (formAccumulator.ValueCount > _defaultFormOptions.ValueCountLimit)
{
throw new InvalidDataException($"Form key count limit {_defaultFormOptions.ValueCountLimit} exceeded.");
}
}
}
}
// Drains any remaining section body that has not been consumed and
// reads the headers for the next section.
section = await reader.ReadNextSectionAsync();
}
// Bind form data to a model
var user = new User();
var formValueProvider = new FormValueProvider(
BindingSource.Form,
new FormCollection(formAccumulator.GetResults()),
CultureInfo.CurrentCulture);
var bindingSuccessful = await TryUpdateModelAsync(user, prefix : "",
valueProvider : formValueProvider);
if (!bindingSuccessful)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
}
var uploadedData = new UploadedData()
{
Name = user.Name,
Age = user.Age,
Zipcode = user.Zipcode,
FilePath = targetFilePath
};
return(Json(uploadedData));
}
public void CaseTemplateUploadedData_Delete_DoesSetWorkflowStateToRemoved()
{
//Arrange
short shortMin = Int16.MinValue;
short shortMax = Int16.MaxValue;
Random rnd = new Random();
bool randomBool = rnd.Next(0, 2) > 0;
CaseTemplate caseTemplate = new CaseTemplate();
caseTemplate.Approvable = randomBool;
caseTemplate.Body = Guid.NewGuid().ToString();
caseTemplate.Title = Guid.NewGuid().ToString();
caseTemplate.AlwaysShow = randomBool;
caseTemplate.EndAt = DateTime.Now;
caseTemplate.PdfTitle = Guid.NewGuid().ToString();
caseTemplate.StartAt = DateTime.Now;
caseTemplate.DescriptionFolderId = rnd.Next(1, 200);
caseTemplate.RetractIfApproved = randomBool;
caseTemplate.Create(DbContext);
UploadedData uploadedData = new UploadedData();
uploadedData.Checksum = Guid.NewGuid().ToString();
uploadedData.Extension = Guid.NewGuid().ToString();
uploadedData.Local = (short)rnd.Next(shortMin, shortMax);
uploadedData.CurrentFile = Guid.NewGuid().ToString();
uploadedData.ExpirationDate = DateTime.Now;
uploadedData.FileLocation = Guid.NewGuid().ToString();
uploadedData.FileName = Guid.NewGuid().ToString();
uploadedData.UploaderType = Guid.NewGuid().ToString();
uploadedData.OriginalFileName = Guid.NewGuid().ToString();
uploadedData.Create(DbContext);
CaseTemplateUploadedData caseTemplateUploadedData = new CaseTemplateUploadedData();
caseTemplateUploadedData.Approvable = randomBool;
caseTemplateUploadedData.Title = Guid.NewGuid().ToString();
caseTemplateUploadedData.CaseTemplateId = caseTemplate.Id;
caseTemplateUploadedData.RetractIfApproved = randomBool;
caseTemplateUploadedData.UploadedDataId = uploadedData.Id;
caseTemplateUploadedData.Create(DbContext);
//Act
DateTime?oldUpdatedAt = caseTemplateUploadedData.UpdatedAt;
caseTemplateUploadedData.Delete(DbContext);
List <CaseTemplateUploadedData> dbCaseTemplateUploadedDatas = DbContext.CaseTemplateUploadedDatas.AsNoTracking().ToList();
List <CaseTemplateUploadedDataVersion> dbCaseTemplateUploadedDataVersions = DbContext.CaseTemplateUploadedDataVersions.AsNoTracking().ToList();
//Assert
Assert.NotNull(dbCaseTemplateUploadedDatas);
Assert.NotNull(dbCaseTemplateUploadedDataVersions);
Assert.AreEqual(1, dbCaseTemplateUploadedDatas.Count);
Assert.AreEqual(2, dbCaseTemplateUploadedDataVersions.Count);
Assert.AreEqual(caseTemplateUploadedData.Id, dbCaseTemplateUploadedDatas[0].Id);
Assert.AreEqual(caseTemplateUploadedData.Version, dbCaseTemplateUploadedDatas[0].Version);
Assert.AreEqual(caseTemplateUploadedData.CreatedAt.ToString(), dbCaseTemplateUploadedDatas[0].CreatedAt.ToString());
Assert.AreEqual(caseTemplateUploadedData.UpdatedAt.ToString(), dbCaseTemplateUploadedDatas[0].UpdatedAt.ToString());
Assert.AreEqual(caseTemplateUploadedData.CreatedByUserId, dbCaseTemplateUploadedDatas[0].CreatedByUserId);
Assert.AreEqual(caseTemplateUploadedData.UpdatedByUserId, dbCaseTemplateUploadedDatas[0].UpdatedByUserId);
Assert.AreEqual(Constants.WorkflowStates.Removed, dbCaseTemplateUploadedDatas[0].WorkflowState);
Assert.AreEqual(caseTemplateUploadedData.Approvable, dbCaseTemplateUploadedDatas[0].Approvable);
Assert.AreEqual(caseTemplateUploadedData.Title, dbCaseTemplateUploadedDatas[0].Title);
Assert.AreEqual(caseTemplate.Id, dbCaseTemplateUploadedDatas[0].CaseTemplateId);
Assert.AreEqual(uploadedData.Id, dbCaseTemplateUploadedDatas[0].UploadedDataId);
Assert.AreEqual(caseTemplateUploadedData.RetractIfApproved, dbCaseTemplateUploadedDatas[0].RetractIfApproved);
//Old Version
Assert.AreEqual(caseTemplateUploadedData.Id, dbCaseTemplateUploadedDataVersions[0].Id);
Assert.AreEqual(1, dbCaseTemplateUploadedDataVersions[0].Version);
Assert.AreEqual(caseTemplateUploadedData.CreatedAt.ToString(), dbCaseTemplateUploadedDataVersions[0].CreatedAt.ToString());
Assert.AreEqual(oldUpdatedAt.ToString(), dbCaseTemplateUploadedDataVersions[0].UpdatedAt.ToString());
Assert.AreEqual(caseTemplateUploadedData.CreatedByUserId, dbCaseTemplateUploadedDataVersions[0].CreatedByUserId);
Assert.AreEqual(caseTemplateUploadedData.UpdatedByUserId, dbCaseTemplateUploadedDataVersions[0].UpdatedByUserId);
Assert.AreEqual(Constants.WorkflowStates.Created, dbCaseTemplateUploadedDataVersions[0].WorkflowState);
Assert.AreEqual(caseTemplateUploadedData.Approvable, dbCaseTemplateUploadedDataVersions[0].Approvable);
Assert.AreEqual(caseTemplateUploadedData.Title, dbCaseTemplateUploadedDataVersions[0].Title);
Assert.AreEqual(caseTemplate.Id, dbCaseTemplateUploadedDataVersions[0].CaseTemplateId);
Assert.AreEqual(uploadedData.Id, dbCaseTemplateUploadedDataVersions[0].UploadedDataId);
Assert.AreEqual(caseTemplateUploadedData.RetractIfApproved, dbCaseTemplateUploadedDataVersions[0].RetractIfApproved);
//New Version
Assert.AreEqual(caseTemplateUploadedData.Id, dbCaseTemplateUploadedDataVersions[1].CaseTemplateUploadedDataId);
Assert.AreEqual(2, dbCaseTemplateUploadedDataVersions[1].Version);
Assert.AreEqual(caseTemplateUploadedData.CreatedAt.ToString(), dbCaseTemplateUploadedDataVersions[1].CreatedAt.ToString());
Assert.AreEqual(caseTemplateUploadedData.UpdatedAt.ToString(), dbCaseTemplateUploadedDataVersions[1].UpdatedAt.ToString());
Assert.AreEqual(caseTemplateUploadedData.CreatedByUserId, dbCaseTemplateUploadedDataVersions[1].CreatedByUserId);
Assert.AreEqual(caseTemplateUploadedData.UpdatedByUserId, dbCaseTemplateUploadedDataVersions[1].UpdatedByUserId);
Assert.AreEqual(Constants.WorkflowStates.Removed, dbCaseTemplateUploadedDataVersions[1].WorkflowState);
Assert.AreEqual(caseTemplateUploadedData.Approvable, dbCaseTemplateUploadedDataVersions[1].Approvable);
Assert.AreEqual(caseTemplateUploadedData.Title, dbCaseTemplateUploadedDataVersions[1].Title);
Assert.AreEqual(caseTemplate.Id, dbCaseTemplateUploadedDataVersions[1].CaseTemplateId);
Assert.AreEqual(uploadedData.Id, dbCaseTemplateUploadedDataVersions[1].UploadedDataId);
Assert.AreEqual(caseTemplateUploadedData.RetractIfApproved, dbCaseTemplateUploadedDataVersions[1].RetractIfApproved);
}
public IActionResult Index(UploadedDataViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
string filePath = null;
// If the Photo property on the incoming model object is not null, then the user
// has selected an image to upload.
if (model.Base64 != null)
{
try
{
// The image must be uploaded to the images folder in wwwroot
// To get the path of the wwwroot folder we are using the inject
// HostingEnvironment service provided by ASP.NET Core
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images\\" + model.Name);
//if the the directory doesn't exist
Directory.CreateDirectory(uploadsFolder);
// To make sure the file name is unique we are appending a new
// GUID value and and an underscore to the file name
uniqueFileName = Guid.NewGuid().ToString() + "_PostCardImage.png";
filePath = Path.Combine(uploadsFolder, uniqueFileName);
byte[] imgBytes = Convert.FromBase64String(model.Base64);
using (var imageFile = new FileStream(filePath, FileMode.Create))
{
imageFile.Write(imgBytes, 0, imgBytes.Length);
imageFile.Flush();
}
//Saves the provided information on the database.
//We store the filepath to delete the image from the server
//at the user's request.
UploadedData newDataEntry = new UploadedData
{
Name = model.Name,
Email = model.Email,
SentDate = DateTime.Now,
ImageName = uniqueFileName,
ImagePath = filePath
};
_uploadedDataRespository.UploadData(newDataEntry);
//Sends the email with the select image as an attachement if no errors occur above
var fromAddress = new MailAddress("*****@*****.**");
var toAddress = new MailAddress(model.Email);
const string fromPassword = "******";
string subject = "";
if (model.Subject != "")
{
subject = model.Subject;
}
else
{
subject = "Post Card - Image(s)";
}
string body = model.EmailBody;
var smtp = new SmtpClient
{
Host = "smtp.gmail.com",
Port = 587,
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
UseDefaultCredentials = false,
Credentials = new NetworkCredential(fromAddress.Address, fromPassword)
};
Attachment attachment = new Attachment(filePath);
using (MailMessage message = new MailMessage(fromAddress, toAddress)
{
Subject = subject,
Body = body
})
{
message.Attachments.Add(attachment);
smtp.Send(message);
}
ViewBag.CssClassName = "text-success";
ViewBag.ServerMessage = "Image successfully sent.";
return(View("Index"));
}
catch (Exception ex)
{
//deletes the uploaded file if an error occurs
if (System.IO.File.Exists(filePath))
{
System.IO.File.Delete(filePath);
}
ViewBag.TextClass = "text-danger";
ViewBag.Message = ex.Message;
}
}
else
{
ViewBag.TextClass = "text-danger";
ViewBag.Message = "Please select an image.";
}
return(View());
}
else
{
ViewBag.TextClass = "text-danger";
ViewBag.Message = "The form validation failed.";
}
return(View());
}
public async Task <IActionResult> Upload()
{
var multipartBoundary = Request.GetMultipartBoundary();
if (string.IsNullOrEmpty(multipartBoundary))
{
return(BadRequest($"Expected a multipart request, but got '{Request.ContentType}'."));
}
// Used to accumulate all the form url encoded key value pairs in the request.
var formAccumulator = new KeyValueAccumulator();
string targetFilePath = null;
var reader = new MultipartReader(multipartBoundary, HttpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
// This will reparse the content disposition header
// Create a FileMultipartSection using it's constructor to pass
// in a cached disposition header
var fileSection = section.AsFileSection();
if (fileSection != null)
{
var fileName = fileSection.FileName;
targetFilePath = Path.Combine(_hostingEnvironment.ContentRootPath, Guid.NewGuid().ToString());
using (var targetStream = System.IO.File.Create(targetFilePath))
{
await fileSection.FileStream.CopyToAsync(targetStream);
_logger.LogInformation($"Copied the uploaded file '{fileName}' to '{targetFilePath}'.");
}
}
else
{
var formSection = section.AsFormDataSection();
if (formSection != null)
{
var name = formSection.Name;
var value = await formSection.GetValueAsync();
formAccumulator.Append(name, value);
if (formAccumulator.ValueCount > FormReader.DefaultValueCountLimit)
{
throw new InvalidDataException(
$"Form key count limit {FormReader.DefaultValueCountLimit} exceeded.");
}
}
}
// Drains any remaining section body that has not been consumed and
// reads the headers for the next section.
section = await reader.ReadNextSectionAsync();
}
// Bind form data to a model
var user = new User();
var formValueProvider = new FormValueProvider(
BindingSource.Form,
new FormCollection(formAccumulator.GetResults()),
CultureInfo.CurrentCulture);
var bindingSuccessful = await TryUpdateModelAsync(user, prefix : "", valueProvider : formValueProvider);
if (!bindingSuccessful)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
}
var uploadedData = new UploadedData()
{
Name = user.Name,
Age = user.Age,
Zipcode = user.Zipcode,
FilePath = targetFilePath
};
return(Json(uploadedData));
}
public void UploadedData_Update_DoesUpdate()
{
//Arrange
Random rnd = new Random();
short minValue = Int16.MinValue;
short maxValue = Int16.MaxValue;
UploadedData uploadedData = new UploadedData();
uploadedData.Checksum = Guid.NewGuid().ToString();
uploadedData.Extension = Guid.NewGuid().ToString();
uploadedData.CurrentFile = Guid.NewGuid().ToString();
uploadedData.FileLocation = Guid.NewGuid().ToString();
uploadedData.FileName = Guid.NewGuid().ToString();
uploadedData.UploaderType = Guid.NewGuid().ToString();
uploadedData.Local = (short)rnd.Next(minValue, maxValue);
uploadedData.ExpirationDate = DateTime.Now;
uploadedData.OriginalFileName = Guid.NewGuid().ToString();
uploadedData.Create(DbContext);
//Act
DateTime?oldUpdatedAt = uploadedData.UpdatedAt;
string oldChecksum = uploadedData.Checksum;
string oldExtension = uploadedData.Extension;
string oldCurrentFIle = uploadedData.CurrentFile;
string oldFileLocation = uploadedData.FileLocation;
string oldFileName = uploadedData.FileName;
string oldUploaderType = uploadedData.UploaderType;
int? oldLocal = uploadedData.Local;
DateTime?oldExpirationDate = uploadedData.ExpirationDate;
string oldOriginalFileName = uploadedData.OriginalFileName;
uploadedData.Checksum = Guid.NewGuid().ToString();
uploadedData.Extension = Guid.NewGuid().ToString();
uploadedData.CurrentFile = Guid.NewGuid().ToString();
uploadedData.FileLocation = Guid.NewGuid().ToString();
uploadedData.FileName = Guid.NewGuid().ToString();
uploadedData.UploaderType = Guid.NewGuid().ToString();
uploadedData.Local = (short)rnd.Next(minValue, maxValue);
uploadedData.ExpirationDate = DateTime.Now;
uploadedData.OriginalFileName = Guid.NewGuid().ToString();
uploadedData.Update(DbContext);
List <UploadedData> dbUploadedDatas = DbContext.UploadedDatas.AsNoTracking().ToList();
List <UploadedDataVersion> dbUploadedDataVersions = DbContext.UploadedDataVersions.AsNoTracking().ToList();
//Assert
Assert.NotNull(dbUploadedDatas);
Assert.NotNull(dbUploadedDataVersions);
Assert.AreEqual(1, dbUploadedDatas.Count);
Assert.AreEqual(2, dbUploadedDataVersions.Count);
Assert.AreEqual(uploadedData.Id, dbUploadedDatas[0].Id);
Assert.AreEqual(uploadedData.Version, dbUploadedDatas[0].Version);
Assert.AreEqual(uploadedData.CreatedAt.ToString(), dbUploadedDatas[0].CreatedAt.ToString());
Assert.AreEqual(uploadedData.UpdatedAt.ToString(), dbUploadedDatas[0].UpdatedAt.ToString());
Assert.AreEqual(uploadedData.CreatedByUserId, dbUploadedDatas[0].CreatedByUserId);
Assert.AreEqual(uploadedData.UpdatedByUserId, dbUploadedDatas[0].UpdatedByUserId);
Assert.AreEqual(Constants.WorkflowStates.Created, dbUploadedDatas[0].WorkflowState);
Assert.AreEqual(uploadedData.Checksum, dbUploadedDatas[0].Checksum);
Assert.AreEqual(uploadedData.Extension, dbUploadedDatas[0].Extension);
Assert.AreEqual(uploadedData.Local, dbUploadedDatas[0].Local);
Assert.AreEqual(uploadedData.CurrentFile, dbUploadedDatas[0].CurrentFile);
Assert.AreEqual(uploadedData.ExpirationDate.ToString(), dbUploadedDatas[0].ExpirationDate.ToString());
Assert.AreEqual(uploadedData.FileLocation, dbUploadedDatas[0].FileLocation);
Assert.AreEqual(uploadedData.FileName, dbUploadedDatas[0].FileName);
Assert.AreEqual(uploadedData.UploaderType, dbUploadedDatas[0].UploaderType);
Assert.AreEqual(uploadedData.OriginalFileName, dbUploadedDatas[0].OriginalFileName);
//Old Version
Assert.AreEqual(uploadedData.Id, dbUploadedDataVersions[0].UploadedDataId);
Assert.AreEqual(1, dbUploadedDataVersions[0].Version);
Assert.AreEqual(uploadedData.CreatedAt.ToString(), dbUploadedDataVersions[0].CreatedAt.ToString());
Assert.AreEqual(oldUpdatedAt.ToString(), dbUploadedDataVersions[0].UpdatedAt.ToString());
Assert.AreEqual(uploadedData.CreatedByUserId, dbUploadedDataVersions[0].CreatedByUserId);
Assert.AreEqual(uploadedData.UpdatedByUserId, dbUploadedDataVersions[0].UpdatedByUserId);
Assert.AreEqual(Constants.WorkflowStates.Created, dbUploadedDataVersions[0].WorkflowState);
Assert.AreEqual(oldChecksum, dbUploadedDataVersions[0].Checksum);
Assert.AreEqual(oldExtension, dbUploadedDataVersions[0].Extension);
Assert.AreEqual(oldLocal, dbUploadedDataVersions[0].Local);
Assert.AreEqual(oldCurrentFIle, dbUploadedDataVersions[0].CurrentFile);
Assert.AreEqual(oldExpirationDate.ToString(), dbUploadedDataVersions[0].ExpirationDate.ToString());
Assert.AreEqual(oldFileLocation, dbUploadedDataVersions[0].FileLocation);
Assert.AreEqual(oldFileName, dbUploadedDataVersions[0].FileName);
Assert.AreEqual(oldUploaderType, dbUploadedDataVersions[0].UploaderType);
Assert.AreEqual(oldOriginalFileName, dbUploadedDataVersions[0].OriginalFileName);
//New Version
Assert.AreEqual(uploadedData.Id, dbUploadedDataVersions[1].UploadedDataId);
Assert.AreEqual(2, dbUploadedDataVersions[1].Version);
Assert.AreEqual(uploadedData.CreatedAt.ToString(), dbUploadedDataVersions[1].CreatedAt.ToString());
Assert.AreEqual(uploadedData.UpdatedAt.ToString(), dbUploadedDataVersions[1].UpdatedAt.ToString());
Assert.AreEqual(uploadedData.CreatedByUserId, dbUploadedDataVersions[1].CreatedByUserId);
Assert.AreEqual(uploadedData.UpdatedByUserId, dbUploadedDataVersions[1].UpdatedByUserId);
Assert.AreEqual(Constants.WorkflowStates.Created, dbUploadedDataVersions[1].WorkflowState);
Assert.AreEqual(uploadedData.Checksum, dbUploadedDataVersions[1].Checksum);
Assert.AreEqual(uploadedData.Extension, dbUploadedDataVersions[1].Extension);
Assert.AreEqual(uploadedData.Local, dbUploadedDataVersions[1].Local);
Assert.AreEqual(uploadedData.CurrentFile, dbUploadedDataVersions[1].CurrentFile);
Assert.AreEqual(uploadedData.ExpirationDate.ToString(), dbUploadedDataVersions[1].ExpirationDate.ToString());
Assert.AreEqual(uploadedData.FileLocation, dbUploadedDataVersions[1].FileLocation);
Assert.AreEqual(uploadedData.FileName, dbUploadedDataVersions[1].FileName);
Assert.AreEqual(uploadedData.UploaderType, dbUploadedDataVersions[1].UploaderType);
Assert.AreEqual(uploadedData.OriginalFileName, dbUploadedDataVersions[1].OriginalFileName);
}
//[DisableFormValueModelBinding]
//[ValidateAntiForgeryToken]
//public async Task<IActionResult> Upload()
public async Task <IActionResult> Upload()
{
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Expected a multipart request, but got '{Request.ContentType}'."));
}
// Used to accumulate all the form url encoded key value pairs in the request.
var formAccumulator = new KeyValueAccumulator();
string targetFilePath = null;
var boundary = MultipartRequestHelper.GetBoundary(
MediaTypeHeaderValue.Parse(Request.ContentType), _defaultFormOptions.MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary, HttpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
ContentDispositionHeaderValue contentDisposition;
ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out contentDisposition);
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
var name = HeaderUtilities.RemoveQuotes(contentDisposition.Name) ?? string.Empty;
var fileName = HeaderUtilities.RemoveQuotes(contentDisposition.FileName) ?? string.Empty;
// Here the uploaded file is being copied to local disk but you can also for example, copy the
// stream directly to let's say Azure blob storage
targetFilePath = Path.Combine(_hostingEnvironment.ContentRootPath, Guid.NewGuid().ToString());
using (var targetStream = System.IO.File.Create(targetFilePath))
{
await section.Body.CopyToAsync(targetStream);
_logger.LogInformation($"Copied the uploaded file '{fileName}' to '{targetFilePath}'.");
}
}
else if (MultipartRequestHelper.HasFormDataContentDisposition(contentDisposition))
{
// Content-Disposition: form-data; name="key"
//
// value
// Do not limit the key name length here because the mulipart headers length
// limit is already in effect.
var key = HeaderUtilities.RemoveQuotes(contentDisposition.Name);
MediaTypeHeaderValue mediaType;
MediaTypeHeaderValue.TryParse(section.ContentType, out mediaType);
var encoding = FilterEncoding(mediaType?.Encoding);
using (var streamReader = new StreamReader(
section.Body,
encoding,
detectEncodingFromByteOrderMarks: true,
bufferSize: 1024,
leaveOpen: true))
{
// The value length limit is enforced by MultipartBodyLengthLimit
var value = await streamReader.ReadToEndAsync();
formAccumulator.Append(key, value);
if (formAccumulator.ValueCount > _defaultFormOptions.ValueCountLimit)
{
throw new InvalidDataException(
$"Form key count limit {_defaultFormOptions.ValueCountLimit} exceeded.");
}
}
}
// Drains any remaining section body that has not been consumed and
// reads the headers for the next section.
section = await reader.ReadNextSectionAsync();
}
// Bind form data to a model
//var user = new User();
//var formValueProvider = new FormValueProvider(
// BindingSource.Form,
// new FormCollection(formAccumulator.GetResults()),
// CultureInfo.CurrentCulture);
//var bindingSuccessful = await TryUpdateModelAsync(user, prefix: "", valueProvider: formValueProvider);
//if (!bindingSuccessful)
//{
// if (!ModelState.IsValid)
// {
// return BadRequest(ModelState);
// }
//}
var uploadedData = new UploadedData()
{
//Name = user.Name,
FilePath = targetFilePath
};
return(Ok(uploadedData));
}
public async Task UploadedData_Update_DoesUpdate()
{
//Arrange
ItemList itemList = new ItemList
{
Name = Guid.NewGuid().ToString()
};
await itemList.Create(DbContext);
Item item = new Item
{
Name = Guid.NewGuid().ToString(),
Description = Guid.NewGuid().ToString(),
Enabled = true,
ItemListId = itemList.Id,
};
await item.Create(DbContext);
ItemCase itemCase = new ItemCase
{
MicrotingSdkSiteId = 24,
MicrotingSdkCaseId = 34,
MicrotingSdkeFormId = 234,
Status = 66,
ItemId = item.Id,
};
await itemCase.Create(DbContext);
UploadedData uploadedData = new UploadedData
{
ItemCaseId = itemCase.Id,
Checksum = Guid.NewGuid().ToString(),
Extension = Guid.NewGuid().ToString(),
CurrentFile = Guid.NewGuid().ToString(),
UploaderType = Guid.NewGuid().ToString(),
FileLocation = Guid.NewGuid().ToString(),
FileName = Guid.NewGuid().ToString()
};
await uploadedData.Create(DbContext);
string newCheckSum = Guid.NewGuid().ToString();
string newExtension = Guid.NewGuid().ToString();
string newCurrentFile = Guid.NewGuid().ToString();
string newUploaderType = Guid.NewGuid().ToString();
string newFileLocation = Guid.NewGuid().ToString();
string newFileName = Guid.NewGuid().ToString();
uploadedData.Checksum = newCheckSum;
uploadedData.Extension = newExtension;
uploadedData.CurrentFile = newCurrentFile;
uploadedData.UploaderType = newUploaderType;
uploadedData.FileLocation = newFileLocation;
uploadedData.FileName = newFileName;
//Act
await uploadedData.Update(DbContext);
UploadedData dbUploadedData = DbContext.UploadedDatas.AsNoTracking().First();
List <UploadedData> uploadedDataList = DbContext.UploadedDatas.AsNoTracking().ToList();
List <UploadedDataVersion> uploadedDataVersionList = DbContext.UploadedDataVersions.AsNoTracking().ToList();
//Assert
Assert.NotNull(dbUploadedData);
Assert.AreEqual(1, uploadedDataList.Count);
Assert.AreEqual(2, uploadedDataVersionList.Count);
Assert.AreEqual(newCheckSum, dbUploadedData.Checksum);
Assert.AreEqual(newExtension, dbUploadedData.Extension);
Assert.AreEqual(newCurrentFile, dbUploadedData.CurrentFile);
Assert.AreEqual(newUploaderType, dbUploadedData.UploaderType);
Assert.AreEqual(newFileLocation, dbUploadedData.FileLocation);
Assert.AreEqual(newFileName, dbUploadedData.FileName);
Assert.AreEqual(uploadedData.ItemCaseId, dbUploadedData.ItemCaseId);
}
public static UploadedData CSVtoEntities(Stream fileStream)
{
int rowNumber = 0;
UploadedData uploadedData = new UploadedData();
TransactionDto transaction;
using (StreamReader sr = new StreamReader(fileStream))
{
decimal amount = 0;
//skip header
sr.ReadLine();
Regex csvParser = new Regex(",(?=(?:[^\"]*\"[^\"]*\")*(?![^\"]*\"))");
while (!sr.EndOfStream)
{
rowNumber++;
transaction = new TransactionDto();
try
{
string[] rows = csvParser.Split(sr.ReadLine());
if (rows.Length == 4)
{
if (String.IsNullOrEmpty(rows[0]))
{
transaction.Message = "No Account provided. ";
}
else
{
transaction.Account = rows[0].Trim();
}
if (String.IsNullOrEmpty(rows[1]))
{
transaction.Message += "No Description provided. ";
}
else
{
transaction.Description = rows[1].Trim();
}
if (String.IsNullOrEmpty(rows[2]))
{
transaction.Message += "No Currency Code provided. ";
}
else
{
transaction.CurrencyCode = rows[2].Trim();
}
if (!CurrencyHelper.ValidateCurrency(rows[2]))
{
transaction.Message += "Non existing Currency Code provided. ";
}
if (String.IsNullOrEmpty(rows[3]) || !Decimal.TryParse(rows[3], out amount))
{
transaction.Message += "No Amount provided. ";
}
else
{
transaction.Amount = amount;
}
if (!transaction.IsSuccess)
{
transaction.Message += " at row: " + rowNumber;
uploadedData.FailedData.Add(transaction);
}
else
{
uploadedData.InsertData.Add(transaction);
}
}
else if (rows.Length < 4)
{
transaction.Message = "Missing data at row " + rowNumber;
uploadedData.FailedData.Add(transaction);
}
else
{
transaction.Message = "Invalid chars at row " + rowNumber;
uploadedData.FailedData.Add(transaction);
}
}
catch (Exception ex)
{
transaction.Message = ex.InnerException.Message + " At row " + rowNumber;
uploadedData.FailedData.Add(transaction);
}
}
}
return(uploadedData);
}
