Esempio n. 1
0
        /// <summary>
        /// Validate and make the request
        /// </summary>
        public async Task <TaggingOperationResult> SendAsync()
        {
            try
            {
                Validate();
                TagOperator             tagService = new TagOperator(base.Provider);
                TagCRUDSuccessfulResult result     = await tagService.RemoveUserFromTagsAsync(this.UserId, this.Tags);

                return(result);
            }
            catch (AWSMobilePushNotificationServiceException ex)
            {
                return(new TagCRUDFailedResult(ex));
            }
            catch (Exception ex)
            {
                if (Provider.CatchAllExceptions)
                {
                    return(new TagCRUDFailedResult(ex.Message));
                }
                else
                {
                    throw ex;
                }
            }
        }
        public async Task <TagCRUDSuccessfulResult> RemoveUserFromTagsAsync(string userId, List <PNTag> tags, bool removeAllTags = false)
        {
            TagCRUDSuccessfulResult result = new TagCRUDSuccessfulResult();

            if (removeAllTags)
            {
                int modification = await RemoveAllTagsOfUserAsync(userId);

                result.NumberOfModifications = modification;
                return(result);
            }
            else
            {
                foreach (var tagToRemove in tags)
                {
                    DynamoTag tag = await tagTableOperator.GetTagAsync(tagToRemove.Tag);

                    if (tag == null)
                    {
                        continue;
                    }
                    List <DynamoSubscriber> dynamoSubscribers = await subscriberTableOperator.GetAllSubcribersOfUserAsync(userId);

                    var subscribers = dynamoSubscribers.Select(s => s.Subscriber).ToList();

                    await RemoveSubscribersFromTagAsync(tag.Tag, subscribers, tag.TaggingTypeEnum);

                    result.NumberOfModifications = result.NumberOfModifications + subscribers.Count;
                }
            }
            return(result);
        }
        public async Task <TaggingOperationResult> AddUserToTagsAsync(string userId, List <PNAttributedTag> tags)
        {
            List <DynamoSubscriber> subscribers = await subscriberTableOperator.GetAllSubcribersOfUserAsync(userId);

            if (subscribers.Count == 0)
            {
                return(new TagCRUDFailedResult(new UserNotFoundException(userId)));
            }

            foreach (var subscriber in subscribers)
            {
                await SubscribeToTagsAsync(subscriber, tags);
            }
            TagCRUDSuccessfulResult result = new TagCRUDSuccessfulResult();

            result.NumberOfModifications = subscribers.Count;
            return(result);
        }
        public async Task <TaggingOperationResult> DeleteTagAsync(PNTag tag)
        {
            DynamoTag pnTag = await tagTableOperator.GetTagAsync(tag.Tag);

            if (pnTag == null)
            {
                return(new TagCRUDFailedResult(new TagNotFoundException(tag.Tag)));
            }

            int totalDeleted = 0;

            if (pnTag.TaggingTypeEnum == PNTagType.Iterative)
            {
                //Warning: You could delete by rangekey conditional expression. Check later
                var iterativeTags = await iterativeTagTableOperator.GetAllSubscribersForTagAsync(tag.Tag);

                var subscribers = iterativeTags.Select(t => t.Subscriber).ToList();
                await RemoveSubscribersFromIterativeTagAsync(pnTag.Tag, subscribers);

                totalDeleted = totalDeleted + subscribers.Count;
            }

            if (pnTag.TaggingTypeEnum == PNTagType.SNSTopic)
            {
                var snsTags = await snsTopicTagTableOperator.GetAllSubscribersForTagAsync(tag.Tag);

                var subscribers = snsTags.Select(t =>
                {
                    var subscriber = t.Subscriber;
                    subscriber.SNSSubscriptionArn = t.SnsSubscriptionArn;
                    return(subscriber);
                }).ToList();
                await RemoveSubscribersFromSNSTopicTagAsync(pnTag.Tag, subscribers);

                totalDeleted = totalDeleted + subscribers.Count;
            }
            await RemoveDynamoTagAsync(pnTag.Tag);

            TagCRUDSuccessfulResult result = new TagCRUDSuccessfulResult();

            result.NumberOfModifications = totalDeleted;
            return(result);
        }