public virtual async Task PublishAsync(
string pushRequestName,
PushRequestData data = null,
EntityIdentifier entityIdentifier = null,
PushRequestPriority priority = PushRequestPriority.Normal,
IUserIdentifier[] userIds = null,
IUserIdentifier[] excludedUserIds = null,
int?[] tenantIds = null)
{
if (pushRequestName.IsNullOrEmpty())
{
throw new ArgumentException("PushRequestName can not be null or whitespace!", nameof(pushRequestName));
}
if (!tenantIds.IsNullOrEmpty() && !userIds.IsNullOrEmpty())
{
throw new ArgumentException("tenantIds can be set only if userIds is not set!", nameof(tenantIds));
}
if (tenantIds.IsNullOrEmpty() && userIds.IsNullOrEmpty())
{
tenantIds = new[] { AbpSession.TenantId };
}
var pushRequest = new PushRequest(GuidGenerator.Create())
{
Name = pushRequestName,
EntityTypeName = entityIdentifier?.Type.FullName,
EntityTypeAssemblyQualifiedName = entityIdentifier?.Type.AssemblyQualifiedName,
EntityId = entityIdentifier?.Id.ToJsonString(),
Priority = priority,
UserIds = userIds.IsNullOrEmpty() ? null : userIds.Select(uid => uid.ToUserIdentifier().ToUserIdentifierString()).JoinAsString(","),
ExcludedUserIds = excludedUserIds.IsNullOrEmpty() ? null : excludedUserIds.Select(uid => uid.ToUserIdentifier().ToUserIdentifierString()).JoinAsString(","),
TenantIds = PushRequest.ToTenantIds(tenantIds),
Data = data?.ToJsonString(),
DataTypeName = data?.GetType().AssemblyQualifiedName
};
await RequestStore.InsertRequestAsync(pushRequest);
await CurrentUnitOfWork.SaveChangesAsync(); //To get Id of the push request
if (userIds != null && userIds.Length <= Configuration.MaxUserCountForForegroundDistribution)
{
//We can directly distribute the push request since there are not much receivers
await RequestDistributor.DistributeAsync(pushRequest.Id);
}
else
{
//We enqueue a background job since distributing may get a long time
await BackgroundJobManager.EnqueueAsync <PushRequestDistributionJob, PushRequestDistributionJobArgs>(
new PushRequestDistributionJobArgs(
pushRequest.Id
)
);
}
}
public virtual async Task InsertRequestAsync(PushRequest request)
{
// push request only defined on Host side
using (UnitOfWorkManager.Current.SetTenantId(null))
{
await RequestRepository.DeleteAsync(request);
await UnitOfWorkManager.Current.SaveChangesAsync();
}
}
public virtual Task InsertRequestAsync(PushRequest request)
{
if (Requests.ContainsKey(request.Id))
{
throw new AbpException(string.Format("Request {0} already exists", request.Id));
}
request.Id = GuidGenerator.Create();
if (!Requests.TryAdd(request.Id, request))
{
throw new AbpException(string.Format("Failed to insert request {0}:{1}", request.Name, request.Id));
}
return(Task.CompletedTask);
}
public virtual async Task DistributeAsync(Guid pushRequestId)
{
PushRequest pushRequest = null;
// set tenantId = null, because push request only store in host side
using (UnitOfWorkManager.Current.SetTenantId(null))
{
pushRequest = await RequestStore.GetRequestOrNullAsync(pushRequestId);
if (pushRequest == null)
{
Logger.WarnFormat("PushRequestDistributionJob can not continue since could not found push request by id: {0} ", pushRequestId);
return;
}
}
// TODO: change GetUsers() to GetDevices()
var users = await GetUsers(pushRequest);
if (users.IsNullOrEmpty())
{
Logger.WarnFormat("Push Request with id: {0} does not have any target user", pushRequest.Id);
}
try
{
foreach (var providerInfo in Configuration.ServiceProviders)
{
// TODO: allow PushRequest to store target providers
using (var provider = CreateProvider(providerInfo.Name))
{
await provider.Object.PushAsync(users, pushRequest);
}
}
await RequestStore.DeleteRequestAsync(pushRequest.Id);
}
catch (Exception ex)
{
Logger.Warn(ex.ToString(), ex);
}
}
public Task InsertRequestAsync(PushRequest request)
{
return(Task.FromResult(0));
}
protected virtual async Task <UserIdentifier[]> GetUsers(PushRequest request)
{
var userIds = new List <UserIdentifier>();
if (request.UserIds.IsNullOrEmpty())
{
//Get subscribed users
List <PushRequestSubscription> subscriptions;
if (request.TenantIds.IsNullOrWhiteSpace() ||
request.TenantIds.Trim() == PushRequest.AllTenantIdsString)
{
//Get all subscribed users of all tenants
subscriptions = await RequestStore.GetSubscriptionsAsync(
request.Name,
request.EntityTypeName,
request.EntityId
);
}
else
{
var tenantIds = PushRequest.GetTenantIds(request.TenantIds);
//Get all subscribed users of specified tenant(s)
subscriptions = await RequestStore.GetSubscriptionsAsync(
tenantIds,
request.Name,
request.EntityTypeName,
request.EntityId
);
}
//Remove invalid subscriptions
var invalidSubscriptions = new Dictionary <Guid, PushRequestSubscription>();
var subscriptionGroups = subscriptions.GroupBy(s => s.TenantId);
foreach (var subscriptionGroup in subscriptionGroups)
{
using (CurrentUnitOfWork.SetTenantId(subscriptionGroup.Key))
{
foreach (var subscription in subscriptionGroup)
{
if (!await DefinitionManager.IsAvailableAsync(request.Name, new UserIdentifier(subscription.TenantId, subscription.UserId)) ||
// TODO: exclude system push request from checking user setting
!SettingManager.GetSettingValueForUser <bool>(AbpPushSettingNames.Receive, 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();
}
else
{
//Directly get from UserIds
userIds = request
.UserIds
.Split(",")
.Select(uidAsStr => UserIdentifier.Parse(uidAsStr))
// TODO: exclude system push request from checking user setting
.Where(uid => SettingManager.GetSettingValueForUser <bool>(AbpPushSettingNames.Receive, uid.TenantId, uid.UserId))
.ToList();
}
if (!request.ExcludedUserIds.IsNullOrEmpty())
{
//Exclude specified users.
var excludedUserIds = request
.ExcludedUserIds
.Split(",")
.Select(uidAsStr => UserIdentifier.Parse(uidAsStr))
.ToList();
userIds.RemoveAll(uid => excludedUserIds.Any(euid => euid.Equals(uid)));
}
return(userIds.ToArray());
}
