public virtual async Task HandleEventAsync(EntityUpdatedEto <TenantEto> eventData)
{
try
{
using (_currentTenant.Change(null))
{
var tenant = await _tenantRepository.FindAsync(eventData.Entity.Id, true);
if (tenant == null)
{
return;
}
var connectionStrings = new ConnectionStrings();
foreach (var tenantConnectionString in tenant.ConnectionStrings)
{
connectionStrings[tenantConnectionString.Name] = tenantConnectionString.Value;
}
var cacheItem = new TenantConfigurationCacheItem(tenant.Id, tenant.Name, connectionStrings);
var cacheKey = TenantConfigurationCacheItem.CalculateCacheKey(eventData.Entity.Id.ToString());
await _cache.SetAsync(cacheKey, cacheItem);
}
}
catch (Exception ex)
{
_logger.LogException(ex);
}
}
public virtual async Task HandleEventAsync(EntityUpdatedEto <PaymentEto> eventData)
{
if (!eventData.Entity.CompletionTime.HasValue)
{
return;
}
using var currentTenant = _currentTenant.Change(eventData.Entity.TenantId);
foreach (var item in eventData.Entity.PaymentItems.Where(item => item.ItemType == PaymentsConsts.PaymentItemType))
{
var order = await _orderRepository.FindAsync(item.ItemKey);
if (order == null || order.PaidTime.HasValue ||
!await _orderPaymentChecker.IsValidPaymentAsync(order, eventData.Entity, item))
{
continue;
}
order.SetPaidTime(_clock.Now);
order.SetOrderStatus(OrderStatus.Processing);
await _orderRepository.UpdateAsync(order, true);
}
}
public virtual async Task HandleEventAsync(EntityUpdatedEto <ProductEto> eventData)
{
foreach (var skuId in eventData.Entity.ProductSkus.Select(sku => sku.Id))
{
await UpdateAsync(skuId);
}
}
public Task HandleEventAsync(EntityUpdatedEto <UserEto> eventData)
{
if (eventData.Entity.UserName == "john.nash")
{
_testCounter.Increment("EntityUpdatedEto<UserEto>");
}
return(Task.CompletedTask);
}
public virtual async Task HandleEventAsync(EntityUpdatedEto <PaymentEto> eventData)
{
if (eventData.Entity.PaymentItems.All(item => item.ItemType != PaymentsConsts.PaymentItemType))
{
return;
}
using var changeTenant = _currentTenant.Change(eventData.Entity.TenantId);
var payment = await _paymentRepository.FindAsync(eventData.Entity.Id);
if (payment == null)
{
return;
}
var publishCompletedEvent = eventData.Entity.CompletionTime.HasValue && !payment.CompletionTime.HasValue;
var publishCanceledEvent = eventData.Entity.CanceledTime.HasValue && !payment.CanceledTime.HasValue;
_objectMapper.Map(eventData.Entity, payment);
foreach (var etoItem in eventData.Entity.PaymentItems)
{
var item = payment.PaymentItems.FirstOrDefault(i => i.Id == etoItem.Id);
if (item == null)
{
item = _objectMapper.Map <PaymentItemEto, PaymentItem>(etoItem);
FillPaymentItemStoreId(item);
payment.PaymentItems.Add(item);
}
else
{
_objectMapper.Map(etoItem, item);
}
}
var etoPaymentItemIds = eventData.Entity.PaymentItems.Select(i => i.Id).ToList();
payment.PaymentItems.RemoveAll(i => !etoPaymentItemIds.Contains(i.Id));
await _paymentRepository.UpdateAsync(payment, true);
if (publishCompletedEvent)
{
await PublishPaymentCompletedEventAsync(payment);
}
if (publishCanceledEvent)
{
await PublishPaymentCanceledEventAsync(payment);
}
}
public virtual async Task HandleEventAsync(EntityUpdatedEto <RefundEto> eventData)
{
using var uow = _unitOfWorkManager.Begin(isTransactional: true);
using var changeTenant = _currentTenant.Change(eventData.Entity.TenantId);
var refund = await _refundRepository.FindAsync(eventData.Entity.Id);
if (refund == null)
{
return;
}
if (eventData.Entity.CompletedTime.HasValue && !refund.CompletedTime.HasValue)
{
uow.OnCompleted(async() => await _distributedEventBus.PublishAsync(new EShopRefundCompletedEto
{
Refund = _objectMapper.Map <Refund, EShopRefundEto>(refund)
}));
}
_objectMapper.Map(eventData.Entity, refund);
foreach (var etoItem in eventData.Entity.RefundItems)
{
var item = refund.RefundItems.FirstOrDefault(i => i.Id == etoItem.Id);
if (item == null)
{
item = _objectMapper.Map <RefundItemEto, RefundItem>(etoItem);
refund.RefundItems.Add(item);
}
else
{
_objectMapper.Map(etoItem, item);
}
FillRefundItemStoreId(item);
FillRefundItemOrderId(item);
}
var etoRefundItemIds = eventData.Entity.RefundItems.Select(i => i.Id).ToList();
refund.RefundItems.RemoveAll(i => !etoRefundItemIds.Contains(i.Id));
FillRefundItemOrderLines(refund);
await _refundRepository.UpdateAsync(refund, true);
await uow.CompleteAsync();
}
public virtual async Task HandleEventAsync(EntityUpdatedEto <PaymentEto> eventData)
{
var payment = await _paymentRepository.FindAsync(eventData.Entity.Id);
if (payment == null)
{
payment = _objectMapper.Map <PaymentEto, Payment>(eventData.Entity);
payment.SetPaymentItems(
_objectMapper.Map <List <PaymentItemEto>, List <PaymentItem> >(eventData.Entity.PaymentItems));
await _paymentRepository.InsertAsync(payment, true);
}
else
{
_objectMapper.Map(eventData.Entity, payment);
foreach (var etoItem in eventData.Entity.PaymentItems)
{
var item = payment.PaymentItems.FirstOrDefault(i => i.Id == etoItem.Id);
if (item == null)
{
if (!Guid.TryParse(etoItem.GetProperty <string>("StoreId"), out var storeId))
{
throw new StoreIdNotFoundException();
}
item = _objectMapper.Map <PaymentItemEto, PaymentItem>(etoItem);
item.SetStoreId(storeId);
payment.PaymentItems.Add(item);
}
else
{
_objectMapper.Map(etoItem, item);
}
}
var etoPaymentItemIds = eventData.Entity.PaymentItems.Select(i => i.Id).ToList();
payment.PaymentItems.RemoveAll(i => !etoPaymentItemIds.Contains(i.Id));
}
await _paymentRepository.UpdateAsync(payment, true);
}
public virtual async Task HandleEventAsync(EntityUpdatedEto <TenantEto> eventData)
{
var tenantDto = await _tenantAppService.GetAsync(eventData.Entity.Id);
var tenantConnectionStringsDto = await _tenantAppService.GetConnectionStringAsync(eventData.Entity.Id);
var connectionStrings = new ConnectionStrings();
foreach (var tenantConnectionString in tenantConnectionStringsDto.Items)
{
connectionStrings[tenantConnectionString.Name] = tenantConnectionString.Value;
}
var cacheItem = new TenantConfigurationCacheItem(tenantDto.Id, tenantDto.Name, connectionStrings);
var cacheKey = TenantConfigurationCacheItem.CalculateCacheKey(eventData.Entity.Id.ToString());
await _cache.SetAsync(cacheKey, cacheItem);
}
public async Task HandleEventAsync(EntityUpdatedEto <UserEto> eventData)
{
var user = await UserRepository.FindAsync(eventData.Entity.Id);
if (user == null)
{
//TODO: Why needed (ask to @ebicoglu)?
user = await UserLookupService.FindByIdAsync(eventData.Entity.Id);
if (user == null)
{
return;
}
}
user.Update(eventData.Entity);
await UserRepository.UpdateAsync(user);
}
public virtual async Task HandleEventAsync(EntityUpdatedEto <UserEto> eventData)
{
var user = await UserRepository.FindAsync(eventData.Entity.Id);
if (user == null)
{
user = await UserLookupService.FindByIdAsync(eventData.Entity.Id);
if (user == null)
{
return;
}
}
if (user.Update(eventData.Entity))
{
await UserRepository.UpdateAsync(user);
}
}
public virtual async Task HandleEventAsync(EntityUpdatedEto <TenantEto> eventData)
{
// 禁用租户过滤器
using (_dataFilter.Disable <IMultiTenant>())
{
var tenant = await _tenantRepository.FindAsync(eventData.Entity.Id, true);
if (tenant == null)
{
return;
}
var connectionStrings = new ConnectionStrings();
foreach (var tenantConnectionString in tenant.ConnectionStrings)
{
connectionStrings[tenantConnectionString.Name] = tenantConnectionString.Value;
}
var cacheItem = new TenantConfigurationCacheItem(tenant.Id, tenant.Name, connectionStrings);
var cacheKey = TenantConfigurationCacheItem.CalculateCacheKey(eventData.Entity.Id.ToString());
await _cache.SetAsync(cacheKey, cacheItem);
}
}
public virtual async Task HandleEventAsync(EntityUpdatedEto <PaymentEto> eventData)
{
var payment = await _paymentRepository.FindAsync(eventData.Entity.Id);
if (payment == null)
{
payment = _objectMapper.Map <PaymentEto, Payment>(eventData.Entity);
await _paymentRepository.InsertAsync(payment, true);
}
else
{
_objectMapper.Map(eventData.Entity, payment);
}
if (Guid.TryParse(eventData.Entity.GetProperty <string>("StoreId"), out var storeId))
{
payment.SetStoreId(storeId);
}
await _paymentRepository.UpdateAsync(payment, true);
}
public virtual async Task HandleEventAsync(EntityUpdatedEto <UserEto> eventData)
{
if (!GlobalFeatureManager.Instance.IsEnabled <CmsUserFeature>())
{
return;
}
var user = await UserRepository.FindAsync(eventData.Entity.Id);
if (user == null)
{
user = await UserLookupService.FindByIdAsync(eventData.Entity.Id);
if (user == null)
{
return;
}
}
if (user.Update(eventData.Entity))
{
await UserRepository.UpdateAsync(user);
}
}
