/// <summary>
/// 保存配置实例。
/// </summary>
/// <param name="site">当前配置实例。</param>
/// <returns>返回数据结果。</returns>
public virtual async Task <DataResult> SaveAsync(SiteBase site)
{
var adapter = site.ToStore();
if (adapter.SiteId > 0)
{
return(DataResult.FromResult(await _sdb.UpdateAsync(adapter), DataAction.Updated));
}
if (await IsDuplicatedAsync(site))
{
return(DataResult.FromResult(await _sdb.UpdateAsync(x => x.SiteKey == adapter.SiteKey, new { adapter.SiteName, adapter.UpdatedDate, adapter.SettingValue }), DataAction.Updated));
}
return(DataResult.FromResult(await _sdb.BeginTransactionAsync(async db =>
{
if (!await db.CreateAsync(adapter))
{
return false;
}
site.SiteId = adapter.SiteId;
foreach (var handler in _handlers)
{
if (!await handler.OnCreateAsync(db, site))
{
return false;
}
}
return true;
}), DataAction.Created));
}
/// <summary>
/// 设置默认。
/// </summary>
/// <param name="siteId">网站Id。</param>
/// <param name="domain">域名。</param>
/// <returns>返回设置结果。</returns>
public virtual async Task <bool> SetDefaultAsync(int siteId, string domain)
{
if (await _sddb.BeginTransactionAsync(async db =>
{
await db.UpdateAsync(x => x.SiteId == siteId, new { IsDefault = false });
await db.UpdateAsync(x => x.SiteId == siteId && x.Domain == domain, new { IsDefault = true });
return(true);
}))
{
_cache.Remove(_cacheKey);
return(true);
}
return(false);
}
/// <summary>
/// 更新管理员权限配置。
/// </summary>
/// <returns>返回更新结果。</returns>
public async Task <bool> RefreshOwnersAsync()
{
var roleId = await GetOwnerIdAsync();
if (roleId == 0)
{
return(false);
}
var permissions = await EnsuredProviderPermissionsAsync();
if (await _prdb.BeginTransactionAsync(async db =>
{
foreach (var permission in permissions)
{
if (await db.AnyAsync(x => x.PermissionId == permission.Id && x.RoleId == roleId))
{
continue;
}
await db.CreateAsync(new PermissionInRole {
PermissionId = permission.Id, RoleId = roleId, Value = PermissionValue.Allow
});
}
return(true);
}))
{
RemoveCache();
return(true);
}
return(false);
}
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken,
RequestHandlerDelegate <TResponse> next)
{
TResponse response = default;
try
{
await _dbContext.RetryOnExceptionAsync(async() =>
{
_logger.LogInformation($"Begin transaction {typeof(TRequest).Name}");
await _dbContext.BeginTransactionAsync();
response = await next();
await _dbContext.CommitTransactionAsync();
_logger.LogInformation($"Committed transaction {typeof(TRequest).Name}");
});
return(response);
}
catch (Exception e)
{
_logger.LogInformation($"Rollback transaction executed {typeof(TRequest).Name}");
_dbContext.RollbackTransaction();
_logger.LogError(e.Message, e.StackTrace);
throw e;
}
}
/// <summary>
/// 添加默认网站。
/// </summary>
/// <param name="siteKey">唯一键。</param>
/// <param name="siteName">网站名称。</param>
/// <param name="shortName">网站简称。</param>
/// <param name="description">描述。</param>
/// <param name="domains">域名列表。</param>
/// <returns>返回添加结果。</returns>
public virtual async Task <bool> CreateDefaultSiteAsync(string siteKey, string siteName, string shortName, string description, IEnumerable <string> domains)
{
if (await _context.BeginTransactionAsync(async db =>
{
var site = new SiteAdapter
{
SiteKey = siteKey,
SiteName = siteName,
ShortName = shortName ?? siteName,
Description = description
};
if (await db.As <SiteAdapter>().CreateAsync(site))
{
foreach (var domain in domains)
{
var siteDomain = new SiteDomain
{
Domain = domain,
SiteId = site.Id
};
await db.CreateAsync(siteDomain);
}
return(true);
}
return(false);
}))
{
Refresh();
return(true);
}
return(false);
}
/// <summary>
/// 添加对象对比实例。
/// </summary>
/// <param name="differ">对象对比实例。</param>
/// <returns>返回添加结果。</returns>
public virtual Task <bool> CreateAsync(IObjectDiffer differ)
{
return(_db.BeginTransactionAsync(async db =>
{
foreach (var item in differ)
{
await db.CreateAsync(item);
}
return true;
}, 300));
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
using (var transaction = await _dbContext.BeginTransactionAsync())
{
await next();
await _dbContext.SaveChangesAsync();
transaction.Commit();
}
}
/// <summary>
/// 将API设置到应用中。
/// </summary>
/// <param name="appid">应用程序Id。</param>
/// <param name="apis">API的Id列表。</param>
/// <returns>返回保存结果。</returns>
public virtual async Task <DataResult> AddApisAsync(int appid, int[] apis)
{
return(Result(await _context.BeginTransactionAsync(async db =>
{
var asdb = db.As <ApplicationService>();
await asdb.DeleteAsync(x => x.AppicationId == appid);
if (apis?.Length > 0)
{
foreach (var api in apis)
{
await asdb.CreateAsync(new ApplicationService {
AppicationId = appid, ServiceId = api
});
}
}
return true;
}), DataAction.Updated));
}
/// <summary>
/// 将服务添加到应用程序中。
/// </summary>
/// <param name="appid">应用程序Id。</param>
/// <param name="ids">服务Id列表。</param>
/// <returns>返回添加结果。</returns>
public async Task <bool> AddApplicationServicesAsync(Guid appid, int[] ids)
{
if (await _asdb.BeginTransactionAsync(async db =>
{
await db.DeleteAsync(x => x.AppId == appid);
foreach (var id in ids)
{
await db.CreateAsync(new ApplicationService {
AppId = appid, ServiceId = id
});
}
return(true);
}))
{
_cache.Remove(GetCacheKey(appid));
return(true);
}
return(false);
}
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next)
{
var response = default(TResponse);
var typeName = request.GetGenericTypeName();
try
{
if (dbContext.HasActiveTransaction)
{
return(await next());
}
await dbContext.Execute(async() =>
{
using var transaction = await dbContext.BeginTransactionAsync();
var transactionId = dbContext.CurrentTransactionId;
using (LogContext.PushProperty("TransactionContext", transactionId))
{
logger.LogInformation("----- Begin transaction {TransactionId} for {CommandName} ({@Command})", transactionId, typeName, request);
response = await next();
logger.LogInformation("----- Commit transaction {TransactionId} for {CommandName}", transactionId, typeName);
await dbContext.CommitTransactionAsync(transaction);
await salesOrderIntegrationEventService.PublishEventsThroughEventBusAsync(transactionId);
}
});
return(response);
}
catch (Exception ex)
{
logger.LogError(ex, "ERROR Handling transaction for {CommandName} ({@Command})", typeName, request);
throw;
}
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
try
{
await _dbContext.BeginTransactionAsync();
var actionExecuted = await next();
if (actionExecuted.Exception != null && !actionExecuted.ExceptionHandled)
{
_dbContext.RollbackTransaction();
}
else
{
await _dbContext.CommitTransactionAsync();
}
}
catch (Exception)
{
_dbContext.RollbackTransaction();
throw;
}
}
/// <summary>
/// 保存索引。
/// </summary>
/// <param name="entityType">模型实例对象。</param>
/// <param name="search">搜索实例对象。</param>
/// <param name="indexes">索引分词。</param>
/// <returns>返回保存结果。</returns>
public virtual async Task <bool> SaveAsync(IEntityType entityType, SearchDescriptor search, IEnumerable <string> indexes)
{
//防止重复，空值等等
indexes = indexes.Where(x => !string.IsNullOrWhiteSpace(x))
.Select(x => x.Trim())
.Distinct(StringComparer.OrdinalIgnoreCase)
.ToList();
return(await _searches.BeginTransactionAsync(async db =>
{
var dbSearch = await db.FindAsync(s => s.ProviderName == search.ProviderName && s.TargetId == search.TargetId);
if (dbSearch != null)
{
//重新生成的索引描述信息
if (!await db.UpdateAsync(s => s.Id == dbSearch.Id, new { search.IndexedDate, search.Summary }))
{
return false;
}
search.Id = dbSearch.Id;
}
else if (!await db.CreateAsync(search))
{
return false;
}
//删除关联表
var indb = db.As <SearchInIndex>();
if (dbSearch != null)
{
await indb.DeleteAsync(si => si.SearchId == dbSearch.Id);
}
//添加关键词和关联表
var indexdb = db.As <SearchIndex>();
foreach (var index in indexes)
{
if (string.IsNullOrWhiteSpace(index))
{
continue;
}
//添加关键词
var entry = await indexdb.FindAsync(x => x.Name == index);
if (entry == null)
{
entry = new SearchIndex {
Name = index
};
if (!await indexdb.CreateAsync(entry))
{
return false;
}
}
//添加关联表
if (!await indb.CreateAsync(new SearchInIndex {
IndexId = entry.Id, SearchId = search.Id
}))
{
return false;
}
}
//更新到实体表
if (await db.ExecuteNonQueryAsync($"UPDATE {entityType.Table} SET SearchIndexed = {(int)IndexedType.Completed} WHRE Id = { search.TargetId};"))
{
return true;
}
return false;
}, 300));
}
