protected override Task <CrudResult <bool> > PersistUpdateEntityAsync(T entity)
{
return(mongoDatabase.GetCollection <T>(this.tableName).ReplaceOneAsync(iEntity => iEntity.Id == entity.Id, entity).ContinueWith(resultTask =>
{
if (!resultTask.IsFaulted)
{
return CrudResult <bool> .Success(true);
}
throw resultTask.Exception;
}));
}
protected override Task <CrudResult <string> > PersistAddEntityAsync(T entity)
{
TaskCompletionSource <CrudResult <String> > tcs = new TaskCompletionSource <CrudResult <String> >();
mongoDatabase.GetCollection <T>(this.tableName).InsertOneAsync(entity).ContinueWith(resultTask => {
if (resultTask.IsFaulted)
{
MongoCommandException mongoException = resultTask.Exception?.InnerException as MongoCommandException;
if (mongoException != null && mongoException.CodeName == "OperationNotSupportedInTransaction")
{
try
{
mongoDatabase.CreateCollection(tableName);
//List<CreateIndexModel<User>> indexModelList = new List<CreateIndexModel<User>>();
//var emailIndexOption = new CreateIndexOptions();
//emailIndexOption.Unique = true;
//var emailIndexKey = Builders<User>.IndexKeys.Ascending(user => user.Email);
//var emailIndexModel = new CreateIndexModel<User>(emailIndexKey, emailIndexOption);
//indexModelList.Add(emailIndexModel);
////adding examId of UserExams field as Index
//var examIdIndexKey = Builders<User>.IndexKeys.Ascending(new StringFieldDefinition<User>($"{nameof(User.UserExams)}.{nameof(UserExam.ExamId)}"));
//var examIdIndexModel = new CreateIndexModel<User>(examIdIndexKey);
//indexModelList.Add(examIdIndexModel);
////adding testId of UserTests field as Index
//var testIdIndexKey = Builders<User>.IndexKeys.Ascending(new StringFieldDefinition<User>($"{nameof(User.UserTests)}.{nameof(UserTest.TestId)}"));
//var testIdIndexModel = new CreateIndexModel<User>(testIdIndexKey);
//indexModelList.Add(testIdIndexModel);
////adding subscriptionId of Subscriptions field as Index
//var subscriptionIdIndexKey = Builders<User>.IndexKeys.Ascending(new StringFieldDefinition<User>($"{nameof(User.Subscriptions)}.{nameof(Subscription.Id)}"));
//var subscriptionIdIndexModel = new CreateIndexModel<User>(subscriptionIdIndexKey);
//indexModelList.Add(subscriptionIdIndexModel);
//adding all the indexes.
//mongoTransaction.Database.GetCollection<User>(this.tableName).Indexes.CreateMany(indexModelList);
//mongoTransaction.Database.GetCollection<User>(this.tableName).InsertOne(mongoTransaction.SessionHandle, entity);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
}
tcs.SetException(resultTask.Exception);
}
else
{
tcs.SetResult(CrudResult <String> .Success(entity.Id));
}
});
return(tcs.Task);
}
protected override Task <CrudResult <bool> > PersistDeleteEntityAsync(BlogPost entity)
{
return(mongoDatabase.GetCollection <BlogPost>(this.tableName).DeleteOneAsync(user => user.Id == entity.Id).ContinueWith(resultTask =>
{
if (!resultTask.IsFaulted)
{
return CrudResult <bool> .Success(true);
}
throw resultTask.Exception;
}));
}
private CrudResult <List <Book> > GetAllBooks()
{
var booksList = GetAllFromCache();
if (booksList == null)
{
return(CrudResult <List <Book> > .Error());
}
else
{
return(CrudResult <List <Book> > .Success(booksList));
}
}
public CrudResult <IDictionary <string, Car> > GetAllExistingCar()
{
var dictionaryCars = GetFromCache(DictionaryCarsKey);
if (dictionaryCars == null)
{
return(CrudResult <IDictionary <string, Car> > .NotFound());
}
else
{
return(CrudResult <IDictionary <string, Car> > .Success(dictionaryCars));
}
}
public CrudResult <Book> GetExistingBook(string id)
{
var exitingBook = GetFromCache(id);
if (exitingBook != null)
{
return(CrudResult <Book> .Success(exitingBook));
}
else
{
return(CrudResult <Book> .NotFound());
}
}
protected override Task <CrudResult <string> > PersistAddEntityAsync(Core.Models.Tag entity)
{
TaskCompletionSource <CrudResult <string> > tcs = new TaskCompletionSource <CrudResult <string> >();
mongoDatabase.GetCollection <Core.Models.Tag>(this.tableName).InsertOneAsync(entity).ContinueWith(resultTask => {
if (resultTask.IsFaulted)
{
MongoCommandException mongoException = resultTask.Exception?.InnerException as MongoCommandException;
if (mongoException != null && mongoException.CodeName == "OperationNotSupportedInTransaction")
{
try
{
mongoDatabase.CreateCollection(tableName);
List <CreateIndexModel <Core.Models.Tag> > indexModelList = new List <CreateIndexModel <Core.Models.Tag> >();
////adding userId as Index
var userIdIndexKey = Builders <Core.Models.Tag> .IndexKeys.Ascending(new StringFieldDefinition <Core.Models.Tag>($"{nameof(Core.Models.Tag.UserId)}"));
var userIdIndexModel = new CreateIndexModel <Core.Models.Tag>(userIdIndexKey);
indexModelList.Add(userIdIndexModel);
////adding name as Index
var nameIndexKey = Builders <Core.Models.Tag> .IndexKeys.Ascending(new StringFieldDefinition <Core.Models.Tag>($"{nameof(Core.Models.Tag.Name)}"));
var nameIndexModel = new CreateIndexModel <Core.Models.Tag>(nameIndexKey);
indexModelList.Add(nameIndexModel);
//adding all the indexes.
mongoDatabase.GetCollection <Core.Models.Tag>(this.tableName).Indexes.CreateMany(indexModelList);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
}
tcs.SetException(resultTask.Exception);
}
else
{
tcs.SetResult(CrudResult <String> .Success(entity.Id));
}
});
return(tcs.Task);
}
/// <summary>
/// Performs Delete operation that can be rollback
/// </summary>
/// <param name="entity"></param>
/// <returns><c>True</c> if operation success, <c>False</c> otherwise</returns>
protected async virtual Task <CrudResult <bool> > TransactionalDeleteAsync(IEntity entity)
{
if (Transaction.Current != null)
{
enlistForTransaction();
T original = await GetEntityAsync(entity.Id);
if (original == null)
{
return(CrudResult <bool> .Success(true));
}
transactionElements.Add(original, EnlistmentOperations.Delete);
return(await PersistDeleteEntityAsync(entity as T));
}
else
{
return(await PersistDeleteEntityAsync(entity as T));
}
}
public CrudResult InsertOrUpdateExistingCar(Car car)
{
var dictionaryCars = GetAllExistingCar();
if (dictionaryCars.IsSuccess)
{
dictionaryCars.Value.Add(car.Reference, car);
UpdateCacheData(dictionaryCars.Value);
return(CrudResult.Success());
}
else
{
// Here in other case select to database
var newDictionary = new Dictionary <string, Car>
{
{ car.Reference, car },
};
return(UpdateCacheData(newDictionary));
}
}
public CrudResult <Car> GetExistingCar(string reference)
{
var dictionaryCars = GetAllExistingCar();
if (dictionaryCars.IsSuccess)
{
var car = dictionaryCars.Value
.Where(x => x.Key == reference)
.SingleOrDefault();
if (car.Value == null)
{
return(CrudResult <Car> .NotFound());
}
else
{
return(CrudResult <Car> .Success(car.Value));
}
}
else
{
return(CrudResult <Car> .NotFound());
}
}
private CrudResult RemoveBook(Book book) => RemoveFromCache(book.Id, book) ? CrudResult.Success() : CrudResult.Error();
private CrudResult AddBook(Book book) => SetInCache(book.Id, book) ? CrudResult.Success() : CrudResult.Error();
private CrudResult UpdateCacheData(IDictionary <string, Car> carsDictionary) => SetOrUpdateInCache(DictionaryCarsKey, carsDictionary) ? CrudResult.Success() : CrudResult.Error();
