public void Test_3_Batch_Delete_PublisherEntity()
{
TransactionContext transactionContext = database.BeginTransaction <PublisherEntity>(isolationLevel);
try
{
IList <PublisherEntity> lst = database.Page <PublisherEntity>(2, 100, transactionContext);
if (lst.Count != 0)
{
DatabaseResult result = database.BatchDelete <PublisherEntity>(lst, "deleter", transactionContext);
if (!result.IsSucceeded())
{
output.WriteLine(result.Exception?.Message);
throw new Exception();
}
Assert.True(result.IsSucceeded());
}
database.Commit(transactionContext);
}
catch (Exception ex)
{
output.WriteLine(ex.Message);
database.Rollback(transactionContext);
throw ex;
}
}
public async Task Test_4_Add_PublisherEntityAsync()
{
var tContext = await database.BeginTransactionAsync <PublisherEntity>(isolationLevel);
try
{
for (int i = 0; i < 10; ++i)
{
PublisherEntity entity = Mocker.MockOne();
DatabaseResult result = await database.AddAsync(entity, tContext);
if (!result.IsSucceeded())
{
output.WriteLine(result.Exception?.Message);
throw new Exception();
}
Assert.True(result.IsSucceeded());
}
await database.CommitAsync(tContext);
}
catch (Exception ex)
{
output.WriteLine(ex.Message);
await database.RollbackAsync(tContext);
throw ex;
}
}
public void AddRole()
{
TransactionContext transContext = database.BeginTransaction <Role>();
DatabaseResult result = DatabaseResult.Succeeded();
foreach (Role item in _roleList)
{
long count = _db.Count <Role>(r => r.Name == item.Name, transContext);
if (count != 0)
{
continue;
}
result = _db.AddAsync(item, transContext).Result;
if (!result.IsSucceeded())
{
database.Rollback(transContext);
break;
}
}
database.Commit(transContext);
Assert.True(result.IsSucceeded());
}
public void Test_4_Add_PublisherEntity()
{
TransactionContext tContext = database.BeginTransaction <PublisherEntity>(isolationLevel);
try
{
for (int i = 0; i < 10; ++i)
{
PublisherEntity entity = Mocker.MockOne();
DatabaseResult result = database.Add(entity, tContext);
if (!result.IsSucceeded())
{
output.WriteLine(result.Exception?.Message);
throw new Exception();
}
Assert.True(result.IsSucceeded());
}
database.Commit(tContext);
}
catch (Exception ex)
{
output.WriteLine(ex.Message);
database.Rollback(tContext);
throw ex;
}
}
public void Test_6_Delete_PublisherEntity()
{
var tContext = database.BeginTransaction <PublisherEntity>(isolationLevel);
try
{
IList <PublisherEntity> testEntities = database.RetrieveAll <PublisherEntity>(tContext);
testEntities.ForEach(entity => {
DatabaseResult result = database.Delete(entity, tContext);
if (!result.IsSucceeded())
{
output.WriteLine(result.Exception?.Message);
throw new Exception();
}
Assert.True(result.IsSucceeded());
});
long count = database.Count <PublisherEntity>(tContext);
database.Commit(tContext);
output.WriteLine($"count: {count}");
Assert.True(count == 0);
}
catch (Exception ex)
{
output.WriteLine(ex.Message);
throw ex;
}
}
public async Task Test_1_Batch_Add_PublisherEntityAsync()
{
IList <PublisherEntity> publishers = Mocker.GetPublishers();
var transactionContext = await database.BeginTransactionAsync <PublisherEntity>(isolationLevel).ConfigureAwait(false);
DatabaseResult result = DatabaseResult.Failed();
try
{
result = await database.BatchAddAsync <PublisherEntity>(publishers, "tester", transactionContext);
if (!result.IsSucceeded())
{
output.WriteLine(result.Exception?.Message);
throw new Exception();
}
await database.CommitAsync(transactionContext);
}
catch (Exception ex)
{
output.WriteLine(ex.Message);
await database.RollbackAsync(transactionContext);
throw ex;
}
Assert.True(result.IsSucceeded());
}
public void Test_1_Batch_Add_PublisherEntity()
{
IList <PublisherEntity> publishers = Mocker.GetPublishers();
var transactionContext = database.BeginTransaction <PublisherEntity>(isolationLevel);
DatabaseResult result = DatabaseResult.Failed();
try
{
result = database.BatchAdd <PublisherEntity>(publishers, "tester", transactionContext);
if (!result.IsSucceeded())
{
output.WriteLine(result.Exception?.Message);
throw new Exception();
}
database.Commit(transactionContext);
}
catch (Exception ex)
{
output.WriteLine(ex.Message);
database.Rollback(transactionContext);
throw ex;
}
Assert.True(result.IsSucceeded());
}
public void RandomDeleteSomeUserAsync()
{
TransactionContext transContext = database.BeginTransaction <User>();
List <long> ids = new List <long>();
DatabaseResult result = null;
try
{
long userCount = _db.Count <User>(transContext);
for (int i = 0; i < userCount; i += 10)
{
int userId = i;
User user = _db.ScalarAsync <User>(i, transContext).Result;
if (user == null)
{
continue;
}
ids.Add(userId);
result = _db.DeleteAsync <User>(user, transContext).Result;
Assert.True(result.IsSucceeded());
if (!result.IsSucceeded())
{
database.Rollback(transContext);
break;
}
}
database.Commit(transContext);
Assert.True(transContext.Status == TransactionStatus.Commited);
if (transContext.Status == TransactionStatus.Commited)
{
IList <User> updatedUsers = _db.Retrieve <User>(u => SQLUtil.In(u.Id, false, ids), null);
if (updatedUsers.Count == 0)
{
result = DatabaseResult.Succeeded();
}
result = DatabaseResult.Failed();
}
result = DatabaseResult.Failed();
}
catch (Exception)
{
database.Rollback(transContext);
}
}
public async Task Test_2_Batch_Update_PublisherEntityAsync()
{
TransactionContext transContext = await database.BeginTransactionAsync <PublisherEntity>(isolationLevel);
try
{
IList <PublisherEntity> lst = await database.RetrieveAllAsync <PublisherEntity>(transContext);
for (int i = 0; i < lst.Count; i += 2)
{
PublisherEntity entity = lst[i];
//entity.Guid = Guid.NewGuid().ToString();
entity.Type = PublisherType.Online;
entity.Name = "ÖÐsfasfafÎÄÃû×Ö";
entity.Books = new List <string>()
{
"xxx", "tttt"
};
entity.BookAuthors = new Dictionary <string, Author>()
{
{ "Cat", new Author()
{
Mobile = "111", Name = "BB"
} },
{ "Dog", new Author()
{
Mobile = "222", Name = "sx"
} }
};
}
DatabaseResult result = await database.BatchUpdateAsync <PublisherEntity>(lst, "tester", transContext);
Assert.True(result.IsSucceeded());
if (!result.IsSucceeded())
{
output.WriteLine(result.Exception?.Message);
await database.RollbackAsync(transContext);
throw new Exception();
}
await database.CommitAsync(transContext);
}
catch (Exception ex)
{
output.WriteLine(ex.Message);
await database.RollbackAsync(transContext);
throw ex;
}
}
async void BtnSave_Clicked(object sender, EventArgs e)
{
IList <PublisherEntity> publisherEntities = Mocker.GetPublishers();
TransactionContext transactionContext = await App.Database.BeginTransactionAsync <PublisherEntity>();
try
{
DatabaseResult databaseResult = await App.Database.BatchAddAsync <PublisherEntity>(publisherEntities, "", transactionContext);
if (!databaseResult.IsSucceeded())
{
throw new Exception(databaseResult.Exception?.Message, databaseResult.Exception);
}
await App.Database.CommitAsync(transactionContext);
await DisplayList();
}
catch (Exception ex)
{
await App.Database.RollbackAsync(transactionContext);
await DisplayAlert("Error", ex.Message, "Close");
}
}
public async Task <IActionResult> OnPostAsync()
{
TransactionContext tContext = await database.BeginTransactionAsync <PublisherEntity>();
try
{
IList <PublisherEntity> lst = Mocker.GetPublishers();
DatabaseResult databaseResult = await database.BatchAddAsync(lst, "", tContext);
//new id can be found in databaseResult.Ids
if (!databaseResult.IsSucceeded())
{
await database.RollbackAsync(tContext);
throw new Exception("did not work.");
}
await database.CommitAsync(tContext);
}
catch (Exception ex)
{
await database.RollbackAsync(tContext);
throw ex;
}
return(RedirectToPage("/Index"));
}
static async Task Main(string[] args)
{
AssemblyLoadContext
IDatabase database = GetDatabase();
IList <BookEntity> books = MokeData.GetBooks();
TransactionContext tContext = await database.BeginTransactionAsync <BookEntity>();
DatabaseResult databaseResult = await database.BatchAddAsync(books, "", tContext);
if (!databaseResult.IsSucceeded())
{
await database.RollbackAsync(tContext);
}
await database.CommitAsync(tContext);
IEnumerable <BookEntity> retrieveResult = await database.RetrieveAllAsync <BookEntity>(null);
foreach (BookEntity bookEntity in retrieveResult)
{
Console.WriteLine($"{bookEntity.Name}");
}
}
public async Task Test_5_Update_PublisherEntityAsync()
{
var tContext = await database.BeginTransactionAsync <PublisherEntity>(isolationLevel);
try
{
IList <PublisherEntity> testEntities = await database.PageAsync <PublisherEntity>(1, 1, tContext);
if (testEntities.Count == 0)
{
return;
}
PublisherEntity entity = testEntities[0];
entity.Books.Add("New Book2");
entity.BookAuthors.Add("New Book2", new Author()
{
Mobile = "15190208956", Name = "Yuzhaobai"
});
DatabaseResult result = await database.UpdateAsync(entity, tContext);
if (!result.IsSucceeded())
{
output.WriteLine(result.Exception?.Message);
throw new Exception();
}
Assert.True(result.IsSucceeded());
PublisherEntity stored = await database.ScalarAsync <PublisherEntity>(entity.Id, tContext);
Assert.True(stored.Books.Contains("New Book2"));
Assert.True(stored.BookAuthors["New Book2"].Mobile == "15190208956");
await database.CommitAsync(tContext);
}
catch (Exception ex)
{
output.WriteLine(ex.Message);
await database.RollbackAsync(tContext);
throw ex;
}
}
public void AddUsers()
{
TransactionContext transContext = database.BeginTransaction <User>();
DatabaseResult result = DatabaseResult.Failed();
foreach (User item in _userList)
{
result = _db.AddAsync(item, transContext).Result;
if (!result.IsSucceeded())
{
database.Rollback(transContext);
break;
}
}
database.Commit(transContext);
Assert.True(result.IsSucceeded());
}
public async Task Test_6_Delete_PublisherEntityAsync()
{
var tContext = await database.BeginTransactionAsync <PublisherEntity>(isolationLevel);
try
{
IList <PublisherEntity> testEntities = await database.RetrieveAllAsync <PublisherEntity>(tContext);
await testEntities.ForEachAsync(async entity => {
DatabaseResult result = await database.DeleteAsync(entity, tContext);
if (!result.IsSucceeded())
{
output.WriteLine(result.Exception?.Message);
throw new Exception();
}
Assert.True(result.IsSucceeded());
});
long count = await database.CountAsync <PublisherEntity>(tContext);
Assert.True(count == 0);
await database.CommitAsync(tContext);
output.WriteLine($"count: {count}");
}
catch (Exception ex)
{
await database.RollbackAsync(tContext);
output.WriteLine(ex.Message);
throw ex;
}
}
public void AddSomeUserClaims()
{
int userCount = _userList.Count;
DatabaseResult result = DatabaseResult.Failed();
for (int i = 1; i < userCount; i += 39)
{
UserClaim uc = new UserClaim()
{
UserGuid = i.ToString(), ClaimValue = "Nothing", ClaimType = "HB.Nothing"
};
result = _db.AddAsync(uc, null).Result;
}
Assert.True(result.IsSucceeded());
}
public void AddSomeUserRole()
{
int userCount = _userList.Count;
DatabaseResult result = DatabaseResult.Failed();
int roleId = 1;
for (int i = 1; i < userCount; i += 7)
{
UserRole ur = new UserRole()
{
RoleGuid = roleId++.ToString(), UserGuid = i.ToString()
};
if (roleId == 5)
{
roleId = 1;
}
result = _db.AddAsync(ur, null).Result;
}
Assert.True(result.IsSucceeded());
}
public void RandomUpdateSomeUserAsync()
{
TransactionContext transContext = database.BeginTransaction <User>();
string userNamePrefix = DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss");
List <long> ids = new List <long>();
DatabaseResult result = null;
try
{
long userCount = _db.Count <User>(transContext);
for (int i = 0; i < userCount; i += 10)
{
int userId = i;
User user = _db.ScalarAsync <User>(i, transContext).Result;
if (user == null)
{
continue;
}
ids.Add(userId);
user.UserName = userNamePrefix + "_update_" + i;
result = _db.UpdateAsync <User>(user, transContext).Result;
Assert.True(result.IsSucceeded());
if (!result.IsSucceeded())
{
_output.WriteLine($"user id {userId} update failed.");
database.Rollback(transContext);
break;
}
}
database.Commit(transContext);
Assert.Equal(TransactionStatus.Commited, transContext.Status);
if (transContext.Status == TransactionStatus.Commited)
{
IList <User> updatedUsers = _db.Retrieve <User>(u => SQLUtil.In(u.Id, false, ids), null);
foreach (User u in updatedUsers)
{
_output.WriteLine(u.UserName);
}
}
}
catch (Exception)
{
database.Rollback(transContext);
result = DatabaseResult.Failed();
}
Assert.True(result.IsSucceeded());
}
