public IActionResult Upload(IList <IFormFile> files)
{
foreach (var file in files)
{
ContentDispositionHeaderValue header = ContentDispositionHeaderValue.Parse(file.ContentDisposition);
string fileName = header.FileName;
fileName = fileName.Trim('"');
fileName = Path.GetFileName(fileName);
MemoryStream ms = new MemoryStream();
Stream s = file.OpenReadStream();
s.CopyTo(ms);
byte[] data = ms.ToArray();
s.Dispose();
ms.Dispose();
UploadedFile primaryObj = new UploadedFile();
primaryObj.FileName = fileName;
primaryObj.ContentType = file.ContentType;
primaryObj.Size = file.Length;
primaryObj.TimeStamp = DateTime.Now;
primaryObj.FileContent = data;
IUploadedFile backupObj = primaryObj.Clone();
//IUploadedFile backupObj = primaryObj.DeepCopy();
//send primaryObj to main system
//send backupObj to backup system
}
ViewBag.Message = files.Count + " file(s) uploaded successfully!";
return(View("Index"));
}
public async Task SaveFile(IUploadedFile uploadedFile, DocumentAsset documentAsset)
{
using (var inputSteam = await uploadedFile.OpenReadStreamAsync())
{
bool isNew = documentAsset.DocumentAssetId < 1;
documentAsset.FileExtension = Path.GetExtension(uploadedFile.FileName).TrimStart('.');
documentAsset.FileSizeInBytes = Convert.ToInt32(inputSteam.Length);
documentAsset.ContentType = uploadedFile.MimeType;
// Save at this point if it's a new image
if (isNew)
{
await _dbContext.SaveChangesAsync();
}
var fileName = Path.ChangeExtension(documentAsset.DocumentAssetId.ToString(), documentAsset.FileExtension);
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
// Save the raw file directly
await CreateFileAsync(isNew, fileName, inputSteam);
if (!isNew)
{
await _dbContext.SaveChangesAsync();
}
await scope.CompleteAsync();
}
}
}
/// <summary>
/// Some shared validation to prevent image asset types from being added to documents.
/// </summary>
public static IEnumerable <ValidationResult> Validate(IUploadedFile file)
{
if (file != null && !string.IsNullOrWhiteSpace(file.FileName))
{
// Validate extension & mime type
var ext = Path.GetExtension(file.FileName)?.Trim();
if (string.IsNullOrWhiteSpace(ext))
{
yield return(new ValidationResult("The file you're uploading has no file extension.", new string[] { "File" }));
}
else if (FilePathHelper.FileExtensionContainsInvalidChars(ext))
{
yield return(new ValidationResult("The file you're uploading uses an extension containing invalid characters.", new string[] { "File" }));
}
else if ((ImageAssetConstants.PermittedImageTypes.ContainsKey(ext)) ||
(!string.IsNullOrEmpty(file.MimeType) && ImageAssetConstants.PermittedImageTypes.ContainsValue(file.MimeType)))
{
yield return(new ValidationResult("Image files shoud be uploaded in the image assets section.", new string[] { "File" }));
}
// Validate filename
if (string.IsNullOrWhiteSpace(file.FileName))
{
yield return(new ValidationResult("The file you're uploading has no file name.", new string[] { "File" }));
}
else if (string.IsNullOrWhiteSpace(FilePathHelper.CleanFileName(file.FileName)))
{
yield return(new ValidationResult("The file you're uploading has an invalid file name.", new string[] { "File" }));
}
}
}
public void Loading(IUploadedFile uploadedFile)
{
uploadedFile.Path = @"\Files\" + uploadedFile.UploadedFile.FileName;
using (var fileStream = new FileStream(uploadedFile.Root + uploadedFile.Path, FileMode.OpenOrCreate))
{
uploadedFile.UploadedFile.CopyTo(fileStream);
}
}
public override void Upload(string container, string path, IUploadedFile file)
{
var storageAccount = new CloudStorageAccount(new StorageCredentials(ExtendedProperties["accountName"], ExtendedProperties["accessKey"]), true);
var blobClient = storageAccount.CreateCloudBlobClient();
var cloudContainer = blobClient.GetContainerReference(container);
cloudContainer.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
var blockBlob = cloudContainer.GetBlockBlobReference(path);
blockBlob.UploadFromStream(file.Stream);
}
public override void Upload(string container, string path, IUploadedFile file)
{
client = AWSClientFactory.CreateAmazonS3Client(ExtendedProperties["accessKey"], ExtendedProperties["secretKey"], RegionEndpoint.USEast1);
String S3_KEY = path;
PutObjectRequest request = new PutObjectRequest();
request.BucketName = container;
request.Key = S3_KEY;
request.InputStream = file.Stream;
client.PutObject(request);
}
/// <summary>
/// Some shared validation to prevent image asset types from being added to documents.
/// </summary>
public static IEnumerable <ValidationResult> Validate(IUploadedFile file)
{
if (file != null && !string.IsNullOrWhiteSpace(file.FileName))
{
var ext = Path.GetExtension(file.FileName);
if ((ImageAssetConstants.PermittedImageTypes.ContainsKey(ext)) ||
(!string.IsNullOrEmpty(file.MimeType) && ImageAssetConstants.PermittedImageTypes.ContainsValue(file.MimeType)))
{
yield return(new ValidationResult("Image files shoud be uploaded in the image assets section.", new string[] { "File" }));
}
}
}
public async Task UpdateStudentProfile()
{
byte[] mockImgData = Enumerable.Range(0, 10)
.Select(n => (byte)n)
.ToArray();
Mock <IUploadedFile> fileMock = new Mock <IUploadedFile>();
fileMock
.Setup(file => file.GetFileDataAsync())
.ReturnsAsync(mockImgData);
IUploadedFile mockedFile = fileMock.Object;
_imgMock
.Setup(imgService => imgService.SaveProfileImage(mockedFile))
.ReturnsAsync(new ResultMessage <string>("testpath"));
IServicesExecutor <StudentDTO, Student> executor
= new ServiceExecutor <StudentDTO, Student>(_context, _handlerMock.Object);
IStudentService studentService = new StudentService(executor);
Mock <IErrorHandler> handlerMock = new Mock <IErrorHandler>();
IStudentManagmentService studMngService
= new StudentManagmentService(
_emailMock.Object,
studentService,
_regMock.Object,
_sharedConfigMock.Object,
_imgMock.Object,
handlerMock.Object,
_context);
Student stud = await _context.Students.FirstOrDefaultAsync();
string newUsername = "******";
string newDescription = "New description";
await studMngService.EditStudentProfile(stud.StudentId, new ProfileUpdateDTO
{
Username = "******",
Description = "New description",
Photo = fileMock.Object
});
stud = await _context.Students.FirstOrDefaultAsync(s => s.StudentId == stud.StudentId);
Assert.AreEqual(newUsername, stud.Username);
Assert.AreEqual(newDescription, stud.Description);
_imgMock.Verify(imgService => imgService.SaveProfileImage(mockedFile), Times.Once);
}
public ActionResult Upload(string title, string description, IPrincipal principal, IUploadedFile file)
{
if (!principal.Identity.IsAuthenticated)
return new RedirectResult(FormsAuthentication.LoginUrl);
if (file.ContentLength > 0)
{
TadImage oNewImage = TadImage.NewTadImage(file.InputStream, Guid.NewGuid() + Path.GetExtension(file.FileName));
oNewImage.Title = title;
oNewImage.Description = description;
oNewImage.Save(HttpContext.User.Identity);
}
return RedirectToAction("Index", "Home");
}
public ActionResult Upload(string title, string description, IPrincipal principal, IUploadedFile file)
{
if (file.ContentLength > 0)
{
TadmapImage image = new TadmapImage();
image.Title = title ?? Path.GetFileNameWithoutExtension(file.FileName);
image.Description = description ?? "";
image.Key = Guid.NewGuid() + Path.GetExtension(file.FileName);
image.ImageSet = new ImageSet1(image.Key);
image.UserId = (principal.Identity as TadmapIdentity).Id;
_imageRepository.Save(image);
}
return RedirectToAction("Index", "Home");
}
public IUploadedFile DeepCopy()
{
if (!this.GetType().IsSerializable)
{
throw new Exception("object is not serializable");
}
BinaryFormatter formatter = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
formatter.Serialize(ms, this);
ms.Seek(0, SeekOrigin.Begin);
IUploadedFile deepCopy = (IUploadedFile)formatter.Deserialize(ms);
ms.Close();
return(deepCopy);
}
public async Task SaveFile(IUploadedFile uploadedFile, DocumentAsset documentAsset)
{
documentAsset.ContentType = _mimeTypeService.MapFromFileName(uploadedFile.FileName, uploadedFile.MimeType);
documentAsset.FileExtension = Path.GetExtension(uploadedFile.FileName).TrimStart('.');
documentAsset.FileNameOnDisk = "file-not-saved";
_assetFileTypeValidator.ValidateAndThrow(documentAsset.FileExtension, documentAsset.ContentType, "File");
ValidateFileType(documentAsset);
var fileStamp = AssetFileStampHelper.ToFileStamp(documentAsset.FileUpdateDate);
using (var inputSteam = await uploadedFile.OpenReadStreamAsync())
{
bool isNew = documentAsset.DocumentAssetId < 1;
documentAsset.FileSizeInBytes = Convert.ToInt32(inputSteam.Length);
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
// Save at this point if it's a new file
if (isNew)
{
await _dbContext.SaveChangesAsync();
}
// update the filename
documentAsset.FileNameOnDisk = $"{documentAsset.DocumentAssetId}-{fileStamp}";
var fileName = Path.ChangeExtension(documentAsset.FileNameOnDisk, documentAsset.FileExtension);
// Save the raw file directly
await CreateFileAsync(isNew, fileName, inputSteam);
// Update the filename
await _dbContext.SaveChangesAsync();
await scope.CompleteAsync();
}
}
}
/// <summary>
/// Saves student's profile image.
/// </summary>
/// <param name="file">Information about file</param>
/// <returns>Uri of the image</returns>
public async Task <ResultMessage <string> > SaveProfileImage(IUploadedFile file)
{
byte[] processedImage;
using (Stream imgStream = file.OpenReadStream())
{
processedImage = PreprocessImage(imgStream);
}
if (processedImage == null)
{
return(new ResultMessage <string>(OperationStatus.UnknownError));
}
string path = PathBuilder.BuildPathForProfileImage();
ResultMessage <bool> result = await _docService.UploadDocumentToStorage(path, processedImage);
if (result.IsSuccess)
{
return(new ResultMessage <string>(path));
}
else
{
return(new ResultMessage <string>(OperationStatus.FileSystemError));
}
}
public async Task SaveAsync(
IUploadedFile uploadedFile,
ImageAsset imageAsset,
string propertyName
)
{
Image <Rgba32> imageFile = null;
IImageFormat imageFormat = null;
using (var inputSteam = await uploadedFile.OpenReadStreamAsync())
{
try
{
imageFile = Image.Load(inputSteam, out imageFormat);
}
catch (ArgumentException ex)
{
// We'll get an argument exception if the image file is invalid
// so lets check to see if we can identify if it is an invalid file type and show that error
// This might not always be the case since a file extension or mime type might not be supplied.
var ext = Path.GetExtension(uploadedFile.FileName);
if ((!string.IsNullOrEmpty(ext) && !ImageAssetConstants.PermittedImageTypes.ContainsKey(ext)) ||
(!string.IsNullOrEmpty(uploadedFile.MimeType) && !ImageAssetConstants.PermittedImageTypes.ContainsValue(uploadedFile.MimeType)))
{
throw ValidationErrorException.CreateWithProperties("The file is not a supported image type.", propertyName);
}
throw;
}
using (imageFile) // validate image file
{
ValidateImage(propertyName, imageFile, imageFormat);
var requiredReEncoding = true;
var fileExtension = "jpg";
var foundExtension = _permittedImageFileExtensions
.FirstOrDefault(e => imageFormat.FileExtensions.Contains(e));
if (foundExtension != null)
{
fileExtension = foundExtension;
requiredReEncoding = false;
}
imageAsset.WidthInPixels = imageFile.Width;
imageAsset.HeightInPixels = imageFile.Height;
imageAsset.FileExtension = fileExtension;
imageAsset.FileSizeInBytes = inputSteam.Length;
using (var scope = _transactionScopeManager.Create(_dbContext))
{
var fileName = Path.ChangeExtension(imageAsset.FileNameOnDisk, imageAsset.FileExtension);
if (requiredReEncoding)
{
// Convert the image to jpg
using (var outputStream = new MemoryStream())
{
if (requiredReEncoding)
{
imageFile.Save(outputStream, new JpegEncoder());
}
else
{
imageFile.Save(outputStream, imageFormat);
}
await _fileStoreService.CreateAsync(ASSET_FILE_CONTAINER_NAME, fileName, outputStream);
// recalculate size and save
imageAsset.FileSizeInBytes = outputStream.Length;
}
}
else
{
// Save the raw file directly
await _fileStoreService.CreateAsync(ASSET_FILE_CONTAINER_NAME, fileName, inputSteam);
}
await _dbContext.SaveChangesAsync();
await scope.CompleteAsync();
};
}
}
}
public abstract void Upload(string containerName, string fileName, IUploadedFile file);
public Task SaveAsync(IUploadedFile uploadedFile, ImageAsset imageAsset, string propertyName)
{
throw new ImageAssetFileServiceNotImplementedException();
}
public Task SaveAsync(IUploadedFile uploadedFile, ImageAsset imageAsset, string propertyName)
{
throw new NotImplementedException("No image file plugin installed. To use image assets you need to reference an image asset plugin.");
}
public async Task SaveFile(IUploadedFile uploadedFile, ImageAsset imageAsset)
{
Image imageFile = null;
using (var inputSteam = await uploadedFile.GetFileStreamAsync())
{
try
{
imageFile = Image.FromStream(inputSteam);
}
catch (ArgumentException ex)
{
// We'll get an argument exception if the image file is invalid
// so lets check to see if we can identify if it is an invalid file type and show that error
// This might not always be the case since a file extension or mime type might not be supplied.
var ext = Path.GetExtension(uploadedFile.FileName);
if ((!string.IsNullOrEmpty(ext) && !ImageAssetConstants.PermittedImageTypes.ContainsKey(ext)) ||
(!string.IsNullOrEmpty(uploadedFile.MimeType) && !ImageAssetConstants.PermittedImageTypes.ContainsValue(uploadedFile.MimeType)))
{
throw new PropertyValidationException("The file is not a supported image type.", "File");
}
throw;
}
using (imageFile) // validate image file
{
bool requiredReEncoding = !_permittedImageFileExtensionMap.ContainsKey(imageFile.RawFormat);
bool isNew = imageAsset.ImageAssetId < 1;
var imageFormat = requiredReEncoding ? ImageFormat.Jpeg : imageFile.RawFormat;
imageAsset.Width = imageFile.Width;
imageAsset.Height = imageFile.Height;
imageAsset.Extension = _permittedImageFileExtensionMap[imageFormat].First().TrimStart('.');
imageAsset.FileSize = Convert.ToInt32(inputSteam.Length);
// Save at this point if it's a new image
if (isNew)
{
await _dbContext.SaveChangesAsync();
}
using (var scope = _transactionScopeFactory.Create())
{
var fileName = Path.ChangeExtension(imageAsset.ImageAssetId.ToString(), imageAsset.Extension);
if (requiredReEncoding)
{
// Convert the image to jpg
using (var outputStream = new MemoryStream())
{
imageFile.Save(outputStream, imageFormat);
CreateFile(isNew, fileName, outputStream);
// recalculate size and save
imageAsset.FileSize = Convert.ToInt32(outputStream.Length);
await _dbContext.SaveChangesAsync();
}
}
else
{
// Save the raw file directly
CreateFile(isNew, fileName, inputSteam);
}
scope.Complete();
};
}
}
}
