private Task MessageQueueLoop()
{
var cancelToken = _cancelToken;
int interval = Config.MessageQueueInterval;
return(Task.Run(async() =>
{
Message msg;
while (!cancelToken.IsCancellationRequested)
{
while (_pendingMessages.TryDequeue(out msg))
{
bool hasFailed = false;
SendMessageResponse response = null;
try
{
response = await _api.SendMessage(msg.Channel.Id, msg.RawText, msg.Mentions.Select(x => x.Id), msg.Nonce, msg.IsTTS).ConfigureAwait(false);
}
catch (WebException) { break; }
catch (HttpException) { hasFailed = true; }
if (!hasFailed)
{
_messages.Remap(msg.Id, response.Id);
msg.Id = response.Id;
msg.Update(response);
}
msg.IsQueued = false;
msg.HasFailed = hasFailed;
RaiseMessageSent(msg);
}
await Task.Delay(interval).ConfigureAwait(false);
}
}));
}
static void Main(string[] args)
{
SendMessageRequest req = new SendMessageRequest.Builder()
.SetAccessToken("test_token")
.SetFrom("jackie")
.SetTo("good")
.SetText("Hello every one,I'm Jackie Lee.")
.SetTopic("STN Discuss")
.Build();
byte[] buffer = req.ToByteArray();
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:8080/");
ByteArrayContent content = new ByteArrayContent(buffer);
content.Headers.Add("Content-Type", "application/octet-stream");
Stream respStream = client.PostAsync("mars/sendmessage", content).Result.Content.ReadAsStreamAsync().Result;
SendMessageResponse resp = SendMessageResponse.ParseFrom(respStream);
Console.Read();
}
protected override void ProcessResponseHandlers(AmazonWebServiceResponse response, IRequest request, IWebResponseData webResponseData)
{
base.ProcessResponseHandlers(response, request, webResponseData);
ReceiveMessageResponse receiveMessageResponse = response as ReceiveMessageResponse;
if (receiveMessageResponse != null)
{
ValidateReceiveMessage(receiveMessageResponse);
}
SendMessageResponse sendMessageResponse = response as SendMessageResponse;
SendMessageRequest sendMessageRequest = request.OriginalRequest as SendMessageRequest;
if (sendMessageRequest != null && sendMessageResponse != null)
{
ValidateSendMessage(sendMessageRequest, sendMessageResponse);
}
SendMessageBatchRequest sendMessageBatchRequest = request.OriginalRequest as SendMessageBatchRequest;
SendMessageBatchResponse sendMessageBatchResponse = response as SendMessageBatchResponse;
if (sendMessageBatchRequest != null && sendMessageBatchResponse != null)
{
ValidateSendMessageBatch(sendMessageBatchRequest, sendMessageBatchResponse);
}
}
public async Task <JsonResult> GetTaskItemAssign(Guid taskId, string action)
{
TaskItemAssignModel model = new TaskItemAssignModel();
try
{
TaskItemAssignDto dto = null;
if (action == "Process")
{
dto = await _taskItemAssignService.GetByAssignTo(taskId, CurrentUser.Id);
}
if (action == "Appraise" || action == "Extend")
{
dto = await _taskItemAssignService.GetByAssignBy(taskId, CurrentUser.Id);
}
if (dto == null)
{
var rs = SendMessageResponse.CreateFailedResponse("AccessDenied");
return(Json(rs, JsonRequestBehavior.AllowGet));
}
model = _mapper.Map <TaskItemAssignModel>(dto);
model.TaskItemModel = _mapper.Map <TaskItemModel>(dto.TaskItem);
}
catch (Exception ex)
{
_loggerServices.WriteError(ex.ToString());
}
return(Json(model, JsonRequestBehavior.AllowGet));
}
public static async Task <SendMessageResponse> PostMessageAsync(string accessToken, string userId, string message)
{
var url = $"https://graph.facebook.com/v2.5/{userId}/feed";
var postbody = $"access_token={accessToken}&" +
"format=json&" +
$"message={Uri.EscapeDataString(message)}";
var sendMessageResponse = new SendMessageResponse {
Status = SendMessageStatusEnum.NotSent
};
using (var client = new HttpClient())
{
using (var request = new HttpRequestMessage(HttpMethod.Post, url))
{
request.Content = new StringContent(postbody, Encoding.UTF8, "application/x-www-form-urlencoded");
using (var response = await client.SendAsync(request))
{
if (response.IsSuccessStatusCode)
{
sendMessageResponse.Status = SendMessageStatusEnum.Sent;
}
else
{
JToken error = JObject.Parse(await response.Content.ReadAsStringAsync())["error"];
var fbError = JsonConvert.DeserializeObject <FacebookError>(error.ToString());
sendMessageResponse.Status = SendMessageStatusEnum.Fail;
sendMessageResponse.StatusMessage = fbError.error_user_msg;
}
}
}
}
return(sendMessageResponse);
}
public SendMessageResponse SendMessageAsync(string queueName, string messageBody)
{
var request = new SendMessageRequest(
queueUrl: string.Concat(_queueUrl, queueName),
messageBody: messageBody);
SendMessageResponse result = null;
try
{
result = _amazonSQS.SendMessageAsync(request, new CancellationToken()).Result;
if (result != null)
{
_logger.Info($"Result sqs posted message: {JsonConvert.SerializeObject(result)}");
}
_logger.Info($"Message {messageBody} sent to SQS {string.Concat(_queueUrl, queueName)}. Result: {result?.HttpStatusCode}");
}
catch (System.Exception ex)
{
_logger.Error($"Error to post message at sqs: {ex.InnerException.Message}");
_logger.Error(ex.StackTrace);
throw;
}
return(result);
}
static void Main(string[] args)
{
Console.WriteLine("Starting..");
string sQueue = "https://sqs.eu-west-1.amazonaws.com/{CODE}/{QUEUENAME}"; // Region / CODE and QueueName
try
{
var config = new AmazonSQSConfig()
{
ServiceURL = "https://sqs.eu-west-1.amazonaws.com/" // Region and URL
};
var _messageRequest = new SendMessageRequest();
_messageRequest.QueueUrl = sQueue;
_messageRequest.MessageBody = "This is a test message";
AmazonSQSClient _client = new AmazonSQSClient("ACCESSKEY", "ACCESSSECRET", config);
SendMessageResponse sendMessageResponse = _client.SendMessage(_messageRequest);
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.ToString());
}
Console.WriteLine("Complete");
}
private void HandleResponse(SendMessageResponse response)
{
if (response.Success == false)
_logger.LogError(response.ErrorMessage);
if (response.Status != 0)
_logger.LogError(response.StatusMessage);
}
public override WebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
XmlTextReader reader = new XmlTextReader(context.ResponseStream);
SendMessageResponse response = new SendMessageResponse();
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.LocalName)
{
case MNSConstants.XML_ELEMENT_MESSAGE_ID:
response.MessageId = reader.ReadElementContentAsString();
break;
case MNSConstants.XML_ELEMENT_MESSAGE_BODY_MD5:
response.MessageBodyMD5 = reader.ReadElementContentAsString();
break;
}
break;
}
}
reader.Close();
return response;
}
public IActionResult Post([FromBody] SendMessageRequest sendMessageRequest)
{
SendMessageResponse response = new SendMessageResponse();
if (!ModelState.IsValid)
{
// validation errors have occurred
foreach (var modelState in ModelState.Values)
{
foreach (var error in modelState.Errors)
{
response.ErrorMessages.Add(new ErrorMessage {
Message = error.ErrorMessage
});
}
}
return(BadRequest(response));
// send message
}
response = _twilioService.SendMessage(sendMessageRequest.Message, sendMessageRequest.MobileNo);
if (!response.IsSuccess)
{
return(BadRequest(response));
}
response.SuccessMessage = $"{sendMessageRequest.Message} sent to {sendMessageRequest.MobileNo} successfully";
return(Ok(response));
}
static string SendMessage()
{
Message message = new Message();
message.Recipients = new string[] { "*****@*****.**" };
Content content = new Content();
Header header = new Header();
Attachment attachment = new Attachment();
List <Attachment> listAttachments = new List <Attachment>();
attachment.FileName = "hello_world.txt";
attachment.ContentType = "text/plain";
attachment.Content = "SGVsbG8gV29ybGQh\n";
listAttachments.Add(attachment);
header.Subject = "Test Mail from C#";
header.From = "*****@*****.**";
content.PlainText = "Hello Again";
message.Header = header;
message.Content = content;
message.Attachments = listAttachments;
SendMessageResponse response = EmailLibrary.SendMessage(message);
return(response.SourceTrackingId);
}
public ApiResult <SendMessageResponse> Send(string groupId, string imUserId, string msgType, string msgContent, string deviceType, string sourceType)
{
var response = new SendMessageResponse();
if (groupId.IsNullOrEmpty())
{
return(Error <SendMessageResponse>("1", "组标识不能为空"));
}
if (imUserId.IsNullOrEmpty())
{
return(Error <SendMessageResponse>("2", "用户不能为空"));
}
var channelId = _groupInfoService.GetChannelId(groupId.ToGuid());
if (channelId.IsNotNullOrEmpty())
{
var lasttime = DateTime.Now.ToUnix();
var data = NewsTypeHelper.ToChat(imUserId, sourceType, msgContent, lasttime);
RedisHelper.Publish(channelId, data);
_channelMessageService.Add(channelId, imUserId, msgType, msgContent, deviceType, sourceType, RequestHelper.Ip, "", lasttime);
}
return(Success(response));
}
public ApiResult <SendMessageResponse> Send(SendGroupMessageRequest request)
{
var response = new SendMessageResponse();
if (request == null)
{
return(Error <SendMessageResponse>("1", "参数无能为空"));
}
if (request.GroupId.IsNullOrEmpty())
{
return(Error <SendMessageResponse>("2", "组标识不能为空"));
}
var channelId = _groupInfoService.GetChannelId(request.GroupId.ToGuid());
if (channelId.IsNotNullOrEmpty())
{
var lasttime = DateTime.Now.ToUnix();
var data = NewsTypeHelper.ToChat(request.ImUserId, request.SourceType, request.MsgContent, lasttime);
RedisHelper.Publish(channelId, data);
_channelMessageService.Add(channelId, request.ImUserId, request.MsgType, request.MsgContent, request.DeviceType, request.SourceType, RequestHelper.Ip, "", lasttime);
}
return(Success(response));
}
static void Main(string[] args)
{
string name = string.Empty;
string email = string.Empty;
Console.WriteLine("Press ctrl+c to stop sending queue.");
while (true)
{
Console.Write("\nEnter name: ");
name = Console.ReadLine();
Console.Write("Enter email: ");
email = Console.ReadLine();
SendMessageResponse response = _sqsClient.SendMessageAsync(new SendMessageRequest
{
QueueUrl = QueueConfig.QueueUrl,
MessageBody = JsonConvert.SerializeObject(new Profile
{
Name = name,
Email = email
})
}).Result;
if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
Console.WriteLine("Queue sent successfully");
}
else
{
Console.WriteLine("Queue failed to send");
}
}
}
public async Task <HttpStatusCode> PushMessageToQueueAsync(T model, string awsAccessKeyId, string awsSecretAccessKey)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (String.IsNullOrEmpty(awsAccessKeyId))
{
throw new ArgumentNullException(nameof(awsAccessKeyId));
}
if (String.IsNullOrEmpty(awsSecretAccessKey))
{
throw new ArgumentNullException(nameof(awsSecretAccessKey));
}
try
{
IAmazonSQS sqs = new AmazonSQSClient(awsAccessKeyId, awsSecretAccessKey, RegionEndpoint.APSouth1);
String emailString = JsonConvert.SerializeObject(model);
SendMessageRequest sendMessageRequest = new SendMessageRequest
{
MessageBody = emailString,
QueueUrl = QueueUrl
};
SendMessageResponse response = await sqs.SendMessageAsync(sendMessageRequest);
return(response.HttpStatusCode);
}
catch (Exception ex)
{
throw new Exception("Error Pushing to SQS", ex);
}
}
public SendMessageResponse SendMessage(SendMessageRequest sendMsgReq)
{
SendMessageResponse response = new SendMessageResponse();
MessageService msgSvc = new MessageService(_repository);
try
{
msgSvc.SendMessage(sendMsgReq.Subject, sendMsgReq.Body, _currentTravelerId, new Guid[] { new Guid(sendMsgReq.RecipientID) });
response.MarkSuccess();
}
catch (Exception ex)
{
ReportError(ex, response);
}
return response;
}
public void TestMethod1()
{
SendMessageResponse res = new SendMessageResponse();
Assert.IsNotNull(res.ResponseMessage);
}
