public async Task <bool> TryDeleteDirectoryAsync(string path)
{
path = path.TrimEnd('/');
var filter = Builders <MongoDBFileStoreEntry> .Filter.Where(e => e.Path.StartsWith(path));
var fileEntityList = await _mongoRepository.GetAsync(filter);
try
{
foreach (var fileEntity in fileEntityList)
{
if (!fileEntity.IsDirectory)
{
await _mongoRepository.DeleteFileAsync(fileEntity.FileStoreId);
}
}
await _mongoRepository.DeleteAsync(filter);
return(true);
}
catch (Exception e)
{
_logger.LogError(e.StackTrace);
return(false);
}
}
public void Deve_Registrar_Logs_No_Repositorio_MongoDB()
{
//Given
var dataBaseName = "mongo-auto-create";
var entity = new AggregateRoot();
var mongoSettings = new MongoSettings
{
DatabaseName = dataBaseName,
ConnectionString = "mongodb://127.0.0.1:27017"
};
var setMock = new Mock <IMongoCollection <AggregateRoot> >();
var mongoContextMock = new Mock <MongoContext>(mongoSettings);
var logger = new XunitLogger <MongoRepository <AggregateRoot, Guid> >();
var loggerFactoryMock = new Mock <ILoggerFactory>();
loggerFactoryMock.Setup(setup => setup.CreateLogger(It.IsAny <string>())).Returns(logger);
var repositoryMock = new MongoRepository <AggregateRoot, Guid>(mongoContextMock.Object, loggerFactoryMock.Object);
//When
repositoryMock.GetByIdAsync(entity.Id).ConfigureAwait(false);
repositoryMock.GetAllAsync();
repositoryMock.InsertAsync(entity);
repositoryMock.UpdateAsync(entity);
repositoryMock.DeleteAsync(entity);
repositoryMock.DeleteAsync(entity.Id).ConfigureAwait(false);
repositoryMock.SaveChangesAsync();
//Then
var msgContructor = "Inicializando MongoRepository<AggregateRoot, Guid>";
var msgGetById = $"Método: GetByIdAsync( {{id:{ entity.Id }}} ) Retorno: type AggregateRoot";
var msgGetAllAsync = "Método: GetAllAsync() Retorno: IAsyncEnumerable<AggregateRoot>";
var msgInsertAsync = $"Método: InsertAsync( {{entity:{ entity.ToJson()}}} )";
var msgUpdateAsync = $"Método: UpdateAsync( {{entity:{ entity.ToJson()}}} )";
var msgDeleteAsync = $"Método: DeleteAsync( {{entity:{ entity.ToJson()}}} )";
var msgDeleteNotFoundAsync = $"Método: DeleteAsync( {{id:{ entity.Id }}} ) Registro não encontrado";
var msgSaveChanges = "Método: SaveChangesAsync()";
logger.Logs.Should().HaveCount(9);
logger.Logs.Any(a => a.Equals(msgGetById)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgContructor)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgGetAllAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgInsertAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgUpdateAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgDeleteAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgDeleteNotFoundAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgSaveChanges)).Should().BeTrue();
mongoContextMock.Object.MongoClient.DropDatabase(dataBaseName);
mongoContextMock.Object.Dispose();
}
public async void CanDeleteDocumentByExpressionAsync()
{
var customerRepository = new MongoRepository <Customer>();
await customerRepository.AddAsync(this.TestCustomers);
await customerRepository.DeleteAsync(x => x.Id == this.TestCustomers[0].Id);
var document = await customerRepository.GetByIdAsync(this.TestCustomers[0].Id);
document.ShouldBeNull();
await customerRepository.DeleteAsync(this.TestCustomers);
}
public async void CanDeleteDocumentByIdAsync()
{
var customerRepository = new MongoRepository <Customer>();
customerRepository.Add(this.TestCustomers);
customerRepository.Count().ShouldBe(this.TestCustomers.Count);
await customerRepository.DeleteAsync(this.TestCustomers[0].Id);
var document = await customerRepository.GetByIdAsync(this.TestCustomers[0].Id);
document.ShouldBeNull();
await customerRepository.DeleteAsync(this.TestCustomers);
}
public async Task <IActionResult> Delete(string id)
{
if (String.IsNullOrEmpty(id))
{
return(BadRequest("Customer ID is required to delete customer record"));
}
try
{
var cust = await _custrepo.GetByEntityIdAsync(id);
if (cust == null)
{
return(NotFound());
}
await _custrepo.DeleteAsync(id);
return(Ok());
}
catch (Exception ex) {
_logger.LogError(LoggingEvents.Error, ex, $"ERROR: Unable to delete customer: {id}");
}
return(BadRequest($"ERROR: Unable to delete customer: {id}"));
}
public async Task DeleteAsync_Success()
{
var entity = new MongoTestEntity()
{
Bool = false,
Number = 1,
String = "String"
};
entity = Repository.Create(entity);
await Repository.DeleteAsync(entity);
entity = Repository.Read(entity.Id);
Assert.IsNull(entity);
}
public async void CanAddDocumentAsync()
{
var customerRepository = new MongoRepository <Customer>();
await customerRepository.AddAsync(this.TestCustomers[0]);
this.TestCustomers[0].Id.ShouldNotBeNullOrWhiteSpace();
await customerRepository.DeleteAsync(this.TestCustomers[0]);
}
public async Task DeleteAsync(TrackingUrlEntity entity)
{
try
{
await _collection.DeleteAsync(entity.Id);
}
catch (Exception e)
{
throw new ApplicationException(string.Format("Mongo driver failure: {0}", e));
}
}
public async void CanCountDocumentsAsync()
{
var customerRepository = new MongoRepository <Customer>();
await customerRepository.AddAsync(this.TestCustomers);
var count = await customerRepository.CountAsync();
count.ShouldBe(this.TestCustomers.Count);
await customerRepository.DeleteAsync(this.TestCustomers);
}
public async void CanCheckIfDocumentExistsAsync()
{
var customerRepository = new MongoRepository <Customer>();
await customerRepository.AddAsync(this.TestCustomers);
var exists = await customerRepository.ExistsAsync(x => x.Id == this.TestCustomers[0].Id);
exists.ShouldBeTrue();
await customerRepository.DeleteAsync(this.TestCustomers);
}
public async Task Delete_Object_Success()
{
MongoRepository repo = new MongoRepository(_mongoFixture.MongoClient, _mongoFixture.Logger, new Dictionary <string, HashSet <string> >());
string json = "{ \"Name\" : \"Maria\" }";
var insertResult = await repo.InsertAsync("bookstore", "users", "3", json);
var getResult = await repo.GetAsync("bookstore", "users", "3");
var deleteResult = await repo.DeleteAsync("bookstore", "users", "3");
var getResultAfterDelete = await repo.GetAsync("bookstore", "users", "3");
Assert.Null(getResultAfterDelete);
Assert.True(deleteResult);
}
public async void CanUpdateDocumentAsync()
{
var customerRepository = new MongoRepository <Customer>();
await customerRepository.AddAsync(this.TestCustomers);
this.TestCustomers[0].LastName = "Updated LastName";
await customerRepository.UpdateAsync(this.TestCustomers[0]);
var document = await customerRepository.GetByIdAsync(this.TestCustomers[0].Id);
document.ShouldNotBeNull();
document.Id.ShouldBe(this.TestCustomers[0].Id);
document.LastName.ShouldBe("Updated LastName");
await customerRepository.DeleteAsync(this.TestCustomers);
}
public async Task DeleteAsyncByPredicateShouldSucceed()
{
var itemsDoc = new List <MockDocument> {
_mockDocument98, _mockDocument99
};
foreach (var item in itemsDoc)
{
item.IsActive = false;
}
await _mockDocumentRepo.CreateAsync(itemsDoc);
var searchDocResults = await _mockDocumentRepo.FindAsync();
var count = searchDocResults.Count;
var searchObjResults = await _mockObjectRepo.FindAsync();
count += searchObjResults.Count;
var deleteCount = await _mockDocumentRepo.DeleteAsync(x => !x.IsActive);
searchDocResults = await _mockDocumentRepo.FindAsync();
deleteCount += await _mockObjectRepo.DeleteAsync(x => true);
searchObjResults = await _mockObjectRepo.FindAsync();
Assert.Equal(3, count);
Assert.Equal(3, deleteCount);
Assert.NotNull(searchDocResults);
Assert.NotNull(searchObjResults);
Assert.Collection(searchDocResults);
Assert.Collection(searchObjResults);
Assert.Empty(searchDocResults);
Assert.Empty(searchObjResults);
}
public async Task CustomerMasterRepositoryTest001_CreateFindDeleteAsync_ExpectNoExceptions()
{
// Test cases for async API
await repo.DeleteAllAsync();
Assert.Equal(0, repo.Count());
// Add an entity
Customer entity = new Customer("CustomerMasterRepositoryTest001_cname", "1-800-start");
await repo.AddAsync(entity);
this.testLogger.LogDebug($"New entity: {entity.ToJson()}");
// Count should increase by 1
Assert.Equal(1, await repo.CountAsync());
// Test get by id
var fetch = await repo.GetByEntityIdAsync(entity.entityid);
Assert.NotNull(fetch);
// Assert.Equal(fetch,entity);
// Test search API
var searchresult = await repo.GetAsync(e => e.phone == "1-800-start");
Assert.Equal(1, searchresult.Count);
// Test Update API
entity.phone = "1-800-updated";
await repo.UpdateAsync(entity);
Assert.Equal(1, (await repo.GetAsync(e => e.phone == "1-800-updated")).Count);
await repo.DeleteAsync(entity.entityid);
await Assert.ThrowsAsync <Exception>(async() => fetch = await repo.GetByEntityIdAsync(entity.entityid));
}
public async void CanUpdateMultipleDocumentsAsync()
{
var customerRepository = new MongoRepository <Customer>();
await customerRepository.AddAsync(this.TestCustomers);
this.TestCustomers[0].LastName = "Updated LastName 1";
this.TestCustomers[1].LastName = "Updated LastName 2";
await customerRepository.UpdateAsync(this.TestCustomers);
var document1 = await customerRepository.GetByIdAsync(this.TestCustomers[0].Id);
document1.ShouldNotBeNull();
document1.Id.ShouldBe(this.TestCustomers[0].Id);
document1.LastName.ShouldBe("Updated LastName 1");
var document2 = await customerRepository.GetByIdAsync(this.TestCustomers[1].Id);
document2.ShouldNotBeNull();
document2.Id.ShouldBe(this.TestCustomers[1].Id);
document2.LastName.ShouldBe("Updated LastName 2");
await customerRepository.DeleteAsync(this.TestCustomers);
}
public async Task <Task> ExecuteAsync(Translation translation)
{
SetPredicate(translation);
Log.Debug($"Deleting translation async: {translation.ToString()}");
return(_mongoRepository.DeleteAsync(_predicate));
}
public async Task CreateAsyncByItemsShouldSucceed()
{
var deleteCount = await _mockDocumentRepo.DeleteAsync(x => true);
var items = new List <MockDocument> {
_mockDocument98, _mockDocument99
};
await _mockDocumentRepo.CreateAsync(items);
var results = await _mockDocumentRepo.FindAsync();
Assert.Equal(1, deleteCount);
Assert.NotEmpty(results);
Assert.Equal(2, results.Count);
}
public void StartServer(CancellationToken cancellationToken)
{
this._logger.LogDebug(LoggingEvents.Debug, "Started Data Replication Server");
Console.WriteLine(" *** Started App Data Replication Server ***");
// This is the event handler for emailNotification queue. Make sure this does not throw exception
// Kafka message handling block would not be responsible to handle any exceptions
Func <KMessage <AppEventArgs <Customer> >, Task> appEventHandler = async(message) =>
{
this._logger.LogTrace(LoggingEvents.Trace, $"Response: Partition:{message.Partition}, Offset:{message.Offset} :: {message.Message}");
AppEventArgs <Customer> evt = message.Message;
try {
Customer customer = evt.afterChange;
switch (evt.appEventType)
{
case AppEventType.Insert:
_logger.LogTrace(LoggingEvents.Trace, String.Format("Adding new Customer:{0}", customer.name));
await _custrepo.AddAsync(customer);
await this._searchrepo.AddAsync(customer);
break;
case AppEventType.Delete:
var cust = await _custrepo.GetByEntityIdAsync(customer.entityid);
if (cust == null)
{
_logger.LogTrace(LoggingEvents.Trace, $"Trying to delete Customer {customer.name} with EmtityID: {customer.entityid} that does not exist");
}
else
{
await _custrepo.DeleteAsync(customer.entityid);
}
if (this._searchrepo.Exists(customer.id))
{
await this._searchrepo.DeleteAsync(customer.id);
}
break;
case AppEventType.Update:
_logger.LogTrace(LoggingEvents.Trace, $"Processing request to update customer:{customer.entityid}");
await _custrepo.UpdateAsync(customer);
await _searchrepo.UpdateAsync(customer);
break;
default:
_logger.LogTrace(LoggingEvents.Trace, $"No action required for event:{evt.id} of type:{evt.appEventType}");
break;
}
this._logger.LogDebug(LoggingEvents.Trace, $"Processed Customer CRUD event {evt.id}");
}
catch (Exception ex) {
var msg = $"Event:{evt.id} - Error:{ex.Message}";
this._logger.LogError(LoggingEvents.Error, ex, msg);
// We will send out a notification for every update
var notifyEvt = new EmailEventArgs {
subject = "Data Replication Error",
textMsg = $"Error replicating customer information. {msg}",
htmlMsg = $"<p> Error replicating customer information. </p><p> <b>Message Details: </b> {msg} <p>",
notifyTo = new List <string>()
{
"*****@*****.**"
},
notifyCC = new List <string>(),
notifyBCC = new List <string>()
};
await this._notificationProducer.ProduceAsync(this._notificationMsgQueueTopic, notifyEvt);
}
};
this._appEventMsgConsumer.Consume(cancellationToken, appEventHandler, null, null);
this._appEventMsgConsumer.Dispose();
Console.WriteLine(" *** Stopped App Data Replication Server ***");
this._logger.LogDebug(LoggingEvents.Debug, "Stopped App Data Replication Server");
}