public async Task Delete(string key)
{
key.Should().NotBeNullOrEmpty();
var filter = Builders <GridFSFileInfo> .Filter.Where(x => x.Filename == key);
while (true)
{
var find_option = new GridFSFindOptions()
{
Skip = 0,
Limit = 100,
};
using var res = await this.bucket.FindAsync(filter, find_option);
var list = await res.ToListAsync();
if (!list.Any())
{
break;
}
foreach (var m in list)
{
await this.bucket.DeleteAsync(m.Id);
}
}
}
private async Task <ObjectId> FindbyFilename(string fileName)
{
var filter = Builders <GridFSFileInfo> .Filter.And(
Builders <GridFSFileInfo> .Filter.Eq(x => x.Filename, fileName)
);
var sort = Builders <GridFSFileInfo> .Sort.Descending(x => x.UploadDateTime);
var options = new GridFSFindOptions
{
Limit = 1,
Sort = sort
};
using (var cursor = await _repo.bucket.FindAsync(filter, options))
{
var fileInfo = (await cursor.ToListAsync()).FirstOrDefault();
if (fileInfo != null)
{
return(fileInfo.Id);
}
}
return(ObjectId.Empty);
}
public void UploadImage(Image imageToUpload, string imageName)
{
var cardHashName = imageName.Substring(0, 4) +
imageName.Substring(imageName.Length - 8, 4) +
imageName.Substring(imageName.Length - 4, 4);
MongoClient client = connection();
var db = client.GetDatabase("CreditCardIMG");
var bucket = new GridFSBucket(db);
Image img = imageToUpload;
byte[] source = ImageToByteArray(img);
if (IsImageExist(cardHashName))
{
var filter = Builders <GridFSFileInfo> .Filter.And(
Builders <GridFSFileInfo> .Filter.Eq(x => x.Filename, cardHashName));
var options = new GridFSFindOptions
{
Limit = 1
};
using (var cursor = bucket.Find(filter, options))
{
var fileInfo = cursor.ToList().FirstOrDefault();
bucket.Delete(fileInfo.Id);
bucket.UploadFromBytes(cardHashName, source);
}
}
else
{
bucket.UploadFromBytes(cardHashName, source);
}
}
public bool IsImageExist(string imageName)
{
MongoClient client = connection();
var db = client.GetDatabase("CreditCardIMG");
var bucket = new GridFSBucket(db);
var filter = Builders <GridFSFileInfo> .Filter.And(
Builders <GridFSFileInfo> .Filter.Eq(x => x.Filename, imageName));
var options = new GridFSFindOptions
{
Limit = 1
};
using (var cursor = bucket.Find(filter, options))
{
var fileInfo = cursor.ToList().FirstOrDefault();
if (fileInfo == null)
{
return(false);
}
else
{
return(true);
}
}
}
public byte[] ReadImage(string cardNumber)
{
MongoClient client = connection();
var db = client.GetDatabase("CreditCardIMG");
var bucket = new GridFSBucket(db);
var filter = Builders <GridFSFileInfo> .Filter.And(
Builders <GridFSFileInfo> .Filter.Eq(x => x.Filename, cardNumber));
var options = new GridFSFindOptions
{
Limit = 1
};
using (var cursor = bucket.Find(filter, options))
{
var fileInfo = cursor.ToList().FirstOrDefault();
if (fileInfo == null)
{
return(ReadImage("000000001111")); //Image Not Available.
}
else
{
var imageToReturn = bucket.DownloadAsBytes(fileInfo.Id);
return(imageToReturn);
}
}
}
private ObjectId FindImage(string fileName)
{
var filter = Builders <GridFSFileInfo> .Filter.Eq(x => x.Filename, fileName);
var sort = Builders <GridFSFileInfo> .Sort.Descending(x => x.UploadDateTime);
var options = new GridFSFindOptions
{
Sort = sort,
Limit = 1
};
//现在到这个文件的objectId,
var cursor = dbContext.Bucket.Find(filter, options);
using (cursor)
{
if (cursor == null)
{
throw new ArgumentNullException($"mongoDb找不到这图片,文件名:{fileName}");
}
else
{
var fileInfo = cursor.SingleOrDefault();
ObjectId id = fileInfo.Id;
return(id);
}
}
}
public async Task <MemoryStream> downTileData(string fileName)
{
GridFSFileInfo fileInfo;
var filter = Builders <GridFSFileInfo> .Filter.Eq(x => x.Filename, fileName);
var options = new GridFSFindOptions
{
Limit = 1
};
using (var cursor = gridFSBucket.Find(filter, options))
{
fileInfo = cursor.ToList().FirstOrDefault();
}
if (fileInfo.Id != null)
{
GridFSDownloadStream gridFSDownloadStream = gridFSBucket.OpenDownloadStream(fileInfo.Id);
}
MemoryStream destination = new MemoryStream();
destination.Seek(0, SeekOrigin.Begin);
await gridFSBucket.DownloadToStreamByNameAsync(fileName, destination);
if (destination != null)
{
return(destination);
}
else
{
return(null);
}
}
public async void CleanBucket()
{
var batch = 100;
var filter = Builders <GridFSFileInfo> .Filter.And(
Builders <GridFSFileInfo> .Filter.Lt(x => x.Metadata[RetainDataUntil], DateTime.UtcNow));
var sort = Builders <GridFSFileInfo> .Sort.Descending(x => x.UploadDateTime);
var options = new GridFSFindOptions
{
Limit = batch,
Sort = sort
};
var again = false;
do
{
using (var cursor = await Context.Bucket.FindAsync(filter, options))
{
var fileInfos = (await cursor.ToListAsync());
again = fileInfos.Count() == batch;
Task.WaitAll(fileInfos.Select(fileInfo => Context.Bucket.DeleteAsync(fileInfo.Id)).ToArray());
}
}while (again);
}
/// <summary>
/// 查找一个文件信息
/// </summary>
/// <param name="id">文件id</param>
/// <returns></returns>
public GridFSFileInfo FindingFile(string filename) //ObjectId objectId
{
//ObjectId objectId = new ObjectId(id);
IGridFSBucket bucket = GetGridFSBucket();
//FilterDefinition<GridFSFileInfo> filter = Builders<GridFSFileInfo>.Filter.Where(t => t.Id.ToString() == id);
//FilterDefinition<GridFSFileInfo> filter = Builders<GridFSFileInfo>.Filter.Eq(t => t.Id, objectId);
FilterDefinition <GridFSFileInfo> filter = Builders <GridFSFileInfo> .Filter.Eq(t => t.Filename, filename);
SortDefinition <GridFSFileInfo> sort = Builders <GridFSFileInfo> .Sort.Descending(x => x.UploadDateTime);
var options = new GridFSFindOptions
{
Limit = 1,
Sort = sort
};
//var cursor = bucket.Find(filter, options);
var cursor = bucket.Find(filter);
var fileInfo = cursor.ToList().FirstOrDefault();
cursor.Dispose();
return(fileInfo);
}
public List <GridFSFileInfo> FindFilesByTags(KeyValuePair <string, List <string> > Filter, string Bucketname)
{
List <FilterDefinition <GridFSFileInfo> > FilterDef = new List <FilterDefinition <GridFSFileInfo> >();
foreach (string tag in Filter.Value)
{
FilterDef.Add(Builders <GridFSFileInfo> .Filter.AnyEq(Filter.Key, tag));
}
IEnumerable <FilterDefinition <GridFSFileInfo> > FilterFinal = new List <FilterDefinition <GridFSFileInfo> >(FilterDef);
var filter = Builders <GridFSFileInfo> .Filter.And(FilterFinal);
var sort = Builders <GridFSFileInfo> .Sort.Descending(x => x.UploadDateTime);
var options = new GridFSFindOptions
{
Limit = 20,
Sort = sort
};
Bucket = new GridFSBucket(mongoDatabase, new GridFSBucketOptions {
BucketName = Bucketname
});
using (var cursor = Bucket.Find(filter, options))
{
var fileInfo = cursor.ToList();
return(fileInfo);
}
}
public async Task <List <TFile> > GetFilesAllAsync(CancellationToken cancellationToken = default(CancellationToken))
{
var list = new List <TFile>();
var filter = Builders <GridFSFileInfo> .Filter.Empty;
var options = new GridFSFindOptions
{
BatchSize = 100,
Limit = 100
};
var files = await Bucket.FindAsync(filter, options, cancellationToken).ConfigureAwait(false);
while (await files.MoveNextAsync(cancellationToken).ConfigureAwait(false))
{
var cursor = files.Current.Select(gridFsFileInfo =>
{
var file = new TFile
{
FileName = gridFsFileInfo.Filename
};
file.SetId(gridFsFileInfo.Id);
SetMetadata(gridFsFileInfo, file);
return(file);
}).ToList();
list.AddRange(cursor);
}
return(list);
}
public async Task <List <GridFSFileInfo> > FindfileByPostId(string postId, bool flag = true)
{
var gridFsBucket = new GridFSBucket(this.database);
var filter = Builders <GridFSFileInfo> .Filter.And(
Builders <GridFSFileInfo> .Filter.Eq(x => x.Metadata["PostId"], postId)
);
if (flag)
{
filter = Builders <GridFSFileInfo> .Filter.And(
Builders <GridFSFileInfo> .Filter.Eq(x => x.Metadata["PostId"], postId),
Builders <GridFSFileInfo> .Filter.Eq(x => x.Metadata["Type"], 1));
}
var sort = Builders <GridFSFileInfo> .Sort.Descending(x => x.UploadDateTime);
var options = new GridFSFindOptions
{
Sort = sort
};
using (var cursor = await gridFsBucket.FindAsync(filter, options))
{
return(await cursor.ToListAsync());
}
}
public void AllowDiskUse_set_should_have_expected_result()
{
var subject = new GridFSFindOptions();
subject.AllowDiskUse = true;
subject.AllowDiskUse.Should().Be(true);
}
public void BatchSize_set_should_have_expected_result()
{
var subject = new GridFSFindOptions();
subject.BatchSize = 123;
subject.BatchSize.Should().Be(123);
}
public void NoCursorTimeout_set_should_have_expected_result()
{
var subject = new GridFSFindOptions();
subject.NoCursorTimeout = true;
subject.NoCursorTimeout.Should().Be(true);
}
public void Skip_set_should_throw_when_value_is_invalid()
{
var subject = new GridFSFindOptions();
Action action = () => subject.Skip = -1;
action.ShouldThrow <ArgumentException>().And.ParamName.Should().Be("value");
}
public void Skip_set_should_have_expected_result()
{
var subject = new GridFSFindOptions();
subject.Skip = 123;
subject.Skip.Should().Be(123);
}
public void BatchSize_set_should_have_expected_result()
{
var subject = new GridFSFindOptions();
subject.BatchSize = 123;
subject.BatchSize.Should().Be(123);
}
public void BatchSize_get_should_return_expected_result()
{
var subject = new GridFSFindOptions { BatchSize = 123 };
var result = subject.BatchSize;
result.Should().Be(123);
}
public void Limit_get_should_return_expected_result()
{
var subject = new GridFSFindOptions { Limit = 123 };
var result = subject.Limit;
result.Should().Be(123);
}
public void MaxTime_set_should_have_expected_result()
{
var subject = new GridFSFindOptions();
subject.MaxTime = TimeSpan.FromSeconds(123);
subject.MaxTime.Should().Be(TimeSpan.FromSeconds(123));
}
public void Sort_set_should_have_expected_result()
{
var subject = new GridFSFindOptions();
var sort = Builders <GridFSFileInfo> .Sort.Ascending(x => x.Length);
subject.Sort = sort;
subject.Sort.Should().BeSameAs(sort);
}
public void NoCursorTimeout_get_should_return_expected_result()
{
var subject = new GridFSFindOptions {
NoCursorTimeout = true
};
var result = subject.NoCursorTimeout;
result.Should().Be(true);
}
public void MaxTime_set_should_have_expected_result(
[Values(-10000, 0, 1, 9999, 10000, 10001)] long maxTimeTicks)
{
var subject = new GridFSFindOptions();
var value = TimeSpan.FromTicks(maxTimeTicks);
subject.MaxTime = value;
subject.MaxTime.Should().Be(value);
}
public void MaxTime_set_should_throw_when_value_is_invalid(
[Values(-10001, -9999, -1)] long maxTimeTicks)
{
var subject = new GridFSFindOptions();
var value = TimeSpan.FromTicks(maxTimeTicks);
Action action = () => subject.MaxTime = value;
action.ShouldThrow <ArgumentException>().And.ParamName.Should().Be("value");
}
public void Limit_get_should_return_expected_result()
{
var subject = new GridFSFindOptions {
Limit = 123
};
var result = subject.Limit;
result.Should().Be(123);
}
public void MaxTime_get_should_return_expected_result()
{
var subject = new GridFSFindOptions {
MaxTime = TimeSpan.FromSeconds(123)
};
var result = subject.MaxTime;
result.Should().Be(TimeSpan.FromSeconds(123));
}
public void BatchSize_set_should_throw_when_value_is_invalid(
[Values(-1, 0)]
int value)
{
var subject = new GridFSFindOptions();
Action action = () => subject.BatchSize = value;
action.ShouldThrow<ArgumentException>().And.ParamName.Should().Be("value");
}
public void BatchSize_set_should_throw_when_value_is_invalid(
[Values(-1, 0)]
int value)
{
var subject = new GridFSFindOptions();
Action action = () => subject.BatchSize = value;
action.ShouldThrow <ArgumentException>().And.ParamName.Should().Be("value");
}
public void Skip_get_should_return_expected_result()
{
var subject = new GridFSFindOptions {
Skip = 123
};
var result = subject.Skip;
result.Should().Be(123);
}
public void BatchSize_get_should_return_expected_result()
{
var subject = new GridFSFindOptions {
BatchSize = 123
};
var result = subject.BatchSize;
result.Should().Be(123);
}
public void AllowDiskUse_get_should_return_expected_result()
{
var subject = new GridFSFindOptions {
AllowDiskUse = true
};
var result = subject.AllowDiskUse;
result.Should().Be(true);
}
public void default_constructor_should_return_expected_result()
{
var result = new GridFSFindOptions();
result.BatchSize.Should().NotHaveValue();
result.Limit.Should().NotHaveValue();
result.MaxTime.Should().NotHaveValue();
result.NoCursorTimeout.Should().NotHaveValue();
result.Skip.Should().NotHaveValue();
result.Sort.Should().BeNull();
}
public void MaxTime_set_should_throw_when_value_is_invalid(
[Values(-1, 0)]
int seconds)
{
var subject = new GridFSFindOptions();
var value = TimeSpan.FromSeconds(seconds);
Action action = () => subject.MaxTime = value;
action.ShouldThrow <ArgumentException>().And.ParamName.Should().Be("value");
}
public void default_constructor_should_return_expected_result()
{
var result = new GridFSFindOptions();
result.BatchSize.Should().NotHaveValue();
result.Limit.Should().NotHaveValue();
result.MaxTime.Should().NotHaveValue();
result.NoCursorTimeout.Should().NotHaveValue();
result.Skip.Should().NotHaveValue();
result.Sort.Should().BeNull();
}
public void MaxTime_set_should_throw_when_value_is_invalid(
[Values(-1, 0)]
int seconds)
{
var subject = new GridFSFindOptions();
var value = TimeSpan.FromSeconds(seconds);
Action action = () => subject.MaxTime = value;
action.ShouldThrow<ArgumentException>().And.ParamName.Should().Be("value");
}
public void NoCursorTimeout_set_should_have_expected_result()
{
var subject = new GridFSFindOptions();
subject.NoCursorTimeout = true;
subject.NoCursorTimeout.Should().Be(true);
}
public void NoCursorTimeout_get_should_return_expected_result()
{
var subject = new GridFSFindOptions { NoCursorTimeout = true };
var result = subject.NoCursorTimeout;
result.Should().Be(true);
}
public void Skip_get_should_return_expected_result()
{
var subject = new GridFSFindOptions { Skip = 123 };
var result = subject.Skip;
result.Should().Be(123);
}
public void Skip_set_should_throw_when_value_is_invalid()
{
var subject = new GridFSFindOptions();
Action action = () => subject.Skip = -1;
action.ShouldThrow<ArgumentException>().And.ParamName.Should().Be("value");
}
public void Sort_get_should_return_expected_result()
{
var sort = Builders<GridFSFileInfo>.Sort.Ascending(x => x.Length);
var subject = new GridFSFindOptions { Sort = sort };
var result = subject.Sort;
result.Should().BeSameAs(sort);
}
public void Sort_set_should_have_expected_result()
{
var subject = new GridFSFindOptions();
var sort = Builders<GridFSFileInfo>.Sort.Ascending(x => x.Length);
subject.Sort = sort;
subject.Sort.Should().BeSameAs(sort);
}
public void MaxTime_set_should_have_expected_result()
{
var subject = new GridFSFindOptions();
subject.MaxTime = TimeSpan.FromSeconds(123);
subject.MaxTime.Should().Be(TimeSpan.FromSeconds(123));
}
public void Limit_set_should_have_expected_result()
{
var subject = new GridFSFindOptions();
subject.Limit = 123;
subject.Limit.Should().Be(123);
}
public void MaxTime_get_should_return_expected_result()
{
var subject = new GridFSFindOptions { MaxTime = TimeSpan.FromSeconds(123) };
var result = subject.MaxTime;
result.Should().Be(TimeSpan.FromSeconds(123));
}
