protected virtual async Task <long[]> GetUserIds(NotificationScheme notificationScheme)
        {
            List <long> userIds;

            if (!notificationScheme.UserIds.IsNullOrEmpty())
            {
                //Directly get from UserIds and filter out not receive notification users
                userIds = notificationScheme
                          .UserIds
                          .Split(",")
                          .Select(long.Parse)
                          .Where(uid =>
                                 AsyncHelper.RunSync(() => _settingService.GetSettingValueForUserAsync(uid, SettingDefinitions.Names.ReceiveNotifications)).ToUpper() == "TRUE")
                          .ToList();
            }
            else
            {
                //Get all subscribed users
                var subscriptions = await _notificationRepository.GetSubscriptionsAsync(
                    notificationScheme.NotificationName,
                    notificationScheme.EntityTypeName,
                    notificationScheme.EntityId
                    );

                //Remove invalid subscriptions
                var invalidSubscriptions = new Dictionary <long, NotificationSubscription>();
                foreach (var subscription in subscriptions)
                {
                    if (!await _notificationDefinitionManager.IsAvailableAsync(notificationScheme.NotificationName, subscription.UserId) ||
                        AsyncHelper.RunSync(() => _settingService.GetSettingValueForUserAsync(subscription.UserId, SettingDefinitions.Names.ReceiveNotifications)).ToUpper() != "TRUE")
                    {
                        invalidSubscriptions[subscription.Id] = subscription;
                    }
                }

                subscriptions.RemoveAll(s => invalidSubscriptions.ContainsKey(s.Id));

                //Get user ids
                userIds = subscriptions.Select(s => s.UserId).ToList();
            }

            if (!notificationScheme.ExcludedUserIds.IsNullOrEmpty())
            {
                //Exclude specified userIds.
                var excludedUserIds = notificationScheme
                                      .ExcludedUserIds
                                      .Split(",")
                                      .Select(long.Parse)
                                      .ToList();

                userIds.RemoveAll(uid => excludedUserIds.Any(euid => euid.Equals(uid)));
            }

            return(userIds.ToArray());
        }
Пример #2
0
        protected virtual async Task <UserIdentifier[]> GetUsers(NotificationInfo notificationInfo)
        {
            List <UserIdentifier> userIds;

            if (!notificationInfo.UserIds.IsNullOrEmpty())
            {
                //Directly get from UserIds
                userIds = notificationInfo
                          .UserIds
                          .Split(",")
                          .Select(uidAsStr => UserIdentifier.Parse(uidAsStr))
                          .Where(uid => SettingManager.GetSettingValueForUser <bool>(NotificationSettingNames.ReceiveNotifications, uid.TenantId, uid.UserId))
                          .ToList();
            }
            else
            {
                //Get subscribed users

                var tenantIds = GetTenantIds(notificationInfo);

                List <NotificationSubscriptionInfo> subscriptions;

                if (tenantIds.IsNullOrEmpty() ||
                    (tenantIds.Length == 1 && tenantIds[0] == NotificationInfo.AllTenantIds.To <int>()))
                {
                    //Get all subscribed users of all tenants
                    subscriptions = await _notificationStore.GetSubscriptionsAsync(
                        notificationInfo.NotificationName,
                        notificationInfo.EntityTypeName,
                        notificationInfo.EntityId
                        );
                }
                else
                {
                    //Get all subscribed users of specified tenant(s)
                    subscriptions = await _notificationStore.GetSubscriptionsAsync(
                        tenantIds,
                        notificationInfo.NotificationName,
                        notificationInfo.EntityTypeName,
                        notificationInfo.EntityId
                        );
                }

                //Remove invalid subscriptions
                var invalidSubscriptions = new Dictionary <Guid, NotificationSubscriptionInfo>();

                //TODO: Group subscriptions per tenant for potential performance improvement
                foreach (var subscription in subscriptions)
                {
                    using (CurrentUnitOfWork.SetTenantId(subscription.TenantId))
                    {
                        if (!await _notificationDefinitionManager.IsAvailableAsync(notificationInfo.NotificationName, new UserIdentifier(subscription.TenantId, subscription.UserId)) ||
                            !SettingManager.GetSettingValueForUser <bool>(NotificationSettingNames.ReceiveNotifications, subscription.TenantId, subscription.UserId))
                        {
                            invalidSubscriptions[subscription.Id] = subscription;
                        }
                    }
                }

                subscriptions.RemoveAll(s => invalidSubscriptions.ContainsKey(s.Id));

                //Get user ids
                userIds = subscriptions
                          .Select(s => new UserIdentifier(s.TenantId, s.UserId))
                          .ToList();
            }

            if (!notificationInfo.ExcludedUserIds.IsNullOrEmpty())
            {
                //Exclude specified users.
                var excludedUserIds = notificationInfo
                                      .ExcludedUserIds
                                      .Split(",")
                                      .Select(uidAsStr => UserIdentifier.Parse(uidAsStr))
                                      .ToList();

                userIds.RemoveAll(uid => excludedUserIds.Any(euid => euid.Equals(uid)));
            }

            return(userIds.ToArray());
        }
