public async Task <ActionResult> Post()
{
var data = Request.Form.Files["data"];
string lastModified = Request.Form["lastModified"].ToString();
var total = Request.Form["total"];
var fileName = Request.Form["fileName"];
var index = Request.Form["index"];
var fileSize = long.Parse(Request.Form["fileSize"]);
string temporaryFile = Path.Combine($"{Directory.GetCurrentDirectory()}/wwwroot/", lastModified);
try
{
if (!Directory.Exists(temporaryFile))
{
Directory.CreateDirectory(temporaryFile);
}
string tempPath = Path.Combine(temporaryFile, index.ToString());
if (!Convert.IsDBNull(data))
{
await FileHelper.CreateFileAsync(data, tempPath);
}
bool mergeOk = false;
if (total == index)
{
var fileExtension = Path.GetExtension(fileName).ToLowerInvariant();
fileName = DateTime.Now.ToString("yyyyMMddHHmmss") + fileName;
var finalPath = Path.Combine($"{Directory.GetCurrentDirectory()}/wwwroot/", fileName);//最终的文件名（demo中保存的是它上传时候的文件名，实际操作肯定不能这样）
mergeOk = await FileHelper.MergeFileAsync(lastModified, finalPath);
if (mergeOk)
{
var saveFile = new Model.FileModel
{
FileName = fileName,
FilePath = finalPath,
ExtensionName = fileExtension,
FileSize = fileSize
};
await _fileRepository.AddAsync(saveFile);
}
}
Dictionary <string, object> result = new Dictionary <string, object>();
result.Add("number", index);
result.Add("mergeOk", mergeOk);
return(Ok(result));
}
catch (Exception ex)
{
Directory.Delete(temporaryFile);
throw ex;
}
}
public async Task <ResponseUploadFile> UploadFileAsync(IFormFile file, string uploader, bool allowCompress)
{
string localFilePath = string.Empty;
try
{
// Store a file into temp disk before proceeding
localFilePath = await SaveFormFileAsync(file);
// 1. Check all rules
foreach (var rule in _fileValidatorRules)
{
await rule.Validate(file, localFilePath);
}
// 2. Call Media Connector to upload
var storedFile = await _fileConnectorExecutions.First(a => a.FileStorageType == _fileOptions.CurrentValue.FileStorageType).StoreFileAsync(file, tempFilePath: localFilePath);
// 3. Store its into database
var createdId = DataUtil.GenerateUniqueId();
var createFile = new Entities.Files.File
{
Id = createdId,
Name = file.FileName,
DateUploaded = DateTime.UtcNow,
Uploader = uploader,
MIMEType = await GetFileMIMEType(localFilePath),
FileSize = file.Length,
FileStorageType = _fileOptions.CurrentValue.FileStorageType,
IdentifierOptions = storedFile.FileIdentifierOptions,
AllowCompress = allowCompress,
DownloadableUrl = storedFile.UseServerHost
? _filePublishOptions.CurrentValue.DownloadableHost + "/" + createdId
: storedFile.DownloadableUrl
};
await _fileRepository.AddAsync(createFile);
System.IO.File.Delete(localFilePath);
return(new ResponseUploadFile
{
FileId = createFile.Id,
DownloadableUrl = createFile.DownloadableUrl
});
}
finally
{
if (!string.IsNullOrEmpty(localFilePath))
{
System.IO.File.Delete(localFilePath);
}
}
}
public async Task <OutgoingFile> SaveAsync(string fileName, byte[] fileContents)
{
try
{
var filePath = await _fileStorage.SaveAsync(fileName, fileContents);
var incomingFile = new IncomingFile
{
AddedOn = DateTime.UtcNow,
FileName = fileName,
Path = filePath,
Size = fileContents.Length
};
var incomingFileEntity = _mapper.Map <File>(incomingFile);
var outgoingFileEntity = await _repository.AddAsync(incomingFileEntity);
var outgoingFile = _mapper.Map <OutgoingFile>(outgoingFileEntity);
return(outgoingFile);
}
catch (Exception e)
{
_logger.LogError(e, $"Unable to save {fileName}: {e.Message}");
throw;
}
}
public async Task <AvatarDTO> Save(IFormFile formFile)
{
var credentials = new BasicAWSCredentials(_configuration["AwsSettings:AccessKey"], _configuration["AwsSettings:SecretKey"]);
s3Client = new AmazonS3Client(credentials, RegionEndpoint.SAEast1);
string fileName = formFile.FileName;
string objectKey = $"{_configuration["AwsSettings:FolderName"]}/{fileName}";
string url = "";
using (Stream fileToUpload = formFile.OpenReadStream())
{
var putObjectRequest = new PutObjectRequest();
putObjectRequest.BucketName = _configuration["AwsSettings:BucketName"];
putObjectRequest.Key = objectKey;
putObjectRequest.InputStream = fileToUpload;
putObjectRequest.ContentType = formFile.ContentType;
var response = await s3Client.PutObjectAsync(putObjectRequest);
url = GeneratePreSignedURL(objectKey);
}
Avatar avatarSaved = await _fileRepository.AddAsync(new Avatar {
Name = fileName,
Url = url
});
AvatarDTO dto = _mapper.Map <AvatarDTO>(avatarSaved);
return(dto);
}
public async Task <Guid?> AddOrUpdateFileByIdAsync(IFormFile image, Guid?iconId, CancellationToken cancellationToken)
{
if (image == null)
{
return(iconId);
}
await using var memory = new System.IO.MemoryStream();
await image.CopyToAsync(memory, cancellationToken);
if (iconId.HasValue)
{
await _fileRepository.Delete(iconId.Value, cancellationToken);
}
var file = new File
{
Data = memory.ToArray(),
ContentType = image.ContentType
};
await _fileRepository.AddAsync(file, cancellationToken);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(file.Id);
}
public async Task <Unit> Handle(AddFileCommand request, CancellationToken cancellationToken)
{
var fileId = await _fileRepository.AddAsync(request.Filename, request.Content.ToArray(), cancellationToken);
request.FileId = fileId;
await _userRepository.AssignFileAsync(request.Username, request.FileId, UserFileStatus.Owner, cancellationToken);
return(Unit.Value);
}
public async Task <DocumentInfo> UploadFileAsync(UserFile file, Guid authorId, string host)
{
var filePath = await _diskFileService.UploadAsync(file, GetStoragePath());
var document = new File
{
AuthorId = authorId,
DownloadLink = $"{host}/api/files/download/{filePath}",
IsFilePathAbsolute = false,
Name = filePath.Split("/").Last(),
FriendlyName = file.FriendlyName
};
var savedDocument = await _fileRepository.AddAsync(document);
return(_mapper.Map <DocumentInfo>(savedDocument));
}
private async Task <FileDto> AddFileAsync(FileDto fileToAdd)
{
var result = _mapper.Map <FileDto, BlueprintFile>(fileToAdd);
result.CreatedDate = DateTime.UtcNow;
if (!_configuration.FileTypes.Contains(fileToAdd.Extension))
{
result.BackgroudProcessingStatus = (int?)BackgroudProcessingStatus.Processed;
}
await _fileRepository.AddAsync(result);
await _fileRepository.CommitAsync();
return(_mapper.Map <BlueprintFile, FileDto>(result));
}
public async Task <IFile> AddFileAsync(IFolder folder, string name, string contentType, Stream binary)
{
if (folder == null)
{
throw new ArgumentNullException(nameof(folder));
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
if (name.Contains("/"))
{
throw new ArgumentException("Cannot use path delimiter('/')", nameof(name));
}
if (string.IsNullOrEmpty(contentType))
{
throw new ArgumentNullException(nameof(contentType));
}
if (binary == null)
{
throw new ArgumentNullException(nameof(binary));
}
var userId = _resolver.GetUserId();
if (userId == null)
{
throw new UnauthorizedAccessException();
}
var path = CreateBinaryPath();
using (var stream = SysFile.OpenWrite(path))
{
await binary.CopyToAsync(stream);
}
var size = new FileInfo(path).Length;
var file = await _files.AddAsync(folder.Id, name, path, contentType, size, userId, DateTimeOffset.UtcNow);
return(Mapping.Mapper.Map <File>(file));
}
public async Task <IActionResult> UploadAsync([FromForm] FileDataDTO fileData)
{
try
{
int maxSize = Convert.ToInt32(config["AppDetails:AllowedFileSizeInMb"]) * 1000000;
if (fileData.File.Length > maxSize)
{
return(BadRequest("File is too big"));
}
string[] alloweFileTypes = config["AppDetails:AllowedFileTypes"].Split(",");
string extension = Path.GetExtension(fileData.File.FileName);
if (!alloweFileTypes.Contains(extension))
{
return(BadRequest("File extension is not allowed"));
}
string path = await fileService.SaveOnDriveAsync(fileData.File);
if (path == null)
{
// Such file already exists
return(BadRequest("File with such name already exists"));
}
var fileInstance = await fileRepository.AddAsync(new FileInstance()
{
Name = fileData.File.FileName,
SizeInMb = (double)fileData.File.Length / 1000000,
Path = path,
UploadDate = DateTime.Now,
UserWhoUploaded = fileData.UserWhoUploaded
});
return(Ok(fileInstance));
}
catch (Exception e)
{
// place to add logging
return(StatusCode(StatusCodes.Status500InternalServerError, e.Message));
}
}
public async Task <Unit> Handle(AddShareCommand request, CancellationToken cancellationToken)
{
var user = await _userRepository.FirstOrDefaultAsync(request.Sender, cancellationToken);
if (user.PrivateKeyPassword != request.PrivateKeyPassword.Sha512())
{
throw new Exception("Invalid private key password");
}
var decryptionResponse = _encryptor.Decrypt(user.PrivateKey, request.PrivateKeyPassword.Sha256AsBytes());
if (decryptionResponse.Status == Status.Failed)
{
throw new Exception();
}
request.Id = await _shareRepository.AddShareAsync(request.Title, request.Description, cancellationToken);
await _shareRepository.AddShareUserAsync(request.Id, request.Sender, ShareUserOwnershipStatus.Sender, cancellationToken);
foreach (var receiver in request.Receivers)
{
await _shareRepository.AddShareUserAsync(request.Id, receiver, ShareUserOwnershipStatus.Receiver, cancellationToken);
}
foreach (var file in request.Files)
{
var fileId = await _fileRepository.AddAsync(file.Name, file.Content, cancellationToken);
await _userRepository.AssignFileAsync(request.Sender, fileId, UserFileStatus.Owner, cancellationToken);
await _shareRepository.AddShareFileAsync(request.Id, fileId, cancellationToken);
var signResponse = await _ecdsa.SignFileAsync(file.Name, file.Content, decryptionResponse.DecryptedText);
await _shareRepository.AddShareFileUserAsync(request.Id, fileId, request.Sender,
signResponse.Signature, cancellationToken);
}
await _shareRepository.AcceptAsync(request.Id, request.Sender);
return(Unit.Value);
}
public async Task AddPhotoAsync(string path, Guid id, IFormFile photo)
{
var @user = await _userRepository.GetAsync(id);
int width = 0;
var productImage = Image.Load(photo.OpenReadStream());
int div = productImage.Height / 256;
int hight = productImage.Height / div;
if (productImage.Height < productImage.Width)
{
width = 256;
}
else
{
width = productImage.Width / div;
}
productImage.Mutate(x => x.Resize(width, hight));
await _fileRepository.AddAsync(productImage, path, user.Id);
user.SetImageLocation(Path.Combine(path + "\\uploads\\" + user.Id + ".png"));
await _userRepository.UpdateAsync(@user);
}
public async Task AddPhotoAsync(string path, Guid id, IFormFile photo)
{
var @product = await _productRepository.GetOrFailAsync(id);
int width = 0;
var productImage = Image.Load(photo.OpenReadStream());
int div = productImage.Height / 512;
int hight = productImage.Height / div;
if (productImage.Height < 2 * productImage.Width)
{
width = 1024;
}
else
{
width = productImage.Width / div;
}
productImage.Mutate(x => x.Resize(width, hight));
await _fileRepository.AddAsync(productImage, path, product.Id);
@product.SetImageLocation(Path.Combine(path + "\\uploads\\" + product.Id + ".png"));
await _productRepository.UpdateAsync(@product);
}
public async Task <IActionResult> Upload(string folder, List <IFormFile> files)
{
var resources = new List <string>();
foreach (var formFile in files)
{
if (formFile.Length > 0)
{
var resourceId = Guid.NewGuid().ToString();
resources.Add(resourceId);
await _fileRepository.AddAsync(new GenericFile(formFile.CopyToAsync)
{
Folder = folder,
ContentType = formFile.ContentType,
Name = formFile.FileName,
ResourceId = resourceId
});
}
}
return(Created(Url.Content("~/drive/file"), resources));
}
public async Task <IResultModel> Add(FileUploadModel model, FileInfo fileInfo)
{
var entity = new FileEntity
{
ModuleCode = model.ModuleCode,
Group = model.Group,
AccessMode = model.AccessMode,
FileName = fileInfo.FileName,
SaveId = fileInfo.SaveName.Split('.')[0],
Path = fileInfo.Path,
FullPath = fileInfo.FullPath,
Ext = fileInfo.Ext,
Size = fileInfo.Size.Size,
SizeName = fileInfo.Size.ToString(),
Md5 = fileInfo.Md5
};
var mime = await _mimeRepository.Get(fileInfo.Ext.ToLower());
if (mime != null)
{
entity.Mime = mime.Value;
}
using var uow = _dbContext.NewUnitOfWork();
var result = await _repository.AddAsync(entity, uow);
if (result)
{
#region ==绑定文件拥有者==
if (model.AccessMode == FileAccessMode.Auth && model.Accounts != null && model.Accounts.Any())
{
var owners = model.Accounts.Split(',')
.Select(accountId => new FileOwnerEntity
{
SaveId = entity.SaveId,
AccountId = Guid.Parse(accountId)
}).ToList();
await _ownerRepository.AddAsync(owners, uow);
}
#endregion
#region ==OSS上传==
var fileObject = new FileObject
{
ModuleCode = entity.ModuleCode,
Group = entity.Group,
AccessMode = entity.AccessMode,
PhysicalPath = model.PhysicalPath,
FileInfo = fileInfo
};
await _fileStorageProvider.Upload(fileObject);
entity.Url = fileInfo.Url;
#endregion
uow.Commit();
return(ResultModel.Success(entity));
}
return(ResultModel.Failed());
}
public async Task <File> AddAsync(int torrentId, IFormFile file)
{
Guard.Against.NullInvalid(file, "Invalid file");
if (string.IsNullOrWhiteSpace(file.FileName))
{
throw new RutrackerException(
"The file name cannot be empty.",
ExceptionEventTypes.InvalidParameters);
}
if (file.Length > _fileOptions.MaxSize)
{
throw new RutrackerException(
$"File '{file.Name}' is too large (more {_fileOptions.MaxSize} bytes).",
ExceptionEventTypes.InvalidParameters);
}
var torrent = await _torrentRepository.GetAsync(torrentId);
if (torrent == null)
{
throw new RutrackerException(
$"The torrent with '{torrentId}' not found",
ExceptionEventTypes.InvalidParameters);
}
if (torrent.IsStockTorrent)
{
throw new RutrackerException(
"Cannot add the file to the stock torrent.",
ExceptionEventTypes.InvalidParameters);
}
var result = await _fileRepository.AddAsync(new File
{
Name = file.FileName,
BlobName = $"{Path.GetFileNameWithoutExtension(file.FileName)}-{Guid.NewGuid():N}{Path.GetExtension(file.FileName)}",
Size = file.Length,
Type = file.ContentType,
TorrentId = torrentId
});
await _unitOfWork.SaveChangesAsync();
var containerName = torrentId.ToString().PadLeft(10, '0');
var fileName = result.BlobName;
var contentType = result.Type;
var stream = file.OpenReadStream();
var url = await _storageService.UploadFileAsync(containerName, fileName, contentType, stream);
result.Url = url;
torrent.Size += result.Size;
_fileRepository.Update(result);
_torrentRepository.Update(torrent);
await _unitOfWork.SaveChangesAsync();
return(result);
}
public async Task <bool> Handle(ResizeImageCommand request, CancellationToken cancellationToken)
{
var criteria = new ImageResizeCriteria(request.ImageId, request.Query);
var criteriaValidator = new ImageResizeCriteriaValidator(_configuration);
Guard.AgainstInvalidArgumentWithMessage("Invalid criteria", criteriaValidator.ValidCriteria(criteria));
(int?width, int?height)widthHeightPair = criteriaValidator.GetCriteria(criteria);
var files = _fileRepository.GetFiles(criteria.ImageId, widthHeightPair.width, widthHeightPair.height);
Guard.AgainstNullOrNotAny("Files", files);
var originalImage = files.FirstOrDefault(file => file.Id == request.ImageId);
Guard.AgainstNull("OriginalFile", originalImage);
//if request has no param -> ask for original image -> return directly to original image
if (criteria.Empty)
{
return(true);
}
//resized image is always the first one in the list
var fileResized = files.OrderByDescending(file => file.OriginalId)
.FirstOrDefault();
bool canResize = _imageService.CanResize(widthHeightPair, (fileResized.Width, fileResized.Height));
Guard.AgainstInvalidOperationWithMessage("Cannot Resize this picture with given resolution", canResize);
bool shouldResize = _imageService.ShouldResize(((int)originalImage.Width, (int)originalImage.Height), widthHeightPair);
if (!shouldResize)
{
return(true);
}
//file not exist
if (fileResized.OriginalId == null)
{
if ((widthHeightPair.width == null || fileResized.Width == widthHeightPair.width) &&
(widthHeightPair.height == null || fileResized.Height == widthHeightPair.height))
{
return(true);
}
using (var imageData = _imageService.ReadImage(fileResized.FilePath))
{
var oldFileName = Path.GetFileName(fileResized.FilePath);
string fileExtension = Path.GetExtension(fileResized.FilePath);
var imagePath = Path.GetDirectoryName(fileResized.FilePath);
var newFileName = string.Concat(Path.GetFileNameWithoutExtension(oldFileName),
widthHeightPair.width == null ? "" : $"_w{widthHeightPair.width}",
widthHeightPair.height == null ? "" : $"_h{widthHeightPair.height}",
fileExtension);
string cloudPath = PathHelper.CombineUrl(imagePath.Replace(_configuration.RootDataFolder, _configuration.CloudDataUrl), string.Empty);
using (FileStream outputStream = new FileStream(Path.Combine(imagePath, newFileName), FileMode.CreateNew))
{
(int?width, int?height)sizeAfterResized = await _imageService.ResizeImage(imageData, (widthHeightPair.width, widthHeightPair.height), fileExtension, outputStream);
var filebuilder = new FileBuilder();
var newFile = filebuilder.BuildCloudUrl(cloudPath, newFileName)
.BuildFilePath(imagePath, newFileName)
.BuildFileInfo(new BlueprintFile
{
CreatedDate = DateTime.UtcNow,
CreatedBy = nameof(System),
FileType = fileResized.FileType,
Height = sizeAfterResized.height,
Width = sizeAfterResized.width,
OriginalFileName = newFileName,
Source = fileResized.Source,
OriginalId = fileResized.Id,
Extension = fileResized.Extension,
CompanyId = fileResized.CompanyId
})
.Build();
await _fileRepository.AddAsync(newFile);
await _fileRepository.CommitAsync();
return(true);
}
}
}
return(true);
}