public async Task <IEnumerable <GridFSFileInfo> > GetLogFilesInfoByName(string fileName)
{
var filter = Builders <GridFSFileInfo> .Filter.Eq <string>(info => info.Filename, fileName);
var fileInfos = await _gridFS.FindAsync(filter);
return(await fileInfos.ToListAsync());
}
public async Task <long> GetFilesCountAsync()
{
var filter = Builders <GridFSFileInfo> .Filter.Empty;
var options = new GridFSFindOptions {
};
long counter = 0;
using IAsyncCursor <GridFSFileInfo> cursor = await gridFSBucket.FindAsync(filter, options);
await cursor.ForEachAsync(x => counter++);
return(counter);
}
public async Task <long> GetSizeAsync(string fileName,
CancellationToken ct = default)
{
var name = GetFileName(fileName, nameof(fileName));
var fileQuery = await bucket.FindAsync(Filters.Eq(x => x.Id, name), cancellationToken : ct);
var fileObject = await fileQuery.FirstOrDefaultAsync(ct);
if (fileObject == null)
{
throw new AssetNotFoundException(fileName);
}
return(fileObject.Length);
}
/// <summary>
/// Сохранить файл в стор
/// </summary>
/// <param name="file">файл</param>
/// <param name="cancellationToken">токен признака отмены</param>
/// <returns>Идентификатор сохранённого файла</returns>
public async Task <String> SaveFileAsync(IFormFile file, CancellationToken cancellationToken)
{
var hash = await GetHash(file, cancellationToken);
var filter = Builders <GridFSFileInfo> .Filter.Eq(info => info.Metadata["hash"], hash);
var existsFiles = await _gridFs.FindAsync(filter, cancellationToken : cancellationToken);
var existsFile = await existsFiles.FirstOrDefaultAsync(cancellationToken);
if (existsFile != null)
{
return(existsFile.Metadata["FileName"].AsString);
}
var fileName = Guid.NewGuid().ToString();
var metaData = new Dictionary <String, Object>
{
["ContentType"] = file.ContentType,
["length"] = file.Length,
["NonUniqueExtId"] = file.FileName,
["FileName"] = fileName,
["hash"] = hash,
};
await _gridFs.UploadFromStreamAsync(
fileName,
file.OpenReadStream(),
new GridFSUploadOptions
{
Metadata = new BsonDocument(metaData)
}, cancellationToken);
return(fileName);
}
//Async
public async Task <IStorageFile> CreateFileAsync(string path, byte[] arr = null)
{
if (arr == null)
{
arr = new byte[0];
}
var id = await _bucket.UploadFromBytesAsync(path, arr);
var info = _bucket.FindAsync(Builders <GridFSFileInfo> .Filter.Eq("_id", id)).Result.First();
return(new GridFSFileStorage(info, _bucket));
}
public async Task <string> GetFileName(string id, FileTypeEnum fileType)
{
var builder = Builders <GridFSFileInfo> .Filter;
var filter = builder.Eq("_id", new ObjectId(id)) & builder.Eq("Metadata.type", (int)fileType);
var cursor = await _gridFS.FindAsync(filter);
var result = cursor.FirstOrDefault();
return(result?.Filename);
}
public async void ReNameFile(string fileName, string newFileName)
{
var filter = Builders <GridFSFileInfo> .Filter.Eq(x => x.Filename, fileName);
var filesCursor = await _gridFsBucket.FindAsync(filter);
var files = await filesCursor.ToListAsync();
foreach (var file in files)
{
await _gridFsBucket.RenameAsync(file.Id, newFileName);
}
}
public async Task <long> GetSizeAsync(string fileName, CancellationToken ct = default)
{
var name = GetFileName(fileName, nameof(fileName));
var find = await bucket.FindAsync(Builders <GridFSFileInfo <string> > .Filter.Eq(x => x.Id, name), cancellationToken : ct);
var file = await find.FirstOrDefaultAsync(ct);
if (file == null)
{
throw new AssetNotFoundException(fileName);
}
return(file.Length);
}
public async Task <Model.FileMetadata> GetFileMetadata(HostConfig host, string file)
{
var index = file.LastIndexOf('.');
file = index == -1 ? file : file.Substring(0, index); //remove extension if any
IGridFSBucket bucket = GetBucket(host);
try
{
var ob = new ObjectId(file);
if (ob == ObjectId.Empty)
{
return(null);
}
var filter = Builders <GridFSFileInfo> .Filter.Eq("_id", ob);
var findOptions = new GridFSFindOptions
{
Limit = 1
};
var fi = await bucket.FindAsync(filter, findOptions);
var metadata = BsonSerializer.Deserialize <Model.FileMetadata>(fi.FirstOrDefault().Metadata);
return(metadata);
}
catch (ArgumentException ex)
{
throw new GridFsObjectIdException(ex.Message);
}
catch (FormatException ex)
{
throw new GridFsObjectIdException(ex.Message);
}
catch (Exception ex)
{
if (ex is GridFSFileNotFoundException || ex is IndexOutOfRangeException || ex is ArgumentNullException)
{
return(null);
}
//log other errors....
throw;
}
}
public async Task <(Stream, StoredFileInfo)> GetAsync(string fileId, CancellationToken cancellationToken = default)
{
_ = fileId ?? throw new ArgumentNullException(nameof(fileId));
IGridFSBucket bucket = getBucket(_dbClient);
FilterDefinition <GridFSFileInfo> filter = Builders <GridFSFileInfo> .Filter.Eq(p => p.Filename, fileId);
using var cursor = await bucket.FindAsync(filter, null, cancellationToken);
var file = await cursor.FirstOrDefaultAsync(cancellationToken);
if (file == null)
{
return(null, null);
}
var stream = await bucket.OpenDownloadStreamAsync(file.Id, null, cancellationToken);
return(stream, BsonSerializer.Deserialize <StoredFileInfo>(file.Metadata));
}
public byte[] Download(ObjectId fileId)
{
var filter = Builders <GridFSFileInfo <ObjectId> >
.Filter.Eq(x => x.Id, fileId);
var searchResult = bucket.FindAsync(filter);
var fileEntry = searchResult.Result.SingleOrDefault();
if (fileEntry == null)
{
content = null;
}
else
{
content = bucket.DownloadAsBytesAsync(fileId).Result;
}
return(content);
}
public async Task DeleteFileAsync(string taskId)
{
try
{
var files = await _gridFs.FindAsync(
new ExpressionFilterDefinition <GridFSFileInfo>(x => x.Filename == taskId));
var file = await files.FirstOrDefaultAsync();
if (file != null)
{
await _gridFs.DeleteAsync(file.Id);
}
}
catch (Exception e)
{
_logger.LogError("Error occured while uploading {@TaskId} in {@AgentName} with {@Exception}",
taskId, nameof(FileWorkerAgentImpl), e.ToString());
}
}
public async Task <bool> DeleteAsync(Guid id, CancellationToken cancellationToken)
{
FilterDefinition <GridFSFileInfo> filter = Builders <GridFSFileInfo> .Filter
.Eq(x => x.Filename, id.ToString("N"));
IAsyncCursor <GridFSFileInfo> cursor = await _gridFSBucket
.FindAsync(filter, options : null, cancellationToken);
GridFSFileInfo?file = cursor.FirstOrDefault(cancellationToken);
if (file != null)
{
await _gridFSBucket.DeleteAsync(file.Id, cancellationToken);
Log.Information("Thmbnail {Filename} deleted.", id);
return(true);
}
return(false);
}
async Task <DocumentInfo?> IQueryHandler <GetImgQuery, DocumentInfo?> .Handle(GetImgQuery query, CancellationToken cancellationToken)
{
var filter = Builders <GridFSFileInfo> .Filter.Eq(info => info.Filename, query.ImageId.ToString());
var fileInfo = (await _gridFs.FindAsync(filter, null, cancellationToken)).FirstOrDefault();
if (fileInfo == null)
{
return(null);
}
var memstream = new MemoryStream();
await _gridFs.DownloadToStreamAsync(fileInfo.Id, memstream, cancellationToken : cancellationToken);
return(new DocumentInfo(
id: query.ImageId,
memoryStream: memstream,
contentType: fileInfo.Metadata["ContentType"].ToString(),
length: fileInfo.Length,
fileName: fileInfo.Metadata.Contains("FileName") ? fileInfo.Metadata["FileName"].ToString() : "",
nonUniqueExtId: fileInfo.Metadata.Contains("NonUniqueExtId") ? fileInfo.Metadata["NonUniqueExtId"].ToString() : ""
));
}
public void Initialize()
{
try
{
_bucket.FindAsync(Builders <GridFSFileInfo <BsonValue> > .Filter.Eq(info => info.Filename, ""))
.ContinueWith(task => _ = task.Exception, default, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