Пример #3
0
        protected virtual async Task <long[]> GetUserIds(NotificationInfo notificationInfo)
        {
            List <long> userIds;

            if (!notificationInfo.UserIds.IsNullOrEmpty())
            {
                //Directly get from UserIds
                userIds = notificationInfo
                          .UserIds
                          .Split(",")
                          .Select(uidAsStr => uidAsStr.To <long>())
                          .Where(uid => SettingManager.GetSettingValueForUser <bool>(NotificationSettingNames.ReceiveNotifications, null, uid))
                          .ToList();
            }
            else
            {
                //Get subscribed users

                var tenantIds = GetTenantIds(notificationInfo);

                List <NotificationSubscriptionInfo> subscriptions;

                using (CurrentUnitOfWork.DisableFilter(AbpDataFilters.MayHaveTenant))
                {
                    if (tenantIds.IsNullOrEmpty())
                    {
                        //Get all subscribed users of all tenants
                        subscriptions = await _notificationStore.GetSubscriptionsAsync(
                            notificationInfo.NotificationName,
                            notificationInfo.EntityTypeName,
                            notificationInfo.EntityId
                            );
                    }
                    else
                    {
                        //Get all subscribed users of specified tenant(s)
                        subscriptions = await _notificationStore.GetSubscriptionsAsync(
                            tenantIds,
                            notificationInfo.NotificationName,
                            notificationInfo.EntityTypeName,
                            notificationInfo.EntityId
                            );
                    }

                    //Remove invalid subscriptions
                    var invalidSubscriptions = new Dictionary <Guid, NotificationSubscriptionInfo>();

                    foreach (var subscription in subscriptions)
                    {
                        if (!await _notificationDefinitionManager.IsAvailableAsync(notificationInfo.NotificationName, subscription.TenantId, subscription.UserId) ||
                            !SettingManager.GetSettingValueForUser <bool>(NotificationSettingNames.ReceiveNotifications, subscription.TenantId, subscription.UserId))
                        {
                            invalidSubscriptions[subscription.Id] = subscription;
                        }
                    }

                    subscriptions.RemoveAll(s => invalidSubscriptions.ContainsKey(s.Id));
                }

                //Get user ids
                userIds = subscriptions
                          .Select(s => s.UserId)
                          .ToList();
            }

            if (!notificationInfo.ExcludedUserIds.IsNullOrEmpty())
            {
                //Exclude specified users.
                var excludedUserIds = notificationInfo
                                      .ExcludedUserIds
                                      .Split(",")
                                      .Select(uidAsStr => uidAsStr.To <long>())
                                      .ToList();

                userIds.RemoveAll(uid => excludedUserIds.Contains(uid));
            }

            return(userIds.ToArray());
        }