public async Task SearchNotificationsAsync_ContainsActiveNotications()
{
//Arrange
_notificationRegistrar.RegisterNotification <RegistrationEmailNotification>();
_notificationRegistrar.RegisterNotification <InvoiceEmailNotification>();
_notificationRegistrar.RegisterNotification <OrderSentEmailNotification>();
var responseGroup = NotificationResponseGroup.Default.ToString();
var searchCriteria = new NotificationSearchCriteria()
{
ResponseGroup = responseGroup
};
_repositoryMock.Setup(n => n.GetByTypesAsync(
new[]
{
nameof(RegistrationEmailNotification),
nameof(InvoiceEmailNotification),
nameof(OrderSentEmailNotification)
}, null, null, responseGroup))
.ReturnsAsync(new NotificationEntity[] { new EmailNotificationEntity {
IsActive = true, Type = nameof(OrderSentEmailNotification)
} });
//Act
var result = await _notificationSearchService.SearchNotificationsAsync(searchCriteria);
//Assert
Assert.Contains(result.Results, x => x.IsActive);
}
public async Task <ApiPageResult> GetNotificationsForManager([FromBody] NotificationSearchCriteria criteria)
{
var page = await _notificationService.GetPageAsync(criteria);
var result = new ApiPageResult
{
Code = 200,
Message = "获取通知列表成功",
Page = page,
};
return(result);
}
public async Task <ApiResult> GetNotifications([FromBody] NotificationSearchCriteria criteria)
{
criteria.ToUserId = HttpContext.User.GetUserId();
var page = await _notificationService.GetPageAsync(criteria);
var result = new ApiPageResult
{
Code = 200,
Message = "获取通知列表成功",
Page = page,
};
return(result);
}
public async Task SearchNotifications_ContainsTwitterNotification()
{
//Arrange
var criteria = new NotificationSearchCriteria()
{
Take = int.MaxValue
};
//Act
var result = await _notificationSearchService.SearchNotificationsAsync(criteria);
//Assert
Assert.Contains(result.Results, n => n.Type == nameof(PostTwitterNotification) && n.IsActive);
}
public async Task SearchNotificationsAsync_GetNotifications()
{
//Arrange
var searchCriteria = new NotificationSearchCriteria();
_notificationRegistrar.RegisterNotification <RegistrationEmailNotification>();
_notificationRegistrar.RegisterNotification <InvoiceEmailNotification>();
_notificationRegistrar.RegisterNotification <OrderSentEmailNotification>();
//Act
var result = await _notificationSearchService.SearchNotificationsAsync(searchCriteria);
//Assert
Assert.NotEmpty(result.Results);
}
protected virtual IList <SortInfo> BuildSortExpression(NotificationSearchCriteria criteria)
{
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo
{
SortColumn = nameof(NotificationEntity.Type)
}
};
}
return(sortInfos);
}
public async Task SearchNotificationsAsync_Get2Items()
{
//Arrange
_notificationRegistrar.RegisterNotification <RegistrationEmailNotification>();
_notificationRegistrar.RegisterNotification <InvoiceEmailNotification>();
_notificationRegistrar.RegisterNotification <OrderSentEmailNotification>();
var searchCriteria = new NotificationSearchCriteria
{
Take = 2,
Skip = 0
};
//Act
var result = await _notificationSearchService.SearchNotificationsAsync(searchCriteria);
//Assert
Assert.Equal(2, result.Results.Count);
}
public async Task SaveChangesAsync_UpdateTwitterNotification()
{
//Arrange
var criteria = new NotificationSearchCriteria()
{
Take = int.MaxValue
};
var notification = _notificationSearchService.SearchNotifications(criteria).Results.FirstOrDefault();
if (notification is TwitterNotification twitterNotification)
{
twitterNotification.Post = $"Post {DateTime.Now}";
}
//Act
await _notificationService.SaveChangesAsync(new [] { notification });
//Assert
}
public GenericSearchResult <Notification> SearchNotifications(NotificationSearchCriteria criteria)
{
var query = AbstractTypeFactory <Notification> .AllTypeInfos
.Where(t => t.AllSubclasses.Any(s => s != t.Type && s.IsSubclassOf(typeof(Notification))))
.Select(n => n.Type)
.AsQueryable();
if (!string.IsNullOrEmpty(criteria.Keyword))
{
query = query.Where(n => n.Name.Contains(criteria.Keyword));
}
var totalCount = query.Count();
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[] { new SortInfo {
SortColumn = ReflectionUtility.GetPropertyName <Notification>(x => x.Type), SortDirection = SortDirection.Ascending
} };
}
var collection = query.OrderBySortInfos(sortInfos).Skip(criteria.Skip).Take(criteria.Take).ToList();
var list = collection.Select(t =>
{
var result = AbstractTypeFactory <Notification> .TryCreateInstance(t.Name);
NotificationEntity notificationEntity;
using (var repository = _repositoryFactory())
{
notificationEntity = repository.GetByTypeAsync(t.Name, criteria.TenantId, criteria.TenantType, criteria.ResponseGroup).GetAwaiter().GetResult();
}
return(notificationEntity != null ? notificationEntity.ToModel(result) : result);
}).ToList();
return(new GenericSearchResult <Notification>
{
Results = list,
TotalCount = totalCount
});
}
public async Task <NotificationSearchResult> SearchNotificationsAsync(NotificationSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchNotificationsAsync), criteria.GetCacheKey());
var notificationSearchResult = await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(NotificationSearchCacheRegion.CreateChangeToken());
var result = AbstractTypeFactory <NotificationSearchResult> .TryCreateInstance();
var sortInfos = BuildSortExpression(criteria);
using (var repository = _repositoryFactory())
{
//Optimize performance and CPU usage
repository.DisableChangesTracking();
var query = BuildQuery(repository, criteria, sortInfos);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var notificationIds = await query.OrderBySortInfos(sortInfos).ThenBy(x => x.Id)
.Select(x => x.Id)
.Skip(criteria.Skip).Take(criteria.Take)
.ToArrayAsync();
var unorderedResults = await _notificationService.GetByIdsAsync(notificationIds, criteria.ResponseGroup);
result.Results = unorderedResults.OrderBy(x => Array.IndexOf(notificationIds, x.Id)).ToArray();
foreach (var notification in result.Results)
{
notification.ReduceDetails(criteria.ResponseGroup);
}
}
}
return(result);
});
return(notificationSearchResult.Clone() as NotificationSearchResult);
}
protected virtual IQueryable <NotificationEntity> GetNotificationsQuery(INotificationRepository repository, NotificationSearchCriteria criteria, IEnumerable <SortInfo> sortInfos)
{
var query = repository.Notifications;
if (!string.IsNullOrEmpty(criteria.NotificationType))
{
query = query.Where(x => x.Type == criteria.NotificationType);
}
if (!string.IsNullOrEmpty(criteria.TenantId))
{
query = query.Where(x => x.TenantId == criteria.TenantId);
}
if (!string.IsNullOrEmpty(criteria.TenantType))
{
query = query.Where(x => x.TenantType == criteria.TenantType);
}
query = query.OrderBySortInfos(sortInfos);
return(query);
}
public async Task <IActionResult> GetNotifications(NotificationSearchCriteria searchCriteria)
{
var notifications = await _notificationSearchService.SearchNotificationsAsync(searchCriteria);
return(Ok(notifications));
}
public IActionResult GetNotifications(NotificationSearchCriteria searchCriteria)
{
var notifications = _notificationSearchService.SearchNotifications(searchCriteria);
return(Ok(notifications));
}
public async Task <Page <NotificationUser> > GetPageAsync(NotificationSearchCriteria criteria)
{
return(await _notificationRepository.GetPageAsync(criteria));
}
public async Task <ActionResult <NotificationSearchResult> > GetNotifications([FromBody] NotificationSearchCriteria searchCriteria)
{
var notifications = await _notificationSearchService.SearchNotificationsAsync(searchCriteria);
return(Ok(notifications));
}
public async Task <NotificationSearchResult> SearchNotificationsAsync(NotificationSearchCriteria criteria)
{
var result = AbstractTypeFactory <NotificationSearchResult> .TryCreateInstance();
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo
{
SortColumn = "Name"
}
};
}
var tmpSkip = 0;
var tmpTake = 0;
using (var repository = _repositoryFactory())
{
var query = GetNotificationsQuery(repository, criteria, sortInfos);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var notificationIds = await query.Select(x => x.Id).Skip(criteria.Skip).Take(criteria.Take).ToArrayAsync();
result.Results = (await _notificationService.GetByIdsAsync(notificationIds, criteria.ResponseGroup)).AsQueryable().OrderBySortInfos(sortInfos).ToList();
}
}
tmpSkip = Math.Min(result.TotalCount, criteria.Skip);
tmpTake = Math.Min(criteria.Take, Math.Max(0, result.TotalCount - criteria.Skip));
criteria.Skip = criteria.Skip - tmpSkip;
criteria.Take = criteria.Take - tmpTake;
if (criteria.Take > 0)
{
var transientNotificationsQuery = AbstractTypeFactory <Notification> .AllTypeInfos.Select(x => AbstractTypeFactory <Notification> .TryCreateInstance(x.Type.Name))
.OfType <Notification>().AsQueryable();
if (!string.IsNullOrEmpty(criteria.NotificationType))
{
transientNotificationsQuery = transientNotificationsQuery.Where(x => x.Type.EqualsInvariant(criteria.NotificationType));
}
var allPersistentProvidersTypes = result.Results.Select(x => x.GetType()).Distinct();
transientNotificationsQuery = transientNotificationsQuery.Where(x => !allPersistentProvidersTypes.Contains(x.GetType()));
transientNotificationsQuery = transientNotificationsQuery.Where(x => !x.Kind.EqualsInvariant(x.Type));
result.TotalCount += transientNotificationsQuery.Count();
var transientNotifications = transientNotificationsQuery.Skip(criteria.Skip).Take(criteria.Take).ToList();
result.Results = result.Results.Concat(transientNotifications).AsQueryable().OrderBySortInfos(sortInfos).ToList();
}
return(result);
}
protected virtual IQueryable <NotificationEntity> BuildQuery(INotificationRepository repository, NotificationSearchCriteria criteria, IEnumerable <SortInfo> sortInfos)
{
var query = repository.Notifications;
if (!string.IsNullOrEmpty(criteria.NotificationType))
{
var notificationType = GetNotificationType(criteria.NotificationType);
query = query.Where(x => x.Type == notificationType);
}
query = query.Where(x => x.TenantId == criteria.TenantId);
query = query.Where(x => x.TenantType == criteria.TenantType);
if (!string.IsNullOrEmpty(criteria.Keyword))
{
var words = Regex
.Split(criteria.Keyword, @"\W")
.Where(x => !string.IsNullOrWhiteSpace(x));
foreach (var word in words)
{
query = query.Where(x => x.Type.Contains(word));
}
}
if (criteria.IsActive)
{
query = query.Where(x => x.IsActive == null || x.IsActive.Value);
}
query = query.OrderBySortInfos(sortInfos);
return(query);
}
