Esempio n. 1
0
        private async Task <IterativeTagResponseTuple> PublishToIterativeTagAsync(List <DynamoIterativeTag> entries)
        {
            // Parallel tasks are not implemented because of AWS-SDK SNS bug in parellel execution cause high memory usage
            // List<Task> tasks = new List<Task>();
            IterativeTagResponseTuple resultTuples = new IterativeTagResponseTuple();

            foreach (var tagEntry in entries)
            {
                if (IsTargetPlatformRestrictsSubscriber(model.TargetPlatform, tagEntry.Platform))
                {
                    var failed = new PublishToSNSFailedResult(new PlatformUnmatchedException(model.TargetPlatform, tagEntry.Platform));
                    resultTuples.Add(new Tuple <PublishToSNSResult, DynamoIterativeTag>(failed, tagEntry));
                    continue;
                }

                string message = SerializeMessageFromProperties(tagEntry.Platform);
                if (string.IsNullOrEmpty(message))
                {
                    var failed = new PublishToSNSFailedResult(new SNSNotificationMessageNullException());
                    resultTuples.Add(new Tuple <PublishToSNSResult, DynamoIterativeTag>(failed, tagEntry));
                    continue;
                }

                var result = await PublishToEndpointAsync(tagEntry.EndpointArn, message);

                result.UserId = tagEntry.Subscriber.UserId;
                resultTuples.Add(new Tuple <PublishToSNSResult, DynamoIterativeTag>(result, tagEntry));
            }
            return(resultTuples);
        }
Esempio n. 2
0
        private async Task <PublishToSNSResult> PublishToSubscriberAsync(DynamoSubscriber subscriber)
        {
            PublishToSNSResult result;

            if (subscriber == null)
            {
                result = new PublishToSNSFailedResult(new SubscriberNotFoundException(subscriber.Subscriber.UserId, subscriber.Subscriber.Token));
                return(result);
                // throw new SubscriberNotFoundException(subscriber.Subscriber.UserId, subscriber.Subscriber.Token);
            }
            if (IsTargetPlatformRestrictsSubscriber(model.TargetPlatform, subscriber.Platform))
            {
                result = new PublishToSNSFailedResult(new PlatformUnmatchedException(model.TargetPlatform, subscriber.Platform));
                return(result);
                // return new PublishToSNSFailedResult("TargetPlatform doesn't match with the subscribers platform");
            }

            string message = base.SerializeMessageFromProperties(subscriber.Platform);

            if (string.IsNullOrEmpty(message))
            {
                result = new PublishToSNSFailedResult(new SNSNotificationMessageNullException());
                return(result);
            }

            // Console.WriteLine("SerializedMessage: " + message);

            result = await PublishToEndpointAsync(subscriber.EndpointARN, message);

            result.UserId = subscriber.UserId;
            if (result.ErrorAlias == ErrorReason.SNSEndpointDisabled ||
                result.ErrorAlias == ErrorReason.SNSEndpointNotFound)
            {
                await unRegisterOperator.UnRegisterSubscriberAsync(subscriber.UserId, subscriber.NotificationToken);
            }

            return(result);
        }