public override void Dispatch(MessageDelivery messageDelivery)
{
PublishRequest pr = new PublishRequest(messageDelivery.ContractType, messageDelivery.Action, messageDelivery.Message, messageDelivery.Context);
using (TransactionScope ts = new TransactionScope())
{
foreach (MessageDelivery md in determineDeliveries(pr))
{
DeliveryCore deliveryCore = SelectDeliveryCore(md);
deliveryCore.Deliver(md);
}
ts.Complete();
}
}
List<MessageDelivery> determineDeliveries(PublishRequest publishRequest)
{
List<MessageDelivery> messageDeliveries = new List<MessageDelivery>();
List<SubscriptionEndpoint> unhandledFilters = new List<SubscriptionEndpoint>();
bool handled = false;
foreach (SubscriptionEndpoint subscription in _getSubscriptions())
{
if (!subscription.IsExpired)
{
bool include;
if (subscription.Filter is UnhandledMessageFilter)
{
include = false;
if (subscription.Filter.Include(publishRequest))
{
unhandledFilters.Add(subscription);
}
}
else
{
include = subscription.Filter == null || subscription.Filter.Include(publishRequest);
}
if (include)
{
MessageDelivery delivery = new MessageDelivery(subscription.Id, publishRequest.ContractType, publishRequest.Action, publishRequest.Message, Runtime.MaxRetries, publishRequest.Context);
messageDeliveries.Add(delivery);
handled = true;
}
}
}
// if unhandled, send to subscribers of unhandled messages
if (!handled)
{
foreach (SubscriptionEndpoint subscription in unhandledFilters)
{
if (!subscription.IsExpired)
{
MessageDelivery delivery = new MessageDelivery(subscription.Id, publishRequest.ContractType, publishRequest.Action, publishRequest.Message, Runtime.MaxRetries, publishRequest.Context);
messageDeliveries.Add(delivery);
}
}
}
return messageDeliveries;
}
/// <summary>
/// Adds a message to the topic. Returns NOT_FOUND if the topic does notexist.
/// Documentation https://developers.google.com/pubsub/v1beta1a/reference/topics/publish
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated Pubsub service.</param>
/// <param name="body">A valid Pubsub v1beta1a body.</param>
/// <returns>EmptyResponse</returns>
public static Empty Publish(PubsubService service, PublishRequest body)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (body == null)
{
throw new ArgumentNullException("body");
}
// Make the request.
return(service.Topics.Publish(body).Execute());
}
catch (Exception ex)
{
throw new Exception("Request Topics.Publish failed.", ex);
}
}
public async Task Handle(S3Event s3Event, ILambdaContext context)
{
if (!s3Event.Records.Any())
{
context.Logger.LogLine("No records");
}
foreach (var record in s3Event.Records)
{
try
{
context.Logger.LogLine($"Started publish request for {record.S3.Object.Key} to {SNS_ARN}");
var publishRequest = new PublishRequest(SNS_ARN, record.S3.Object.Key);
var publishResponse = await _snsClient.PublishAsync(publishRequest).ConfigureAwait(false);
context.Logger.LogLine($"Published message for {record.S3.Object.Key}");
}
catch (Exception e)
{
context.Logger.LogLine($"Failed to publish SNS notification for {record.S3.Object.Key} with error: {e.Message}");
}
}
}
public async Task <bool> PublishEmailMessage(string topicArn, string message)
{
var request = new PublishRequest
{
Message = message,
TopicArn = topicArn
};
try
{
var response = await _sns.PublishAsync(request);
Console.WriteLine("Message sent");
Console.WriteLine(response.MessageId);
}
catch (Exception ex)
{
Console.WriteLine("Caught exception publishing request:");
Console.WriteLine(ex.Message);
}
return(true);
}
public static void AddMutation <T>(this PublishRequest request, T oldImage, T newImage, string eventType = null) where T : class, new()
{
var model = new MutationModel <T>
{
OldImage = oldImage,
NewImage = newImage,
EventType = eventType
};
request.Message = JsonConvert.SerializeObject(model);
var diff = model.Diff();
request.MessageAttributes.Add(
Constants.UpdatedProperties,
new MessageAttributeValue
{
DataType = "String.Array",
StringValue = JsonConvert.SerializeObject(diff)
}
);
}
public void sendSms(string phoneNumber, string messageBody, out string messageid, out string messagestatus)
{
string AWSAccessKeyId = ConfigurationManager.AppSettings["AWSAccessKeyId"].ToString();
string AWSSecretKey = ConfigurationManager.AppSettings["AWSSecretKey"].ToString();
var sns = new AmazonSimpleNotificationServiceClient(AWSAccessKeyId, AWSSecretKey, Amazon.RegionEndpoint.USEast1);
var smsAttributes = new Dictionary <string, MessageAttributeValue>();
MessageAttributeValue sMSType = new MessageAttributeValue();
sMSType.DataType = "String";
sMSType.StringValue = "Transactional";
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken token = source.Token;
smsAttributes.Add("AWS.SNS.SMS.SMSType", sMSType);
PublishRequest publishRequest = new PublishRequest();
publishRequest.Message = "This is 2nd sample message";
publishRequest.MessageAttributes = smsAttributes;
publishRequest.PhoneNumber = "received phone no with + and country code";
PublishResponse message = sns.Publish(new PublishRequest()
{
PhoneNumber = phoneNumber, MessageAttributes = smsAttributes, Message = messageBody, Subject = "NeeoApp Activation"
});
messageid = message.MessageId;
messagestatus = message.HttpStatusCode.ToString();
}
public async Task ItShouldPublishASingleMessageToSns()
{
var publishRequest = new PublishRequest("topic-arn", "sns-message");
var publishResult = new PublishResponse {
MessageId = "message-id"
};
var snsService = Substitute.For <IAmazonSimpleNotificationService>();
snsService.PublishAsync(Arg.Any <PublishRequest>())
.Returns(publishResult);
var(probe, task) = this.SourceProbe <string>()
.Via(SnsPublisher.PlainFlow("topic-arn", snsService))
.ToMaterialized(Sink.Seq <PublishResponse>(), Keep.Both)
.Run(this._materializer);
probe.SendNext("sns-message").SendComplete();
var actualResult = (await task).FirstOrDefault();
actualResult.Should().Be(publishResult);
await snsService.Received(1).PublishAsync(Arg.Any <PublishRequest>());
}
private SkillResponse GetOrderResponse(IntentRequest request)
{
if (request.DialogState != DialogState.Completed)
{
return(ResponseBuilder.DialogDelegate());
}
if (request.Intent.ConfirmationStatus == ConfirmationStatus.Confirmed && int.TryParse(request.Intent.Slots["number"]?.Value, out var number))
{
var snsClient = new AmazonSimpleNotificationServiceClient();
var snsPublishRequest = new PublishRequest
{
TopicArn = Environment.GetEnvironmentVariable("SNS_TOPIC"),
Message = $"New beer order. Amount: {number}"
};
snsClient.PublishAsync(snsPublishRequest).Wait();
var plainText = new PlainText($"{number} {(number > 1 ? "beers" : "beer")} ordered.");
var speech = new Speech(plainText, Foley.GlassesClick02);
return(ResponseBuilder.Tell(speech));
}
return(ResponseBuilder.Empty());
}
public async Task PublishAsync_RequestObject()
{
// Snippet: PublishAsync(PublishRequest,CallSettings)
// Create client
PublisherClient publisherClient = await PublisherClient.CreateAsync();
// Initialize request argument(s)
PublishRequest request = new PublishRequest
{
TopicAsTopicName = new TopicName("[PROJECT]", "[TOPIC]"),
Messages =
{
new PubsubMessage
{
Data = ByteString.CopyFromUtf8(""),
},
},
};
// Make the request
PublishResponse response = await publisherClient.PublishAsync(request);
// End snippet
}
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 SendAsync(TransportMessage message, ITransactionContext context)
{
var snsClient = _amazonInternalSettings.CreateSnsClient(context);
var sqsMessage = new AmazonTransportMessage(message.Headers, StringHelper.GetBody(message.Body));
var msg = _amazonInternalSettings.MessageSerializer.Serialize(sqsMessage);
var pubRequest = new PublishRequest(_destinationAddress, msg);
var messageAttributeValues = context.GetOrNull <IDictionary <string, MessageAttributeValue> >(SnsAttributeMapperOutBoundStep.SnsAttributeKey) ?? new Dictionary <string, MessageAttributeValue>();
foreach (var messageAttributeValue in messageAttributeValues)
{
pubRequest.MessageAttributes.Add(messageAttributeValue.Key, messageAttributeValue.Value);
}
var publishResponse = await snsClient.PublishAsync(pubRequest);
if (publishResponse.HttpStatusCode != HttpStatusCode.OK)
{
throw new SnsRebusException($"Error publishing message to topic {_destinationAddress}.", publishResponse.CreateAmazonExceptionFromResponse());
}
}
/// <summary>
/// Sends the SMS message passed in the text parameter to the phone number
/// in phoneNum.
/// </summary>
/// <param name="phoneNum">The ten-digit phone number to which the text
/// message will be sent.</param>
/// <param name="text">The text of the message to send.</param>
/// <returns></returns>
public async Task SendTextMessageAsync(string phoneNum, string text)
{
if (string.IsNullOrEmpty(phoneNum) || string.IsNullOrEmpty(text))
{
return;
}
// Now actually send the message.
var request = new PublishRequest
{
Message = text,
PhoneNumber = phoneNum
};
try
{
var response = await snsClient.PublishAsync(request);
}
catch (Exception ex)
{
Console.WriteLine($"Error sending message: {ex}");
}
}
public override async Task <PublishResponse> PublishAsync(PublishRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
if (string.IsNullOrEmpty(request.Subject))
{
request.Subject = "#"; // To allow for automatic http forwarding
}
if (request.MessageAttributes.ContainsKey(Constants.DelaySeconds) && int.Parse(request.MessageAttributes[Constants.DelaySeconds].StringValue) > 0)
{
if (BytesHelper.TooLarge(request, 32000))
{
await _s3Client.PubSubS3Query(request, _messageDeliverySettings, cancellationToken);
}
return(await _stepFunctions.PublishAsync(request, _messageDeliverySettings.StateMachine, cancellationToken));
}
if (BytesHelper.TooLarge(request))
{
await _s3Client.PubSubS3Query(request, _messageDeliverySettings, cancellationToken);
}
return(await base.PublishAsync(request, cancellationToken));
}
/**
* Convert PublishRequest to name value pairs
*/
private static IDictionary<string, string> ConvertPublish(PublishRequest request)
{
IDictionary<string, string> parameters = new Dictionary<string, string>();
parameters["Action"] = "Publish";
if (request.IsSetTopicArn())
{
parameters["TopicArn"] = request.TopicArn;
}
if (request.IsSetMessage())
{
parameters["Message"] = request.Message;
}
if (request.IsSetMessageStructure())
{
parameters["MessageStructure"] = request.MessageStructure;
}
if (request.IsSetSubject())
{
parameters["Subject"] = request.Subject;
}
return parameters;
}
private static void NotifyDriverOfViolation(List <DMVDatabase> listOfEntries)
{
AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(Amazon.RegionEndpoint.USEast1);
foreach (DMVDatabase driver in listOfEntries)
{
Console.WriteLine("Has been notified: " + driver.HasBeenNotified + " Has violation: " + driver.HasViolation);
if (!driver.HasBeenNotified && driver.HasViolation)
{
PublishRequest pubRequest = new PublishRequest
{
PhoneNumber = driver.Phone,
Message = driver.Name + ", you have a ticket that needs to be paid"
};
snsClient.PublishAsync(pubRequest);
Console.WriteLine("Request to notify by email sent");
driver.HasBeenNotified = true;
}
//System.Threading.Thread.Sleep(5000);
}
}
public async Task Publish <T>(T message, string topic)
{
string stringMessage = JsonConvert.SerializeObject(message, _serializerSettings);
PublishRequest publishRequest = new PublishRequest(topic, stringMessage)
{
MessageAttributes = new Dictionary <string, MessageAttributeValue>
{
{ Type, new MessageAttributeValue
{
StringValue = message.GetType().Name,
DataType = "String"
} },
{ Version, new MessageAttributeValue
{
StringValue = GetVersion(message.GetType().GetTypeInfo().Assembly.GetName().Version),
DataType = "String"
} }
}
};
await _simpleNotificationService.PublishAsync(publishRequest);
}
private void SendSnsNotification(UserModel model, string id, string stationId)
{
UserSnsModel snsModel = new UserSnsModel
{
UserId = id,
PhoneNumber = model.PhoneNumber,
StationId = stationId,
EmailAddress = model.EmailAddress
};
Console.WriteLine("Starting creation of SnS Lambda Topic...");
Console.WriteLine(string.Format("Input parameters: {0}", snsModel.ToString()));
string payload = JsonConvert.SerializeObject(snsModel);
Console.WriteLine(string.Format("Serialized payload: {0}", payload));
PublishRequest publishRequest = new PublishRequest(SnSLambdaTopic, payload);
snsClient.Publish(publishRequest);
Console.WriteLine("Succesfully published message.");
}
public NotificationResponse Send(NotificationRequest notificationRequest)
{
NotificationResponse notificationResponse = new NotificationResponse();
using (var snsService = new AmazonSimpleNotificationServiceClient(SNSConfiguration.AccessKeyId, SNSConfiguration.AccessSecretKey, SNSConfiguration.Region))
{
var attributes = new Dictionary <string, MessageAttributeValue>();
attributes.Add("AWS.SNS.SMS.SenderID", new MessageAttributeValue()
{
StringValue = notificationRequest.SenderId, DataType = "String"
});
attributes.Add("AWS.SNS.SMS.SMSType", new MessageAttributeValue()
{
StringValue = notificationRequest.Type.GetDescription(), DataType = "String"
});
var request = new PublishRequest()
{
PhoneNumber = $"+{notificationRequest.PhoneNumber}",
Message = notificationRequest.TextMessage,
MessageAttributes = attributes
};
var result = snsService.PublishAsync(request).Result;
if (result.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
notificationResponse.IsValid = true;
}
else
{
notificationResponse.Errors.Add("SMS failed!");
notificationResponse.IsValid = false;
}
}
return(notificationResponse);
}
public override async Task <PublishReply> PublishMessage(PublishRequest request, ServerCallContext context)
{
try
{
var message = new Message(request.Bank, request.Content);
await _messageRepository.Add(message, context.CancellationToken);
Console.WriteLine($"Received: {request.Bank}, {request.Content}");
return(await Task.FromResult(new PublishReply
{
IsSuccess = true
}));
}
catch (Exception e)
{
Console.WriteLine($"Publishing gRPC message: {e.Message}");
return(await Task.FromResult(new PublishReply
{
IsSuccess = false
}));
}
}
/// <summary>Snippet for PublishAsync</summary>
public async Task PublishAsync_RequestObject()
{
// Snippet: PublishAsync(PublishRequest,CallSettings)
// Additional: PublishAsync(PublishRequest,CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
PublishRequest request = new PublishRequest
{
TopicAsTopicName = new TopicName("[PROJECT]", "[TOPIC]"),
Messages =
{
new PubsubMessage
{
Data = ByteString.Empty,
},
},
};
// Make the request
PublishResponse response = await publisherServiceApiClient.PublishAsync(request);
// End snippet
}
private bool SendMessage(string message)
{
var topicArn = _configurationManager.GetSnsTopic();
LambdaLogger.Log($"SNS topic is :{topicArn}");
var client = new AmazonSimpleNotificationServiceClient();
var request = new PublishRequest
{
Message = message,
TopicArn = topicArn
};
try
{
LambdaLogger.Log($"Message is {message} and it is ready to send through SNS:");
var response = client.PublishAsync(request);
if (response.Result.HttpStatusCode != HttpStatusCode.OK)
{
LambdaLogger.Log(
$"Unable to publish message. AWS responded with status code: {response.Result.HttpStatusCode} and metadata:{response.Result.ResponseMetadata}.");
return(false);
}
LambdaLogger.Log("Message send through SNS:");
return(true);
}
catch (Exception ex)
{
LambdaLogger.Log("Caught exception publishing request:");
LambdaLogger.Log(ex.Message);
}
return(false);
}
/// <summary>
/// Asynchronously sends the specified message.
/// </summary>
/// <param name="message">The message to send.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public Task SendAsync(SenderMessage message, CancellationToken cancellationToken)
{
if (message is null)
{
throw new ArgumentNullException(nameof(message));
}
if (message.OriginatingSystem is null)
{
message.OriginatingSystem = "SNS";
}
var publishMessage = new PublishRequest(TopicArn, message.StringPayload);
foreach (var header in message.Headers)
{
publishMessage.MessageAttributes[header.Key] =
new MessageAttributeValue {
StringValue = header.Value.ToString(), DataType = "String"
};
}
return(SnsClient.PublishAsync(publishMessage, cancellationToken));
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <string> FunctionHandler(ILambdaContext context)
{
var client = GetStepFunctionsClient();
var snsClient = new AmazonSimpleNotificationServiceClient(bucketRegion);;
var req = new GetActivityTaskRequest()
{
ActivityArn = "arn:aws:states:us-east-2:341189667252:activity:ApproveRequest"
};
var response = await client.GetActivityTaskAsync(req);
if (response == null || response.Input == null)
{
return("No activities received after 60 seconds.");
}
var approveData = JsonSerializer.Deserialize <ApproveData>(response.Input);
var token = WebUtility.UrlEncode(response.TaskToken);
var emailBody = "can you approve? ," + "https://8tj14zkhq2.execute-api.us-east-2.amazonaws.com/respond/succeed?taskToken=" + token + " or reject: " + "https://8tj14zkhq2.execute-api.us-east-2.amazonaws.com/respond/fail?taskToken=" + token;
var pubReq = new PublishRequest();
pubReq.TopicArn = "arn:aws:sns:us-east-2:341189667252:approval-request";
pubReq.Message = emailBody;
pubReq.Subject = "Need your confirmation!";
try
{
await snsClient.PublishAsync(pubReq);
}
catch (AmazonSimpleNotificationServiceException ex)
{
return("error in sending notification:" + ex.Message);
}
return("worker completed!");
}
public Heartbeat(Guid heartbeatId, TimeSpan interval, PublishRequest heartbeatRequest, PublishRequest successRequest, PublishRequest failureRequest, MessageFilter responseFilter, TimeSpan timeout)
: this()
{
if (failureRequest == null)
{
throw new ArgumentNullException("failureRequest");
}
if (heartbeatRequest == null)
{
throw new ArgumentNullException("heartbeatRequest");
}
if (responseFilter == null)
{
throw new ArgumentNullException("responseFilter");
}
if (interval == TimeSpan.Zero)
{
throw new ArgumentException("Interval must not be zero.");
}
if (timeout == TimeSpan.Zero)
{
throw new ArgumentException("Timeout must not be zero.");
}
HeartbeatId = heartbeatId;
Interval = interval;
HearbeatRequest = heartbeatRequest;
SuccessRequest = successRequest;
FailureRequest = failureRequest;
ResponseFilter = responseFilter;
Timeout = timeout;
}
public string SendMessage(IMessageRequest request)
{
PublishRequest publishRequest = new PublishRequest();
bool valid = Helpers.IsPhoneNumberValid(request.PhoneNumber);
if (valid)
{
try
{
string phone = Helpers.GetPhoneDigits(request.PhoneNumber);
publishRequest.Message = request.Message;
publishRequest.PhoneNumber = $"+1{phone}";
PublishResponse response = this.snsService.PublishAsync(publishRequest).Result;
return(response.MessageId);
}
catch (Exception ex) {
throw ex;
}
}
else
{
throw new ArgumentException($"{request.PhoneNumber} is not a valid phone format");
}
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="evnt"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task <string> FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context)
{
var client = new AmazonSimpleNotificationServiceClient();
context.Logger.LogLine($"Event Received by Lambda Function from {dynamoEvent}");
context.Logger.LogLine($"Beginning to process {dynamoEvent.Records.Count} records...");
foreach (var record in dynamoEvent.Records)
{
var dbRecord = record.Dynamodb.NewImage;
if (dbRecord != null)
{
var itemStore = dbRecord["Store"].S;
var itemName = dbRecord["Item"].S;
var itemStock = Convert.ToInt32(dbRecord["Count"].N);
var message = itemStore + " is out of stock of " + itemName;
context.Logger.LogLine($"Records {itemStore} - {itemName} - {itemStock.ToString()}");
if (itemStock == 0)
{
var allTopics = await client.ListTopicsAsync();
var NoStockTopic = allTopics.Topics.FirstOrDefault(x => x.TopicArn.Contains("NoStock")).TopicArn;
var request = new PublishRequest {
TopicArn = NoStockTopic,
Message = message,
Subject = "Inventory Alert!"
};
client.PublishAsync(request).Wait();
}
}
}
return("OK");
}
/// <summary>
/// 消息发布
/// </summary>
public void PublishWithMessage()
{
// 设置请求对象
PublishRequest request = new PublishRequest
{
TopicUrn = "urn:smn:cn-north-1:cffe4fc4c9a54219b60dbaf7b586e132:create_by_zhangyx_test_csharp",
Subject = "hello csharp",
Message = "a test messag from csharp sdk"
};
try
{
// 发送请求并返回响应
PublishResponse response = smnClient.SendRequest(request);
string result = response.MessageId;
Console.WriteLine("{0}", result);
Console.ReadLine();
}
catch (Exception e)
{
// 处理异常
Console.WriteLine("{0}", e.Message);
}
}
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 PublishAsync(Message message)
{
var messageToSend = _serialisationRegister.Serialise(message, serializeForSnsPublishing: true);
var messageType = message.GetType().Name;
var request = new PublishRequest
{
TopicArn = Arn,
Subject = messageType,
Message = messageToSend
};
try
{
await Client.PublishAsync(request);
_eventLog.LogInformation($"Published message: '{messageType}' with content {messageToSend}");
}
catch (Exception ex)
{
throw new PublishException(
$"Failed to publish message to SNS. TopicArn: {request.TopicArn} Subject: {request.Subject} Message: {request.Message}",
ex);
}
}
/// <summary>
///
/// </summary>
/// <param name="pRequestMessage"></param>
/// <returns></returns>
public PublishResponse RePublishSurvey(PublishRequest pRequest)
{
try
{
PublishResponse result = new PublishResponse(pRequest.RequestId);
Epi.Web.Enter.Interfaces.DataInterfaces.ISurveyInfoDao SurveyInfoDao = new EFwcf.EntitySurveyInfoDao();
Epi.Web.Enter.Interfaces.DataInterfaces.IOrganizationDao OrganizationDao = new EFwcf.EntityOrganizationDao();
Epi.Web.BLL.Publisher Implementation = new Epi.Web.BLL.Publisher(SurveyInfoDao, OrganizationDao);
SurveyInfoBO surveyInfoBO = Mapper.ToBusinessObject(pRequest.SurveyInfo);
SurveyRequestResultBO surveyRequestResultBO = Implementation.RePublishSurvey(surveyInfoBO);
result.PublishInfo = Mapper.ToDataTransferObject(surveyRequestResultBO);
return(result);
}
catch (Exception ex)
{
CustomFaultException customFaultException = new CustomFaultException();
customFaultException.CustomMessage = ex.Message;
customFaultException.Source = ex.Source;
customFaultException.StackTrace = ex.StackTrace;
customFaultException.HelpLink = ex.HelpLink;
throw new FaultException <CustomFaultException>(customFaultException);
}
}
/// <summary>Execute NAnt task</summary>
protected override void ExecuteTask()
{
var isArnSet = !String.IsNullOrEmpty(ARN);
// Ensure our topic exists
if (!DoesTopicExist())
{
CreateTopic();
}
// Ensure the ARN is set
if (!isArnSet)
{
Project.Log(Level.Info, "Please set the SNS ARN!");
return;
}
Project.Log(Level.Info, "Sending message to '{0}'.", Topic);
using (Client) {
try {
var request = new PublishRequest {
TopicArn = ARN,
Subject = Subject,
Message = Message
};
var response = Client.Publish(request);
if (response.IsSetPublishResult())
{
var result = response.PublishResult;
Project.Log(Level.Info, "Successfully published message ID: {0}", result.MessageId);
return;
}
} catch (AmazonS3Exception ex) {
ShowError(ex);
}
}
Project.Log(Level.Error, "Error publishing message!");
}
public async Task SendAlert(int teamId, string title, string subtitle)
{
var endpoints = await findTeamEndpoints(teamId);
foreach (var endpointArn in endpoints)
{
var request = new PublishRequest()
{
TargetArn = endpointArn,
Message = createNotification(title, subtitle),
MessageStructure = "json"
};
await _client.PublishAsync(request);
request = new PublishRequest()
{
TargetArn = endpointArn,
Message = createDataMessage(title),
MessageStructure = "json"
};
_log.Info($"Sending alert for team {teamId}\n");
await _client.PublishAsync(request);
}
}
/// <summary>
/// Initializes the message with the body.
/// </summary>
public PublishMessage(PublishRequest PublishRequest)
{
this.PublishRequest = PublishRequest;
}
public override bool Include(PublishRequest request)
{
SendMessageRequest r = request.Message as SendMessageRequest;
if (r != null)
{
return String.Compare(r.To, To, true) == 0;
}
return false;
}
protected void Publish(Type contractType, string action, object message)
{
Dictionary<MessageDeliveryContextKey, object> context = new Dictionary<MessageDeliveryContextKey, object>();
// Add security context to the message if it is available
if (System.ServiceModel.OperationContext.Current.ServiceSecurityContext != null)
{
WindowsIdentity identity = System.ServiceModel.OperationContext.Current.ServiceSecurityContext.WindowsIdentity;
if (identity != null && identity.IsAuthenticated)
{
context.Add(MessageDelivery.WindowsIdentityNameKey, identity.Name);
context.Add(MessageDelivery.WindowsIdentityImpersonationLevelKey, identity.ImpersonationLevel.ToString());
}
IIdentity primaryIdentity = System.ServiceModel.OperationContext.Current.ServiceSecurityContext.PrimaryIdentity;
if (primaryIdentity != null)
{
context.Add(MessageDelivery.PrimaryIdentityNameKey, primaryIdentity.Name);
//context.Add(MessageDelivery.PrimaryIdentityImpersonationLevelKey, primaryIdentity);
}
}
PublishRequest pr = new PublishRequest(contractType, action, message, new MessageDeliveryContext(context));
Runtime.PublishOneWay(pr);
}
protected override PublishRequest Transform(PublishRequest request)
{
return (PublishRequest)Script.ExecuteWithVariables(new Dictionary<string, object>() { { "request", request } });
}
public override bool Include(PublishRequest request)
{
return true;
}
public override bool Include(PublishRequest request)
{
return (bool)Script.ExecuteWithVariables(new Dictionary<string, object>() { { "request", request } });
}
/// <summary>
/// Begins an asynchronous invocation of the Publish service.
/// </summary>
public IAsyncResult BeginPublish(
RequestHeader requestHeader,
SubscriptionAcknowledgementCollection subscriptionAcknowledgements,
AsyncCallback callback,
object asyncState)
{
PublishRequest request = new PublishRequest();
request.RequestHeader = requestHeader;
request.SubscriptionAcknowledgements = subscriptionAcknowledgements;
UpdateRequestHeader(request, requestHeader == null, "Publish");
if (UseTransportChannel)
{
return TransportChannel.BeginSendRequest(request, callback, asyncState);
}
return InnerChannel.BeginPublish(new PublishMessage(request), callback, asyncState);
}
/// <summary>
/// Invokes the Publish service.
/// </summary>
public virtual ResponseHeader Publish(
RequestHeader requestHeader,
SubscriptionAcknowledgementCollection subscriptionAcknowledgements,
out uint subscriptionId,
out UInt32Collection availableSequenceNumbers,
out bool moreNotifications,
out NotificationMessage notificationMessage,
out StatusCodeCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
PublishRequest request = new PublishRequest();
PublishResponse response = null;
request.RequestHeader = requestHeader;
request.SubscriptionAcknowledgements = subscriptionAcknowledgements;
UpdateRequestHeader(request, requestHeader == null, "Publish");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (PublishResponse)genericResponse;
}
else
{
PublishResponseMessage responseMessage = InnerChannel.Publish(new PublishMessage(request));
if (responseMessage == null || responseMessage.PublishResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.PublishResponse;
ValidateResponse(response.ResponseHeader);
}
subscriptionId = response.SubscriptionId;
availableSequenceNumbers = response.AvailableSequenceNumbers;
moreNotifications = response.MoreNotifications;
notificationMessage = response.NotificationMessage;
results = response.Results;
diagnosticInfos = response.DiagnosticInfos;
}
finally
{
RequestCompleted(request, response, "Publish");
}
return response.ResponseHeader;
}
