private async Task <string> EnsureTopic(string topicName) { try { _topicLock.EnterReadLock(); if (_snsTopics.TryGetValue(topicName, out var url)) { return(url); } } finally { _topicLock.ExitReadLock(); } try { _topicLock.EnterWriteLock(); var snsCreateResponse = await _snsClient.CreateTopicAsync(topicName); var arn = snsCreateResponse.TopicArn; _snsTopics.Add(topicName, arn); return(arn); } finally { _topicLock.ExitWriteLock(); } }
public async Task <string> CreateTopic(string topicName) { var request = new CreateTopicRequest(topicName); var response = await _sns.CreateTopicAsync(request); return(response.TopicArn); }
private async Task <Application> CreateTopics(Application app) { string queueName = $"queue-{app.Name.Replace(" ", "")}-{app.Id}-subs"; AmazonSimpleNotificationServiceClient clientSNS = AwsFactory.CreateClient <AmazonSimpleNotificationServiceClient>(); //create topics and subscribe them await app.Events.ToList().ForEachAsync(e => { string topic_name = $"topic-{app.Name.Replace(" ", "")}-event-{e.EventName}"; CreateTopicResponse topicResponse = clientSNS.CreateTopicAsync(new CreateTopicRequest(topic_name)).Result; if (topicResponse.HttpStatusCode != System.Net.HttpStatusCode.OK) { throw new Exception($"Error creating topic {topic_name}"); } e.TopicArn = topicResponse.TopicArn; }); return(app); }
/// <summary> /// Ensures the topic. The call to create topic is idempotent and just returns the arn if it already exists. Therefore there is /// no nee to check then create if it does not exist, as this would be extral calls /// </summary> /// <param name="topicName">Name of the topic.</param> /// <param name="client">The client.</param> /// <returns>System.String.</returns> private string EnsureTopic(string topicName, AmazonSimpleNotificationServiceClient client) { _logger.DebugFormat("Topic with name {0} does not exist. Creating new topic", topicName); var topicResult = client.CreateTopicAsync(new CreateTopicRequest(topicName)).Result; return(topicResult.HttpStatusCode == HttpStatusCode.OK ? topicResult.TopicArn : string.Empty); }
public async Task Initialise() { _topicArn = (await _snsClient.CreateTopicAsync(_topicName)).TopicArn; _queueUrl = (await _sqsClient.CreateQueueAsync(_queueName)).QueueUrl; await SubscribeTopicToQueue(); _initialised = true; }
public async Task SetTopicConfigurationTests() { using (var snsClient = new AmazonSimpleNotificationServiceClient()) { string topicName = UtilityMethods.GenerateName("events-test"); var snsCreateResponse = await snsClient.CreateTopicAsync(topicName); var bucketName = await UtilityMethods.CreateBucketAsync(Client, "SetTopicConfigurationTests"); try { await snsClient.AuthorizeS3ToPublishAsync(snsCreateResponse.TopicArn, bucketName); PutBucketNotificationRequest putRequest = new PutBucketNotificationRequest { BucketName = bucketName, TopicConfigurations = new List <TopicConfiguration> { new TopicConfiguration { Id = "the-topic-test", Topic = snsCreateResponse.TopicArn, Events = new List <EventType> { EventType.ObjectCreatedPut } } } }; await Client.PutBucketNotificationAsync(putRequest); var getResponse = WaitUtils.WaitForComplete( () => { return(Client.GetBucketNotificationAsync(bucketName).Result); }, (r) => { return(r.TopicConfigurations.Count > 0); }); Assert.Equal(1, getResponse.TopicConfigurations.Count); Assert.Equal(1, getResponse.TopicConfigurations[0].Events.Count); Assert.Equal(EventType.ObjectCreatedPut, getResponse.TopicConfigurations[0].Events[0]); #pragma warning disable 618 Assert.Equal("s3:ObjectCreated:Put", getResponse.TopicConfigurations[0].Event); #pragma warning restore 618 Assert.Equal("the-topic-test", getResponse.TopicConfigurations[0].Id); Assert.Equal(snsCreateResponse.TopicArn, getResponse.TopicConfigurations[0].Topic); } finally { await snsClient.DeleteTopicAsync(snsCreateResponse.TopicArn); await UtilityMethods.DeleteBucketWithObjectsAsync(Client, bucketName); } } }
public async Task Publish_HasMessageTypeAttributeAndBody() { //Arrange var queueName = Guid.NewGuid().ToString(); var topicName = Guid.NewGuid().ToString(); var firstMessage = new FirstMessage { Value = "value1" }; var secondMessage = new SecondMessage { Value = "value2" }; var snsClient = new AmazonSimpleNotificationServiceClient( AppConfig.AccessKey, AppConfig.SecretKey, new AmazonSimpleNotificationServiceConfig { ServiceURL = AppConfig.ServiceUrl }); var topicArn = (await snsClient.CreateTopicAsync(topicName)).TopicArn; var sqsClient = new AmazonSQSClient( AppConfig.AccessKey, AppConfig.SecretKey, new AmazonSQSConfig { ServiceURL = AppConfig.ServiceUrl }); await sqsClient.CreateQueueAsync(queueName); var queueUrl = (await sqsClient.GetQueueUrlAsync(queueName)).QueueUrl; await snsClient.SubscribeQueueAsync(topicArn, sqsClient, queueUrl); //Act await snsClient.PublishAsync(topicArn, firstMessage); await snsClient.PublishAsync(topicArn, secondMessage); var response = await sqsClient.ReceiveMessageAsync(new ReceiveMessageRequest { QueueUrl = queueUrl, MaxNumberOfMessages = 2, MessageAttributeNames = new List <string> { "All" } }); var messageTypes = response.Messages .Select(message => JsonConvert.DeserializeObject <MessageBody>(message.Body)) .Select(body => body.MessageAttributes.Single(pair => pair.Key == "MessageType").Value.Value) .ToList(); //Assert new[] { nameof(FirstMessage), nameof(SecondMessage) } .ShouldAllBe(s => messageTypes.Contains(s)); new [] { firstMessage.Value, secondMessage.Value } .ShouldAllBe(s => response.Messages.Any(message => message.Body.Contains(s))); }
private static async Task <string> CreateSnsTopic(AmazonSimpleNotificationServiceClient amazonSnsServiceClient, string topicName) { await amazonSnsServiceClient.CreateTopicAsync(topicName); var listTopicsResponse = await amazonSnsServiceClient.ListTopicsAsync(); string topicArn = listTopicsResponse.Topics.FirstOrDefault()?.TopicArn; return(topicArn); }
static async Task <(string topicArn, Func <Task> topicCleanup)> CreateTopic( AmazonSimpleNotificationServiceClient snsClient, string timestamp, string name, CancellationToken cancellationToken) { var topic = await snsClient.CreateTopicAsync($"Beetles_{name}_{timestamp}", cancellationToken); return(topic.TopicArn, async() => await snsClient.DeleteTopicAsync(topic.TopicArn)); }
/// <summary> /// Method created to connect and process the Topic/Subscription in the AWS. /// </summary> /// <returns></returns> public void ProcessSubscription() { try { foreach (var topic in _topics) { SqsSnsConfiguration config = GetConnection(topic); MethodInfo method = GetMethod(topic); string topicName = topic.Value.TopicName; string subscriptName = topic.Value.Subscription; //Register Trace on the telemetry WorkBench.Telemetry.TrackTrace($"Topic {topicName} registered"); AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(config.AwsAccessKeyId, config.AwsSecretAccessKey); var topicRequest = new CreateTopicRequest { Name = topicName }; var topicResponse = snsClient.CreateTopicAsync(topicRequest).Result; var subsRequest = new ListSubscriptionsByTopicRequest { TopicArn = topicResponse.TopicArn }; var subs = snsClient.ListSubscriptionsByTopicAsync(subsRequest).Result.Subscriptions; foreach (Subscription subscription in subs) { try { WorkBench.Telemetry.TrackEvent("Method invoked"); //Use of the Metrics to monitoring the queue's processes, start the metric WorkBench.Telemetry.BeginMetricComputation("MessageProcessed"); //Processing the method defined with queue InvokeProcess(method, Encoding.UTF8.GetBytes(subscription.SubscriptionArn)); WorkBench.Telemetry.ComputeMetric("MessageProcessed", 1); //Finish the monitoring the queue's processes WorkBench.Telemetry.EndMetricComputation("MessageProcessed"); WorkBench.Telemetry.TrackEvent("Method terminated"); WorkBench.Telemetry.TrackEvent("Queue's message completed"); } catch (Exception exRegister) { //Use the class instead of interface because tracking exceptions directly is not supposed to be done outside AMAW (i.e. by the business code) ((LightTelemetry)WorkBench.Telemetry).TrackException(exRegister); } } } } catch (Exception exception) { //Use the class instead of interface because tracking exceptions directly is not supposed to be done outside AMAW (i.e. by the business code) ((LightTelemetry)WorkBench.Telemetry).TrackException(exception); } }
public static async Task <string> CreateTopic(string topicName) { using (var client = new AmazonSimpleNotificationServiceClient(ConfigManager.ConfigSettings.AccessKey, ConfigManager.ConfigSettings.Secret, Amazon.RegionEndpoint.USWest2)) { var request = new CreateTopicRequest(topicName); var response = await client.CreateTopicAsync(request); return(response.TopicArn); } }
public async System.Threading.Tasks.Task <CreateTopicResponse> CreateTopic(string topicName) { CreateTopicResponse createTopicResponse = new CreateTopicResponse(); using (AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(credentials, Amazon.RegionEndpoint.USEast2)) { CreateTopicRequest createTopicRequest = new CreateTopicRequest(topicName); createTopicResponse = await snsClient.CreateTopicAsync(createTopicRequest); } return(createTopicResponse); }
private async Task <bool> CreateTopicAsync() { var topicRequest = new CreateTopicRequest { Name = "AWSSkills" }; var topicResponse = await _snsClient.CreateTopicAsync(topicRequest); _topicArn = topicResponse.TopicArn; return(false); }
/// <summary> /// 创建sns 主题 /// sqs 订阅该主题 /// 发布消息 /// </summary> /// <param name="args"></param> /// <returns></returns> static async Task Main(string[] args) { string topicArn; var sharedFile = new SharedCredentialsFile(); sharedFile.TryGetProfile("default", out var sourceProfile); var credentials = AWSCredentialsFactory.GetAWSCredentials(sourceProfile, sharedFile); AmazonSimpleNotificationServiceClient client = new AmazonSimpleNotificationServiceClient(credentials, new AmazonSimpleNotificationServiceConfig() { ServiceURL = "http://192.168.1.57:4566" }); AmazonSQSClient as_client = new AmazonSQSClient(credentials, new AmazonSQSConfig() { ServiceURL = "http://192.168.1.57:4566" }); //查找主题 var l_response = await client.ListTopicsAsync(); if (!l_response.Topics.Any()) { //没有主题就创建主题 var c_response = await client.CreateTopicAsync("test"); topicArn = c_response.TopicArn; Console.WriteLine("topic create success,topicArn is {0}", c_response.TopicArn); } else { topicArn = l_response.Topics.First().TopicArn; } Subscription subscriptions; var ls_response = await client.ListSubscriptionsByTopicAsync(topicArn); //if (!ls_response.Subscriptions.Any(t => t.SubscriptionArn == "arn:aws:sns:us-east-1:000000000000:test:bac7453b-ae89-4021-81f2-044890c0d68c")) //{ // //如果没有订阅创建订阅 // var s_response = await client.SubscribeQueueToTopicsAsync(new List<string>() { topicArn }, as_client, "http://*****:*****@qq.com"); //} var p_response = await client.PublishAsync(topicArn, "from sns publish message"); Console.WriteLine("success"); Console.ReadLine(); }
private void CreateTopic(RoutingKey topicName, AmazonSQSClient sqsClient, AmazonSimpleNotificationServiceClient snsClient) { //topic re-creation is a no-op, so don't bother to check first as reduces latency var createTopic = snsClient.CreateTopicAsync(new CreateTopicRequest(topicName)).Result; if (!string.IsNullOrEmpty(createTopic.TopicArn)) { _channelTopicARN = createTopic.TopicArn; } else { throw new InvalidOperationException($"Could not create Topic topic: {topicName} on {_awsConnection.Region}"); } }
public async System.Threading.Tasks.Task CreateTopicAsync() { AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(RegionEndpoint.APSoutheast1); // Create an Amazon SNS topic. CreateTopicRequest createTopicRequest = new CreateTopicRequest("MyTopic"); CreateTopicResponse createTopicResponse = await snsClient.CreateTopicAsync(createTopicRequest); // Print the topic ARN. Console.WriteLine("TopicArn: " + createTopicResponse.TopicArn); // Print the request ID for the CreateTopicRequest action. Console.WriteLine("CreateTopicRequest: " + createTopicResponse.ResponseMetadata.RequestId); }
/// <summary> /// /// </summary> /// <param name="topicName"></param> /// <param name="token"></param> /// <returns></returns> public async Task CreateTopicAsync(string topicName, CancellationToken token = default) { using (var client = new AmazonSimpleNotificationServiceClient(accessKey, secretKey, region)) { var req = new CreateTopicRequest(topicName); req.Tags.Add(new Tag() { Key = "Name", Value = "Topic example" }); await client.CreateTopicAsync(req, token); } }
private static async Task SetupAws() { try { Environment.SetEnvironmentVariable("AWS_ACCESS_KEY_ID", "XXX", EnvironmentVariableTarget.Process); Environment.SetEnvironmentVariable("AWS_SECRET_ACCESS_KEY", "XXX", EnvironmentVariableTarget.Process); Environment.SetEnvironmentVariable("AWS_SESSION_TOKEN", "XXX", EnvironmentVariableTarget.Process); Environment.SetEnvironmentVariable("AWS_DEFAULT_REGION", "us-east-1", EnvironmentVariableTarget.Process); var snsClient = new AmazonSimpleNotificationServiceClient(new AmazonSimpleNotificationServiceConfig { ServiceURL = "http://localhost:4575" }); var sqsClient = new AmazonSQSClient(new AmazonSQSConfig { ServiceURL = "http://localhost:4576" }); var topicName = topic.Replace(".", "_"); var topicRequest = new CreateTopicRequest(topicName); var topicResponse = await snsClient.CreateTopicAsync(topicRequest); var queueRequest = new CreateQueueRequest($"{topicName}.queue"); var queueResponse = await sqsClient.CreateQueueAsync(queueRequest); var subscribeRequest = new SubscribeRequest { Endpoint = queueResponse.QueueUrl, TopicArn = topicResponse.TopicArn, Protocol = "sqs", ReturnSubscriptionArn = true, Attributes = new Dictionary <string, string> { ["RawMessageDelivery"] = "true" } }; var subscribeResponse = await snsClient.SubscribeAsync(subscribeRequest); (await snsClient.ListTopicsAsync()).Topics.ForEach(x => Console.WriteLine($"[AWS] Topic: {x.TopicArn}")); (await sqsClient.ListQueuesAsync(new ListQueuesRequest())).QueueUrls.ForEach(x => Console.WriteLine($"[AWS] Queue: {x}")); (await snsClient.ListSubscriptionsAsync(new ListSubscriptionsRequest())).Subscriptions.ForEach(x => Console.WriteLine($"[AWS] Subscription: {x.TopicArn} -> {x.Endpoint}")); } catch (Exception e) { Console.WriteLine($"[AWS] {e.Message}"); } }
/// <summary> /// Method sender to connect and send the topic to azure. /// </summary> /// <typeparam name="T">Type of message to send</typeparam> /// <param name="message">Object of message to send</param> /// <returns>The task of Process topic</returns> public override async Task SendToTopic <T>(T message) { SqsSnsConfiguration config = GetConnection(_queueName); AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(); var topicRequest = new CreateTopicRequest { Name = _queueName }; var topicResponse = snsClient.CreateTopicAsync(topicRequest).Result; await snsClient.PublishAsync(new PublishRequest { TopicArn = topicResponse.TopicArn, Message = message.ToStringCamelCase(), }); }
public async Task <CreateTopicResponse> CreateTopic(string topicName) { var createTopicRequest = new CreateTopicRequest(topicName); var response = await snsClient.CreateTopicAsync(createTopicRequest); if (topics.ContainsKey(topicName)) { topics[topicName] = response.TopicArn; } else { topics.Add(topicName, response.TopicArn); } return(response); }
private async Task <String> GetTopicArn(String topic) { var amazonTopic = await amazonSnsClient.FindTopicAsync(topic); if (amazonTopic != null) { return(amazonTopic.TopicArn); } var createTopicResponse = await amazonSnsClient.CreateTopicAsync(new CreateTopicRequest() { Name = topic }); return(createTopicResponse.TopicArn); }
public async Task <JsonResult> Create([FromBody] CreateClassRoomDto dto) { var currentUser = await _userManager.GetUserAsync(User); var classRoom = new ClassRoom() { Name = dto.Name, TeacherId = currentUser.Id }; _dbContext.ClassRoom.Add(classRoom); _dbContext.SaveChanges(); AmazonSimpleNotificationServiceClient client = new AmazonSimpleNotificationServiceClient("AKIAJLAJIOHNR4Q2EQSQ", "+5t2ISSTpRYQnZomhd+C4S9LqQ8YiRqKjV1YRHLM", Amazon.RegionEndpoint.USWest2); CreateTopicRequest request = new CreateTopicRequest(classRoom.Id.ToString()); CreateTopicResponse ctr = await client.CreateTopicAsync(request); return(Json(classRoom)); }
private void CreateTopicsAndQueues() { var topicAndQueueName = $"toll-amount-threshold-breached-{Guid.NewGuid().ToString().Substring(0,8)}"; var createTopicResponse = _snsClient.CreateTopicAsync(new CreateTopicRequest { Name = topicAndQueueName }).Result; var createQueueResponse = _sqsClient.CreateQueueAsync(new CreateQueueRequest { QueueName = topicAndQueueName }).Result; TopicArn = createTopicResponse.TopicArn; QueueUrl = createQueueResponse.QueueUrl; var subscriptionArn = _snsClient.SubscribeAsync(new SubscribeRequest { TopicArn = createTopicResponse.TopicArn, Endpoint = createQueueResponse.QueueUrl, Protocol = "sqs" }).Result; var r = _snsClient.SetSubscriptionAttributesAsync(subscriptionArn.SubscriptionArn, "RawMessageDelivery", "true").Result; }
public async Task <ISubscription> SubscribeAsync(String topic) { var amazonTopic = await amazonSnsClient.CreateTopicAsync(new CreateTopicRequest() { Name = topic }); var queue = await amazonSqsClient.CreateQueueAsync(new CreateQueueRequest() { QueueName = Guid.NewGuid().ToString() }); var queueAttributes = await amazonSqsClient.GetQueueAttributesAsync(new GetQueueAttributesRequest() { AttributeNames = new List <String>(new String[] { "QueueArn" }), QueueUrl = queue.QueueUrl }); var policy = new Policy() .WithStatements( new Statement(Statement.StatementEffect.Allow) .WithPrincipals(Principal.AllUsers) .WithConditions(ConditionFactory.NewSourceArnCondition(amazonTopic.TopicArn)) .WithResources(new Resource(queueAttributes.QueueARN)) .WithActionIdentifiers(SQSActionIdentifiers.SendMessage)); await amazonSqsClient.SetQueueAttributesAsync(queue.QueueUrl, new Dictionary <String, String>() { ["Policy"] = policy.ToJson() }); await amazonSnsClient.SubscribeAsync(new SubscribeRequest() { Endpoint = queueAttributes.QueueARN, Protocol = "sqs", TopicArn = amazonTopic.TopicArn }); var subscription = amazonSubscriptionFactory.Create(queue.QueueUrl); return(subscription); }
public async Task <IActionResult> AddUserByEmail([FromBody] AddUserDto model) { var user = await _userManager.FindByEmailAsync(model.Email); if (user == null) { return(NotFound()); } _dbContext.UserClass.Add(new UserClass() { ApplicationUserId = user.Id, ClassRoomId = model.ClassRoomId }); _dbContext.SaveChanges(); AmazonSimpleNotificationServiceClient client = new AmazonSimpleNotificationServiceClient("AKIAJLAJIOHNR4Q2EQSQ", "+5t2ISSTpRYQnZomhd+C4S9LqQ8YiRqKjV1YRHLM", Amazon.RegionEndpoint.USWest2); var topicArn = await client.CreateTopicAsync(new CreateTopicRequest(model.ClassRoomId.ToString())); await client.SubscribeAsync(new SubscribeRequest(topicArn.TopicArn, "email", model.Email)); return(Json("All good bro!")); }
private void CreateTopic(RoutingKey topicName, SnsAttributes snsAttributes) { using (var snsClient = new AmazonSimpleNotificationServiceClient(_awsConnection.Credentials, _awsConnection.Region)) { var attributes = new Dictionary <string, string>(); if (snsAttributes != null) { if (!string.IsNullOrEmpty(snsAttributes.DeliveryPolicy)) { attributes.Add("DeliveryPolicy", snsAttributes.DeliveryPolicy); } if (!string.IsNullOrEmpty(snsAttributes.Policy)) { attributes.Add("Policy", snsAttributes.Policy); } } var createTopicRequest = new CreateTopicRequest(topicName) { Attributes = attributes, Tags = new List <Tag> { new Tag { Key = "Source", Value = "Brighter" } } }; //create topic is idempotent, so safe to call even if topic already exists var createTopic = snsClient.CreateTopicAsync(createTopicRequest).Result; if (!string.IsNullOrEmpty(createTopic.TopicArn)) { ChannelTopicArn = createTopic.TopicArn; } else { throw new InvalidOperationException($"Could not create Topic topic: {topicName} on {_awsConnection.Region}"); } } }
static async Task sendSNSMessageAsync() { //Send a message to the SNS event topic var snsClient = new AmazonSimpleNotificationServiceClient(); // Creating the topic request and the topic and response var topicRequest = new CreateTopicRequest { Name = "TestSNSTopic" }; var topicResponse = await snsClient.CreateTopicAsync(topicRequest); var subscribeRequest = new SubscribeRequest() { TopicArn = topicResponse.TopicArn, Protocol = "application", // important to chose the protocol as I am sending notification to applications I have chosen application here. Endpoint = "" }; var reqObj = new Dictionary <String, String>(); reqObj["field1"] = "123"; reqObj["field2"] = "ABC"; PublishRequest publishReq = new PublishRequest() { TargetArn = subscribeRequest.Endpoint, MessageStructure = "json", Message = JsonConvert.SerializeObject(reqObj) }; PublishResponse response = await snsClient.PublishAsync(publishReq); if (response != null && response.MessageId != null) { Console.WriteLine("Notification Send Successfully"); } }
public async Task PublishEventAsync <TEvent>(TEvent @event) { var endpoint = RegionEndpoint.GetBySystemName(_options.Value.Region); var client = new AmazonSimpleNotificationServiceClient(endpoint); Type eventType = typeof(TEvent); AmazonSnsTopicAttribute attr = eventType .GetCustomAttributes(typeof(AmazonSnsTopicAttribute), inherit: false) .OfType <AmazonSnsTopicAttribute>() .FirstOrDefault(); string topicName = attr == null ? eventType.FullName.ToLower().Replace('.', '-') : attr.Name; var createTopicRequest = new CreateTopicRequest(topicName); CreateTopicResponse createTopicResponse = await client.CreateTopicAsync(createTopicRequest); string topicArn = createTopicResponse.TopicArn; string message = _eventSerializer.Serialize(@event); var publishRequest = new PublishRequest(topicArn, message); PublishResponse publishResponse = await client.PublishAsync(publishRequest); }
public async Task <IActionResult> PostToken([FromBody] TokenDto dto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } WebService1SoapClient client = new WebService1SoapClient ( new BasicHttpBinding(BasicHttpSecurityMode.None), new EndpointAddress("http://localhost/SOAPTokenGenerator/TokenGenerator.asmx") ); var token = new Token() { Duration = 30, ClassId = dto.ClassId, CreatedDateTime = DateTime.Now, TokenValue = client.GenerateToken() }; _context.Token.Add(token); _context.SaveChanges(); AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient("AKIAJLAJIOHNR4Q2EQSQ", "+5t2ISSTpRYQnZomhd+C4S9LqQ8YiRqKjV1YRHLM", Amazon.RegionEndpoint.USWest2); var topicArn = await snsClient.CreateTopicAsync(new CreateTopicRequest(dto.ClassId.ToString())); String msg = "Your token for todays class is: " + token.TokenValue; PublishRequest publishRequest = new PublishRequest(topicArn.TopicArn, msg); var publishResult = await snsClient.PublishAsync(publishRequest); //print MessageId of message published to SNS topic return(CreatedAtAction("GetToken", new { id = token.Id }, token)); }
public async Task RegisterUserNotifications() { string deviceToken = GetDeviceToken(); var notificationsSubscriptions = GetNotificationsSubscriptions(); if (string.IsNullOrEmpty(deviceToken)) { return; } var credentials = new BasicAWSCredentials( AppSettings.Instance.AwsKey, AppSettings.Instance.AwsSecret ); var client = new AmazonSimpleNotificationServiceClient( credentials, Amazon.RegionEndpoint.EUWest1 ); if (string.IsNullOrEmpty(notificationsSubscriptions.ApplicationEndPoint) || notificationsSubscriptions.DeviceToken != deviceToken) { // ********************************************** // de-register old endpoint and all subscriptions if (!string.IsNullOrEmpty(notificationsSubscriptions.ApplicationEndPoint)) { try { var response = await client.DeleteEndpointAsync(new DeleteEndpointRequest { EndpointArn = notificationsSubscriptions.ApplicationEndPoint }); if (response.HttpStatusCode != System.Net.HttpStatusCode.OK) { ShowAlert("Debug", $"Error eliminando endpoint: {response.HttpStatusCode}"); } } catch { /*Silent error in case endpoint doesn´t exist */ } notificationsSubscriptions.ApplicationEndPoint = null; foreach (var sub in notificationsSubscriptions.Subscriptions) { try { await client.UnsubscribeAsync(sub.Value); } catch { /*Silent error in case endpoint doesn´t exist */ } } notificationsSubscriptions.Subscriptions.Clear(); } // register with SNS to create a new endpoint var endPointResponse = await client.CreatePlatformEndpointAsync( new CreatePlatformEndpointRequest { Token = deviceToken, PlatformApplicationArn = Device.RuntimePlatform == Device.iOS ? AppSettings.Instance.AwsPlatformApplicationArnIOS : AppSettings.Instance.AwsPlatformApplicationArnAndroid } ); if (endPointResponse.HttpStatusCode != System.Net.HttpStatusCode.OK) { ShowAlert("Debug", $"Error registrando endpoint: {endPointResponse.HttpStatusCode}, {endPointResponse.ResponseMetadata}"); } // Save device token and application endpoint created notificationsSubscriptions.DeviceToken = deviceToken; notificationsSubscriptions.ApplicationEndPoint = endPointResponse.EndpointArn; } // Retrieve subscriptions var subscriptions = await AudioLibrary.Instance.GetUserSubscriptions(false); if (subscriptions == null) { subscriptions = new UserSubscriptions { Subscriptions = new List <Models.Api.Subscription>() } } ; // Register non existings subscriptions var subscriptionsCodes = subscriptions.Subscriptions.Select(s => s.Code).ToList(); foreach (var code in subscriptionsCodes) { if (!notificationsSubscriptions.Subscriptions.ContainsKey(code)) { var topicArn = AppSettings.Instance.AwsTopicArn; topicArn += string.IsNullOrEmpty(code) ? "" : $"-{code}"; if (!await TopicExists(topicArn, client)) { var topicResponse = await client.CreateTopicAsync(new CreateTopicRequest { Name = $"{AppSettings.Instance.AwsTopicName}-{code}" }); if (topicResponse.HttpStatusCode != System.Net.HttpStatusCode.OK) { ShowAlert("Debug", $"Error creando topic: {topicResponse.HttpStatusCode}, {topicResponse.ResponseMetadata}"); } topicArn = topicResponse.TopicArn; } // Subscribe var subscribeResponse = await client.SubscribeAsync(new SubscribeRequest { Protocol = "application", Endpoint = notificationsSubscriptions.ApplicationEndPoint, TopicArn = topicArn }); if (subscribeResponse.HttpStatusCode != System.Net.HttpStatusCode.OK) { ShowAlert("Debug", $"Error creando suscripción: {subscribeResponse.HttpStatusCode}, {subscribeResponse.ResponseMetadata}"); } // Add to the list notificationsSubscriptions.Subscriptions.Add(code, subscribeResponse.SubscriptionArn); } } // Remove subscriptions not in user list var currentSubscriptions = notificationsSubscriptions.Subscriptions.ToList(); foreach (var subs in currentSubscriptions) { if (!subscriptionsCodes.Contains(subs.Key)) { try { await client.UnsubscribeAsync(subs.Value); } catch { /*Silent error in case endpoint doesn´t exist */ } notificationsSubscriptions.Subscriptions.Remove(subs.Key); } } // Save notifications subscriptions await SaveNotificationsSubscriptions(notificationsSubscriptions); }