public void Send(MessageIn msgIn)
{
try
{
if (client != null)
{
if (!client.IsRunning())
{
client.Connect();
client.Start();
}
client.Send(msgIn.Build());
if (msgIn.Type != MessageType.Heartbeat)
{
ServiceManager.Log(JsonConvert.SerializeObject(msgIn));
}
}
else
{
ServiceManager.Log("disconnected.");
}
}
catch (Exception ex)
{
ServiceManager.Error(ex);
}
}
public async Task QueueMessageWithoutTrans()
{
var client = await CreateClient();
// create quque
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "DefaultDeququeTest" });
Assert.AreEqual(1, createResponse.QueueId);
var extraQueueResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "ExtraQueue" });
Assert.AreEqual(2, extraQueueResponse.QueueId);
var inMessage = new MessageIn()
{
};
var exception = await Assert.ThrowsExceptionAsync <RpcException>(async() =>
{
await client.QueueMessageAsync(new QueueMessageRequest {
Message = inMessage, TransId = 0
});
});
Assert.AreEqual("Transaction not found, id: 0", exception.Status.Detail);
}
public async Task <int> PostToPipeline(int inputValue)
{
var message = new MessageIn(inputValue);
MyPipeline.InputBuffer.Post(message);
return(await message.Completion.Task);
}
public async Task DequeueMessageDefault()
{
var client = await CreateClient();
// Test Create queue
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "DefaultDeququeTest" });
Assert.AreEqual(1, createResponse.QueueId);
var extraQueueResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "ExtraQueue" });
Assert.AreEqual(2, extraQueueResponse.QueueId);
var transResponse = await client.StartTransactionAsync(new StartTransactionRequest());
var inMessage = new MessageIn()
{
MaxAttempts = 3
};
// Add Message
var queueMessageResponse1 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(1, queueMessageResponse1.MessageId);
var queueMessageResponse2 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(2, queueMessageResponse2.MessageId);
var queueMessageResponse3 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(3, queueMessageResponse3.MessageId);
// Check Message is NOT yet in the queue (since transaction not committed)
var messageCheckResponse = await client.PeekMessageByIdAsync(new PeekMessageByIdRequest { MessageId = 2 });
Assert.AreEqual(2, messageCheckResponse.Message.Id);
await client.CommitTransactionAsync(new CommitTransactionRequest { TransId = transResponse.TransId });
var exception = await Assert.ThrowsExceptionAsync <RpcException>(async() =>
{
await client.QueueMessageAsync(new QueueMessageRequest {
Message = inMessage, QueueId = 1, TransId = transResponse.TransId
});
});
Assert.AreEqual(StatusCode.Internal, exception.Status.StatusCode);
Assert.AreEqual("Transaction 1 not active: Commited", exception.Status.Detail);
await _webHost.StopAsync(TimeSpan.FromSeconds(60));
_webHost = StartServer();
var transPullResponse = await client.StartTransactionAsync(new StartTransactionRequest());
var dequeueResponse = await client.DequeueMessageAsync(new DequeueMessageRequest { QueueId = 1, TransId = transPullResponse.TransId });
Assert.AreEqual(1, dequeueResponse.Message?.Id);
}
public async Task DequeueSingleMessagesOnThreads()
{
var dict = new ConcurrentDictionary <int, long?>(20, 20);
var client = await CreateNewClient();
// Test Create quque
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "DefaultDeququeTest" });
Assert.AreEqual(1, createResponse.QueueId);
var transResponse = await client.StartTransactionAsync(new StartTransactionRequest());
var inMessage = new MessageIn()
{
MaxAttempts = 3
};
// Add Message
var queueMessageResponse1 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(1, queueMessageResponse1.MessageId);
var queueMessageResponse2 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(2, queueMessageResponse2.MessageId);
var queueMessageResponse3 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(3, queueMessageResponse3.MessageId);
await client.CommitTransactionAsync(new CommitTransactionRequest { TransId = transResponse.TransId });
// We can't use async here as the Parallel library doesn't support await
Parallel.For(0, 20, new ParallelOptions {
MaxDegreeOfParallelism = 20
}, (index) =>
{
var loopClient = CreateClient();
var transPullResponse = loopClient.StartTransaction(new StartTransactionRequest());
var dequeueResponse = loopClient.DequeueMessage(new DequeueMessageRequest {
QueueId = 1, TransId = transPullResponse.TransId
});
dict.TryAdd(index, dequeueResponse.Message?.Id);
loopClient.CommitTransaction(new CommitTransactionRequest {
TransId = transPullResponse.TransId
});
});
// Make sure three and only three messages were dequeued
Assert.AreEqual(3, dict.Count(x => x.Value != null));
Assert.AreEqual(1, dict.Count(x => x.Value == 1));
Assert.AreEqual(1, dict.Count(x => x.Value == 2));
Assert.AreEqual(1, dict.Count(x => x.Value == 3));
}
public ActionResult DeleteConfirmed(int id)
{
MessageIn messageIn = db.MessageIns.Find(id);
db.MessageIns.Remove(messageIn);
db.SaveChanges();
return(RedirectToAction("Index"));
}
static MessageProcessed TransformMessage(MessageIn message)
{
return(new MessageProcessed()
{
ProcessedValue = message.InputValue++,
Completion = message.Completion
});
}
public ActionResult Edit([Bind(Include = "Id,SendTime,ReceiveTime,MessageFrom,MessageTo,SMSC,MessageText,MessageType,MessageParts,MessagePDU,Gateway,UserId")] MessageIn messageIn)
{
if (ModelState.IsValid)
{
db.Entry(messageIn).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(messageIn));
}
public bool CreateMessageIn(MessageIn sms)
{
if (sms != null)
{
_context.Add(sms);
_context.SaveChanges();
return(true);
}
return(false);
}
public ActionResult Create([Bind(Include = "Id,SendTime,ReceiveTime,MessageFrom,MessageTo,SMSC,MessageText,MessageType,MessageParts,MessagePDU,Gateway,UserId")] MessageIn messageIn)
{
if (ModelState.IsValid)
{
db.MessageIns.Add(messageIn);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(messageIn));
}
public async Task <bool> UpdateMessageInAsync(MessageIn sms)
{
if (sms != null)
{
_context.Update(sms);
await _context.SaveChangesAsync();
return(true);
}
return(false);
}
public async Task SendMessage(MessageIn message)
{
var userId = _userManager.GetUserId(Context.User);
var returnMessage = await _messageService.SendMessageAsync(message.ChatId, userId, message.Content);
if (returnMessage != null)
{
var userName = _userManager.GetUserName(Context.User);
_logger.LogInformation(LoggingEvents.SendMessage, "{userName} sent a message: {content}. To chat {chatId}.", userName, returnMessage.Content, returnMessage.ChatId);
await Clients.Group(message.ChatId.ToString()).ReceiveMessage(new Message(returnMessage));
}
}
public async Task MessageTimeoutInSettings()
{
this.TestInitialize(new QueueOptions
{
DefaultMessageTimeoutInMinutes = 1
});
var client = await CreateClient();
// Test Create quque
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "DefaultDeququeTest" });
var transResponse = await client.StartTransactionAsync(new StartTransactionRequest());
var inMessage = new MessageIn()
{
ExpiryInMinutes = 0, // Should default to the options timeout
MaxAttempts = 3
};
// Add Message
var queueMessageResponse1 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(1, queueMessageResponse1.MessageId);
await client.CommitTransactionAsync(new CommitTransactionRequest { TransId = transResponse.TransId });
Thread.Sleep(1000 * 30);
var peekResponse = await client.PeekMessageByIdAsync(new PeekMessageByIdRequest { MessageId = queueMessageResponse1.MessageId });
Assert.AreEqual(MessageState.Active, peekResponse.Message?.MessageState);
Thread.Sleep(1000 * 31);
// Check Message is expired
var transPullResponse = await client.StartTransactionAsync(new StartTransactionRequest());
var dequeueResponse = await client.DequeueMessageAsync(new DequeueMessageRequest { QueueId = 1, TransId = transPullResponse.TransId });
Assert.IsNull(dequeueResponse.Message);
await client.CommitTransactionAsync(new CommitTransactionRequest { TransId = transPullResponse.TransId });
var peekResponse2 = await client.PeekMessageByIdAsync(new PeekMessageByIdRequest { MessageId = 1 });
Assert.AreEqual(MessageState.Expired, peekResponse2.Message?.MessageState);
Assert.AreNotEqual(0, peekResponse2.Message?.CloseDateTime);
Assert.AreEqual(0, peekResponse2.Message?.TransId);
Assert.AreEqual(TransactionAction.None, peekResponse2.Message?.TransAction);
}
private void SendHeartbeat()
{
// heartbeat
if ((DateTime.Now - lastHeartbeat).TotalSeconds > 3)
{
MessageIn messageIn = new MessageIn();
messageIn.Id = -1;
messageIn.Type = MessageType.Heartbeat;
Send(messageIn);
lastHeartbeat = DateTime.Now;
}
}
// GET: MessageIns/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MessageIn messageIn = db.MessageIns.Find(id);
if (messageIn == null)
{
return(HttpNotFound());
}
return(View(messageIn));
}
public async Task TransactionTimeoutInTransactionPullMessage()
{
this.TestInitialize(new QueueOptions
{
DefaultTranactionTimeoutInMinutes = 10
});
var client = await CreateClient();
// Test Create quque
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "DefaultDeququeTest" });
var transResponse = await client.StartTransactionAsync(new StartTransactionRequest()
{
ExpireInMin = 10
});
var inMessage = new MessageIn()
{
MaxAttempts = 3
};
var queueMessageResponse1 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(1, queueMessageResponse1.MessageId);
var commitTransResponse = await client.CommitTransactionAsync(new CommitTransactionRequest()
{
TransId = transResponse.TransId
});
var trans2Response = await client.StartTransactionAsync(new StartTransactionRequest()
{
ExpireInMin = 1
});
var pullResponse = await client.DequeueMessageAsync(new DequeueMessageRequest { QueueId = 1, TransId = trans2Response.TransId });
Assert.IsNotNull(pullResponse.Message);
Thread.Sleep(1000 * 61);
var peekResponse = await client.PeekMessageByIdAsync(new PeekMessageByIdRequest { MessageId = queueMessageResponse1.MessageId });
Assert.AreEqual(MessageState.Active, peekResponse.Message.MessageState);
}
public ApiResponse SetMessage([FromBody] MessageIn msgIn)
{
this.CheckCurrentUserPermission((x) => x.CanSendMessage || x.IsAdmin);
var userId = this.GetCurrentUser().Id;
using (var context = new AgmDataContext())
{
var msgToAdd = new Message()
{
InsertDate = DateTime.Now,
Subject = msgIn.Subject,
Text = msgIn.Text,
FromUserId = userId
};
var msg = context.Messages.Add(msgToAdd);
var messageReceivers = new List <MessageReceiver>();
if (msgIn.SendToAll == 1)
{
context.Users.Where(u => !u._isDeleted && u.Id != userId).ToList().ForEach((u) => messageReceivers.Add(new MessageReceiver()
{
MessageId = msgToAdd.Id, ToUserId = u.Id
}));
}
else
{
msgIn.ToUserIds.ToList().ForEach(u => messageReceivers.Add(new MessageReceiver()
{
MessageId = msgToAdd.Id, ToUserId = u
}));
}
context.MessageReceivers.AddRange(messageReceivers);
var res = context.SaveChanges();
if (res > 0)
{
return new ApiResponse(true)
{
Data = msg
}
}
;
return(new ApiResponse(false));
}
}
public async Task MessageRetryTenExceeded()
{
var client = await CreateClient();
// Test Create quque
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "DefaultDeququeTest" });
var transResponse = await client.StartTransactionAsync(new StartTransactionRequest());
var inMessage = new MessageIn()
{
MaxAttempts = 10
};
// Add Message
var queueMessageResponse = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(1, queueMessageResponse.MessageId);
await client.CommitTransactionAsync(new CommitTransactionRequest { TransId = transResponse.TransId });
// Cancel Pulled Message
for (int i = 0; i < 10; i++)
{
var transPullResponse = await client.StartTransactionAsync(new StartTransactionRequest());
var dequeueResponse = await client.DequeueMessageAsync(new DequeueMessageRequest { QueueId = 1, TransId = transPullResponse.TransId });
await client.RollbackTranactionAsync(new RollbackTransactionRequest { TransId = transPullResponse.TransId });
}
// Attempt Final Pull (should fail)
var transPullResponse2 = await client.StartTransactionAsync(new StartTransactionRequest());
var dequeueResponse2 = await client.DequeueMessageAsync(new DequeueMessageRequest { QueueId = 1, TransId = transPullResponse2.TransId });
Assert.IsNull(dequeueResponse2.Message);
// Peek Message to confirm retry expiration
var peekResult = await client.PeekMessageByIdAsync(new PeekMessageByIdRequest { MessageId = queueMessageResponse.MessageId });
Assert.AreEqual(10, peekResult.Message?.Attempts);
Assert.AreEqual(MessageState.AttemptsExceeded, peekResult.Message?.MessageState);
Assert.AreNotEqual(0, peekResult.Message?.CloseDateTime);
}
public async Task TransactionTimeoutInTransactionAddMessage()
{
this.TestInitialize(new QueueOptions
{
DefaultTranactionTimeoutInMinutes = 10
});
var client = await CreateClient();
// Test Create quque
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "DefaultDeququeTest" });
var transResponse = await client.StartTransactionAsync(new StartTransactionRequest()
{
ExpireInMin = 1
});
var inMessage = new MessageIn()
{
MaxAttempts = 3
};
// Add Message
var queueMessageResponse1 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(1, queueMessageResponse1.MessageId);
Thread.Sleep(1000 * 61);
var exception = await Assert.ThrowsExceptionAsync <RpcException>(async() =>
{
await client.CommitTransactionAsync(new CommitTransactionRequest {
TransId = transResponse.TransId
});
});
Assert.AreEqual("Transaction 1 not active: Expired", exception.Status.Detail);
var peekResponse = await client.PeekMessageByIdAsync(new PeekMessageByIdRequest { MessageId = queueMessageResponse1.MessageId });
Assert.IsNull(peekResponse.Message);
}
private void SubmitInbox()
{
if (inbox.Count == 0)
{
return;
}
mChrome.GoToUrl("http://ddtext.com/corrlinks/inbox.php");
for (int i = 0; i < inbox.Count; i++)
{
Thread.Sleep(1);
MessageIn msg = inbox[i];
mChrome.FindByAttr("input", "name", "sender", 1).SendKeys(msg.FROM);
mChrome.FindByAttr("input", "name", "date", 1).SendKeys(msg.DATE.ToString());
mChrome.FindByAttr("input", "name", "subject", 1).SendKeys(msg.SUBJECT);
mChrome.FindByAttr("textarea", "name", "message", 1).SendKeys(msg.MESSAGE);
//mChrome.SetTextByID("”message-body”", msg.MESSAGE);
mChrome.FindByAttr("input", "name", "submit", 1).Click();
}
inbox.Clear();
}
public async Task Add1000MessagesOnetransaction()
{
var client = await CreateClient();
// Test Create quque
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "DefaultDeququeTest" });
var transResponse = await client.StartTransactionAsync(new StartTransactionRequest());
var inMessage = new MessageIn()
{
MaxAttempts = 1
};
// Add Message
for (int i = 0; i < 1000; i++)
{
var queueMessageResponse = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
}
await client.CommitTransactionAsync(new CommitTransactionRequest { TransId = transResponse.TransId });
}
public override Task <MessageOut> ProcessMessage(MessageIn request, ServerCallContext context)
{
_logger.LogInformation($"Mensagem recebida: {request.BotUserId} {request.MessageId}");
_messageRep.Insert(new Message()
{
Id = Guid.NewGuid(),
Order = request.MessageId,
AccountId = request.BotUserId,
Moment = DateTime.Now,
Text = request.Text
});
var body = JsonConvert.SerializeObject(request);
return(Task.FromResult(new MessageOut
{
Result = true,
Message = body
}));
}
public async Task Pull1000MessagesByPriority()
{
var client = await CreateClient();
// Test Create quque
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "DefaultDeququeTest" });
// Add Messages
var transResponse = await client.StartTransactionAsync(new StartTransactionRequest());
for (int i = 0; i < 1000; i++)
{
var priority = 1000 - 1;
var inMessage = new MessageIn()
{
MaxAttempts = 1,
Priority = priority,
Payload = Google.Protobuf.ByteString.CopyFromUtf8(priority.ToString())
};
var queueMessageResponse = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
}
await client.CommitTransactionAsync(new CommitTransactionRequest { TransId = transResponse.TransId });
var pullTrans = await client.StartTransactionAsync(new StartTransactionRequest());
for (int i = 0; i < 1000; i++)
{
var message = await client.DequeueMessageAsync(new DequeueMessageRequest()
{
QueueId = createResponse.QueueId, TransId = pullTrans.TransId
});
Assert.AreEqual(message.Message.Payload.ToStringUtf8(), i.ToString());
}
await client.CommitTransactionAsync(new CommitTransactionRequest { TransId = pullTrans.TransId });
}
/// <summary>
/// Helper method for inserting message into specified conversation.
/// </summary>
/// <param name="id"></param>
/// <param name="message"></param>
/// <returns></returns>
private Message CreateMessage(int id, MessageIn message)
{
Message msg = null;
var conversation = ConversationService.Get(id);
if (conversation == null)
{
ThrowResponseException(HttpStatusCode.NotFound, "Conversation with id " + id + " not found");
}
// create and insert new message
try {
msg = MessageService.Insert(new Message {
Text = message.Text
}, conversation, blobs: message.Blobs, embeds: message.Embeds, meetings: message.Meetings);
} catch (Exception ex) {
// TODO: handle some way?
_log.Warn(ex.Message);
}
return(msg);
}
private async void asbInput_QuerySubmitted(AutoSuggestBox sender, AutoSuggestBoxQuerySubmittedEventArgs args)
{
//输入的名称正确，设置Brand的IsFinished为True
if (args.QueryText == string.Empty)
{
txtMessage.Text = "你的答案去火星了吗( ╯□╰ )?";
}
else if (IsAnswerRight(args.QueryText, CurrentBrand))
{
CurrentBrand.IsFinished = true;
txtMessage.Text = "( •̀ ω •́ )bingo 棒!!!";
Bindings.Update();
//将更新后的数据保存到本地
await GameHelper.BrandHelper.WriteBrandsToLocalAsync();
}
else
{
txtMessage.Text = "( ╯□╰ )whoops 不对噢!";
}
//提示动画
MessageIn.Begin();
}
public Task StartAsync(CancellationToken cancellationToken)
{
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (ch, ea) => _messageProcessingService.Process(ea.Body);
var queueName = _configuration.GetValue <string>("queueName");
var exchangeName = _configuration.GetValue <string>("exchangeName");
_channel.BasicConsume(queueName, true, consumer);
var props = _channel.CreateBasicProperties();
var keyboardInput = Console.ReadLine();
while (keyboardInput != "quit")
{
var message = new MessageIn();
message.Message = keyboardInput;
message.Type = "publish";
message.Nickname = MyName;
message.Timestamp = (int)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
var serializedMessage = JsonSerializer.Serialize(message, JsonOptions);
var messageBodyBytes = System.Text.Encoding.UTF8.GetBytes(serializedMessage);
_channel.BasicPublish(exchangeName,
"", props,
messageBodyBytes);
keyboardInput = Console.ReadLine();
}
return(Task.CompletedTask);
}
public async Task RejectSingleMessageOnThreads()
{
var dict = new ConcurrentDictionary <int, long?>(20, 20);
var client = await CreateNewClient();
// Test Create quque
var createResponse = await client.CreateQueueAsync(new CreateQueueRequest { QueueName = "DefaultDeququeTest" });
Assert.AreEqual(1, createResponse.QueueId);
var transResponse = await client.StartTransactionAsync(new StartTransactionRequest());
var inMessage = new MessageIn()
{
MaxAttempts = 3
};
// Add Message
var queueMessageResponse1 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(1, queueMessageResponse1.MessageId);
var queueMessageResponse2 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(2, queueMessageResponse2.MessageId);
var queueMessageResponse3 = await client.QueueMessageAsync(new QueueMessageRequest { Message = inMessage, QueueId = 1, TransId = transResponse.TransId });
Assert.AreEqual(3, queueMessageResponse3.MessageId);
await client.CommitTransactionAsync(new CommitTransactionRequest { TransId = transResponse.TransId });
Parallel.For(0, 20, new ParallelOptions {
MaxDegreeOfParallelism = 20
}, (index) =>
{
var loopClient = CreateClient();
var transPullResponse = loopClient.StartTransaction(new StartTransactionRequest());
var dequeueResponse = loopClient.DequeueMessage(new DequeueMessageRequest {
QueueId = 1, TransId = transPullResponse.TransId
});
dict.TryAdd(index, dequeueResponse.Message?.Id);
// Pretend there is something wrong with message 2. Keep rolling it back.
if (dequeueResponse.Message?.Id == 2)
{
loopClient.RollbackTranaction(new RollbackTransactionRequest {
TransId = transPullResponse.TransId
});
}
else
{
loopClient.CommitTransaction(new CommitTransactionRequest {
TransId = transPullResponse.TransId
});
}
});
// These are highly dependent on the threading. They could fail if the threads finish too quickly. Adding more threads should solve it.
Assert.AreEqual(5, dict.Count(x => x.Value != null));
Assert.AreEqual(1, dict.Count(x => x.Value == 1));
Assert.AreEqual(3, dict.Count(x => x.Value == 2));
Assert.AreEqual(1, dict.Count(x => x.Value == 3));
var messageCheckResponse = await client.PeekMessageByIdAsync(new PeekMessageByIdRequest { MessageId = 2 });
Assert.AreEqual(3, messageCheckResponse.Message?.Attempts);
Assert.AreEqual(2, messageCheckResponse.Message?.Id); //Just in case
Assert.AreEqual(3, messageCheckResponse.Message?.MaxAttempts);
Assert.AreEqual(MessageState.AttemptsExceeded, messageCheckResponse.Message?.MessageState);
Assert.AreNotEqual(0, messageCheckResponse.Message?.CloseDateTime);
}
private void ReadFromInbox()
{
UpdateStatus("Start processing for new messages...");
UpdateStatus(statusSeperator);
// Open Email box
//mChrome.FindByAttr("a", "href", "Inbox.aspx", 1).Click();
// Open new messages
int messageCount;
try
{
string alert = mChrome.FindById("ctl00_mainContentPlaceHolder_newMessageLink").Text;
var startPos = 9;
var endPos = alert.IndexOf(" unread");
string strMessageCount = alert.Substring(9, endPos - 9);
messageCount = Convert.ToInt32(strMessageCount);
mChrome.FindById("ctl00_mainContentPlaceHolder_newMessageLink").Click();
} catch
{
UpdateStatus("No new messages found");
UpdateStatus("Finished processing for new messages...");
UpdateStatus(statusSeperator);
mChrome.GoToUrl("https://www.corrlinks.com/Default.aspx");
return;
}
Thread.Sleep(2000);
IWebElement tbodyWebElement = mChrome.FindByXPath("//table[@class='MessageDataGrid']/tbody");
if (tbodyWebElement == null)
{
UpdateStatus("No new messages found");
UpdateStatus("Finished processing for new messages...");
UpdateStatus(statusSeperator);
return;
}
for (int i = 0; i < messageCount; i++)
{
try
{
Thread.Sleep(4000);
mChrome.FindByXPath("//table[@class='MessageDataGrid']/tbody/tr[" + (2).ToString() + "]").Click();
Thread.Sleep(4000);
MessageIn message = new MessageIn();
message.FROM = mChrome.FindById("ctl00_mainContentPlaceHolder_fromTextBox").GetAttribute("value");
message.INMATE_ID = MyUtil.GetMateID(message.FROM);
message.DATE = Convert.ToDateTime(mChrome.FindById("ctl00_mainContentPlaceHolder_dateTextBox").GetAttribute("value"));
message.SUBJECT = mChrome.FindById("ctl00_mainContentPlaceHolder_subjectTextBox").GetAttribute("value");
message.MESSAGE = mChrome.FindById("ctl00_mainContentPlaceHolder_messageTextBox").Text;
message.TIMESTAMP = new DateTime();
inbox.Add(message);
SubmitInbox();
mChrome.GoToUrl("https://www.corrlinks.com/Inbox.aspx?UnreadMessages");
UpdateStatus("Read message from " + message.FROM);
}
catch (Exception ex)
{
UpdateStatus(ex.Message);
}
}
UpdateStatus("Finished processing for new messages...");
UpdateStatus(statusSeperator);
mChrome.GoToUrl("https://www.corrlinks.com/Default.aspx");
}
public ActionResult InsertMessage(int id, MessageIn message)
{
var msg = CreateMessage(id, message);
return(RedirectToAction <MessengerController>(c => c.Conversation(id)));
}
// Obtener los mensajes de la cola.
private void obtenerLosMensajes()
{
MessageIn myMsgIn = MessageIn.create();
VentasMessage = myMsgIn.getMensaje();
}