public async Task <Unit> Handle(SendMessageCommand command, CancellationToken cancellationToken)
{
var playerId = command.PlayerId;
var channel = command.Channel;
var content = command.Content;
var receivedMessage = new PlayerMessage()
{
Channel = "闲聊",
Content = WebUtility.HtmlEncode(content),
Sender = _account.PlayerName,
PlayerId = _account.PlayerId
};
await _mudProvider.ShowChat(receivedMessage);
await _bus.RaiseEvent(new SendMessageEvent(playerId, content)).ConfigureAwait(false);
//新手任务
var chatTimes = await _redisDb.StringGet <int>(string.Format(RedisKey.ChatTimes, playerId));
if (chatTimes <= 0)
{
await _queueHandler.SendQueueMessage(new CompleteQuestNewbieQuestQueue(playerId, NewbieQuestEnum.第一次聊天));
}
chatTimes++;
await _redisDb.StringSet(string.Format(RedisKey.ChatTimes, playerId), chatTimes);
return(Unit.Value);
}
public async Task <ActionResult> Compose(NewMessageViewModel message)
{
//ViewBag.PmView = "compose";
//ViewBag.Title = "Compose";
//set this incase invalid submittal
var userData = UserData;
message.RequireCaptcha = userData.Information.CommentPoints.Sum < VoatSettings.Instance.MinimumCommentPointsForCaptchaMessaging && VoatSettings.Instance.CaptchaEnabled;
if (!ModelState.IsValid)
{
return(View(message));
}
if (message.Recipient == null || message.Subject == null || message.Body == null)
{
return(RedirectToAction("Sent", "Messages"));
}
if (message.RequireCaptcha)
{
bool isCaptchaValid = await ReCaptchaUtility.Validate(Request);
if (!isCaptchaValid)
{
ModelState.AddModelError(string.Empty, "Incorrect recaptcha answer.");
return(View(message));
}
}
var sendMessage = new SendMessage()
{
Recipient = message.Recipient,
Message = message.Body,
Subject = message.Subject,
Sender = message.Sender
};
var cmd = new SendMessageCommand(sendMessage, false, true).SetUserContext(User);
var response = await cmd.Execute();
if (response.Success)
{
var m = response.Response;
if (m.SenderType == IdentityType.Subverse)
{
return(RedirectToAction("SubverseIndex", "Messages", new { subverse = m.Sender, type = MessageTypeFlag.Sent, state = MessageState.All }));
}
else
{
return(RedirectToAction("Sent", "Messages"));
}
}
else
{
ModelState.AddModelError(string.Empty, response.Message);
return(View(message));
}
}
public async Task SendBadRecipientInfo_CheckExists()
{
var id = Guid.NewGuid().ToString();
var sender = USERNAMES.User100CCP;
var user = TestHelper.SetPrincipal(sender);
var cmd = new SendMessageCommand(new Domain.Models.SendMessage()
{
Recipient = "Do you like chocolate", Message = id, Subject = "All That Matters"
}, false, true).SetUserContext(user);
var response = await cmd.Execute();
VoatAssert.IsValid(response, Status.Error);
Assert.AreNotEqual("Comment points too low to send messages. Need at least 10 CCP.", response.Message);
using (var db = new VoatDataContext())
{
var count = (from x in db.Message
where
x.Content == id
select x).Count();
Assert.AreEqual(0, count, "Expecting no messages to make it through");
}
}
public async Task WhenSendingMessage_MessageIsSaved()
{
var user = await RunAsDefaultUserAsync();
var chat = ArrangeDb.SeedWorkChat(user);
await ArrangeDb.SaveChangesAsync();
var request = new SendMessageCommand {
ChatId = chat.Id, Text = "test message", UserId = user.Id
};
await SendAsync(request);
var chatDb = await AssertDb.Chats.Include(x => x.Messages).SingleAsync();
var message = chatDb.Messages.Single();
message.Should().BeEquivalentTo(new
{
SenderId = user.Id,
Text = "test message",
ChatId = chat.Id
});
message.SentDate.Should().BeCloseTo(DateTime.Now, 5000);
}
/// <summary>
/// Adds tags from the command to the span
/// </summary>
/// <param name="span">The span.</param>
/// <param name="command">The command.</param>
public static void Add(this Activity span, SendMessageCommand command)
{
var delay = command.MessageData.GetDelay();
if (delay.HasValue)
{
span.SetTag("MessageDelay",
delay.Value.ToString());
}
var expiration = command.MessageData.GetExpiration();
if (expiration.HasValue)
{
span.SetTag("MessageExpiration",
expiration.Value.ToString());
}
var priority = command.MessageData.GetPriority();
if (priority.HasValue)
{
span.SetTag("MessagePriority",
priority.Value.ToString());
}
}
public void SendMessage(string messageText)
{
var connectionId = Context.ConnectionId;
Client client;
if (!_services.TryGetClient(connectionId, out client))
{
throw new Exception("cannot send message - unrecognised client connection");
}
var sessionId = client.SessionId;
if (string.IsNullOrEmpty(sessionId))
{
throw new Exception("cannot send message - client has not joined any sessions");
}
var model = new SendMessageCommand {
Sender = client, Text = messageText, TimeStamp = DateTime.UtcNow
};
var session = _services.GetSession(sessionId);
_services.HandleCommand(session, model);
}
public void Send(string message)
{
var response = new SendMessageCommand(_client.ConnectionId, message)
.Send(_commandBus);
_room.NotifyMessageReceived(_client.Username, message, response.Timestamp);
}
public async Task <HttpResponseMessage> SendMessageToQueue([FromBody] SendMessageCommand sendMessageCommand)
{
string test = new StreamReader(HttpContext.Current.Request.InputStream).ReadToEnd();
HttpContext.Current.Request.InputStream.Seek(0, SeekOrigin.Begin);
//Validate input
var inputValidationResult = await ValidateInput(sendMessageCommand);
if (inputValidationResult.IsValid == false)
{
return(inputValidationResult.HttpResult);
}
//Send message to queue
var serviceBusClaimCheckClient = new ServiceBusClaimCheckClient(_blobStorageConnString, _blobContainerName, _serviceBusConnString, sendMessageCommand.QueueName);
await serviceBusClaimCheckClient.SendMessageToQueue(new ServiceBusMessage
{
Content = sendMessageCommand.Content,
ContentType = sendMessageCommand.ContentType,
ScheduledEnqueueTimeUtc = string.IsNullOrEmpty(sendMessageCommand.ScheduledEnqueueTimeUtc) ? DateTime.MinValue : DateTime.Parse(sendMessageCommand.ScheduledEnqueueTimeUtc),
Properties = sendMessageCommand.Properties == null ? new Dictionary <string, string>() : JsonConvert.DeserializeObject <Dictionary <string, string> >(sendMessageCommand.Properties.ToString())
});
return(Request.CreateResponse(HttpStatusCode.Accepted));
}
public async Task SendPrivateMessageFromSubverse()
{
var id = Guid.NewGuid().ToString();
var sender = "unit";
var recipient = USERNAMES.User100CCP;
var user = TestHelper.SetPrincipal(sender);
var message = new Domain.Models.SendMessage()
{
Sender = $"v/{sender}",
Recipient = recipient,
Subject = id,
Message = id
};
var cmd = new SendMessageCommand(message).SetUserContext(user);
var r = await cmd.Execute();
VoatAssert.IsValid(r);
using (var db = new VoatDataContext())
{
var record = (from x in db.Message
where
x.Sender == sender &&
x.SenderType == (int)Domain.Models.IdentityType.Subverse &&
x.Recipient == recipient &&
x.RecipientType == (int)Domain.Models.IdentityType.User &&
x.Title == id &&
x.Content == id
select x).FirstOrDefault();
Assert.IsNotNull(record, "Can not find message in database");
}
}
public MainWindowViewModel(IInteractiveLoginAdapter interactiveLoginAdapter, IMessageBus messageBus)
{
_interactiveLoginAdapter = interactiveLoginAdapter;
_messageBus = messageBus;
SendCommandCommand = new SendMessageCommand(this, _interactiveLoginAdapter);
InitMessageBus();
}
public async Task WhenNackReceivedForMultipleMessage_AllCallbacksAreCalledAndErrorMessagePassed()
{
// Arrange
var client = await GetConnectedClient();
var callbacks = new List <ValueTuple <bool, ErrorInfo> >();
var message = new ProtocolMessage(ProtocolMessage.MessageAction.Message, "Test");
void Callback(bool ack, ErrorInfo err)
{
callbacks.Add((ack, err));
}
// Act
client.ExecuteCommand(SendMessageCommand.Create(message, Callback));
client.ExecuteCommand(SendMessageCommand.Create(message, Callback));
client.ExecuteCommand(SendMessageCommand.Create(message, Callback));
var error = new ErrorInfo("reason", 123);
client.ExecuteCommand(ProcessMessageCommand.Create(
new ProtocolMessage(ProtocolMessage.MessageAction.Nack)
{
MsgSerial = 0, Count = 3, Error = error
}));
await client.ProcessCommands();
// Assert
callbacks.Count.Should().Be(3);
Assert.True(callbacks.TrueForAll(c => !c.Item1)); // Nack
Assert.True(callbacks.TrueForAll(c => ReferenceEquals(c.Item2, error))); // Error
}
/// <summary>
/// Sends an expired message.
/// </summary>
/// <param name="commandSend">The command send.</param>
/// <param name="expireTime">The expire time.</param>
/// <returns></returns>
/// <exception cref="DotNetWorkQueueException">Failed to enqueue a record. The LUA enqueue script returned null</exception>
private async Task <string> SendExpirationMessageAsync(SendMessageCommand commandSend, long expireTime)
{
var id = commandSend.MessageToSend.GetInternalHeader(_headers.StandardHeaders.RpcResponseId);
var rpc = false;
var messageId = _messageIdFactory.Create().Create().ToString();
if (!string.IsNullOrWhiteSpace(id))
{
messageId = id;
rpc = true;
}
var meta = new RedisMetaData(_unixTimeFactory.Create().GetCurrentUnixTimestampMilliseconds());
var serialized = _serializer.Serializer.MessageToBytes(new MessageBody {
Body = commandSend.MessageToSend.Body
});
commandSend.MessageToSend.SetHeader(_headers.StandardHeaders.MessageInterceptorGraph, serialized.Graph);
var result = await _enqueueExpirationLua.ExecuteAsync(messageId,
serialized.Output, _serializer.InternalSerializer.ConvertToBytes(commandSend.MessageToSend.Headers), _serializer.InternalSerializer.ConvertToBytes(meta), expireTime, rpc, commandSend.MessageData.Route).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(result))
{
throw new DotNetWorkQueueException("Failed to enqueue a record. The LUA enqueue script returned null");
}
messageId = result;
return(messageId);
}
internal static IDbCommand GetMainCommand(SendMessageCommand commandSend,
IDbConnection connection,
IDbCommandStringCache commandCache,
IHeaders headers,
ICompositeSerialization serializer)
{
var command = connection.CreateCommand();
command.CommandText = commandCache.GetCommand(CommandStringTypes.InsertMessageBody);
var serialization =
serializer.Serializer.MessageToBytes(new MessageBody {
Body = commandSend.MessageToSend.Body
}, commandSend.MessageToSend.Headers);
var param = command.CreateParameter();
param.ParameterName = "@Body";
param.DbType = DbType.Binary;
param.Value = serialization.Output;
command.Parameters.Add(param);
commandSend.MessageToSend.SetHeader(headers.StandardHeaders.MessageInterceptorGraph,
serialization.Graph);
param = command.CreateParameter();
param.ParameterName = "@Headers";
param.DbType = DbType.Binary;
param.Value = serializer.InternalSerializer.ConvertToBytes(commandSend.MessageToSend.Headers);
command.Parameters.Add(param);
return(command);
}
/// <inheritdoc />
public async Task <string> Handle(SendMessageCommand commandSend)
{
TimeSpan?delay = null;
//there are three possible locations for a message expiration. The user data and the header / internal headers
//grab it from the internal header
TimeSpan?expiration =
commandSend.MessageToSend.GetInternalHeader(_headers.StandardHeaders.RpcTimeout).Timeout;
//if the header value is zero, check the message expiration
if (expiration == TimeSpan.Zero)
{
//try the message header
expiration = commandSend.MessageToSend.GetHeader(_headers.StandardHeaders.RpcTimeout).Timeout;
}
//if the header value is zero, check the message expiration
if (expiration == TimeSpan.Zero && commandSend.MessageData.GetExpiration().HasValue)
{
// ReSharper disable once PossibleInvalidOperationException
expiration = commandSend.MessageData.GetExpiration().Value;
}
//treat a zero time as null
if (expiration == TimeSpan.Zero)
{
expiration = null;
}
if (commandSend.MessageData.GetDelay().HasValue)
{
delay = commandSend.MessageData.GetDelay();
}
//determine which path to send the message on
if (delay.HasValue && expiration.HasValue)
{
return
(await
SendDelayAndExpirationMessageAsync(commandSend,
_unixTimeFactory.Create().GetAddDifferenceMilliseconds(delay.Value),
_unixTimeFactory.Create().GetAddDifferenceMilliseconds(expiration.Value))
.ConfigureAwait(false));
}
if (delay.HasValue)
{
return
(await
SendDelayMessageAsync(commandSend,
_unixTimeFactory.Create().GetAddDifferenceMilliseconds(delay.Value)).ConfigureAwait(false));
}
if (expiration.HasValue)
{
return
(await
SendExpirationMessageAsync(commandSend,
_unixTimeFactory.Create().GetAddDifferenceMilliseconds(expiration.Value))
.ConfigureAwait(false));
}
return(await SendStandardMessageAsync(commandSend).ConfigureAwait(false));
}
public void Inizialize()
{
_chatbotService = new Mock <IChatbotService>();
_unitOfWork = new Mock <IUnitOfWork>();
_messageRepository = new Mock <IRepository <Message> >();
_persistance = new Mock <IPersistence <Message> >();
_unitOfWork = new Mock <IUnitOfWork>();
_unitOfWork.Setup(m => m.GetPersistence <Message>(It.IsAny <Type>())).Returns(() => _persistance.Object);
_eventAgregator = new Mock <IEventAggregator>();
_eventAgregator.Setup(m => m.GetEvent <MessageSended>()).Returns(() => new MessageSended());
var messageModel = new Mock <IMessageModel>();
_messageModel = new Mock <IChatBoxModel>();
_messageModel.SetupGet(m => m.Message).Returns(() => messageModel.Object);
_mapper = new Mock <IMapper>();
_mapper.Setup(m => m.Map <TextMessage>(It.IsAny <It.IsAnyType>()))
.Returns(() => new TextMessage());
_sut = new SendMessageCommand(messageRepository: _messageRepository.Object,
eventAgregator: _eventAgregator.Object,
chabotService: _chatbotService.Object,
unitOfWork: _unitOfWork.Object,
mapper: _mapper.Object);
}
private ICommand CreateSendMessageCommand()
{
var command = new SendMessageCommand(
this.ninjectKernel.Get <IServerChatService>());
return(command);
}
public async Task SendPrivateMessageFromSubverse()
{
var id = Guid.NewGuid().ToString();
var sender = "unit";
var recipient = "User100CCP";
TestHelper.SetPrincipal("unit");
var message = new Domain.Models.SendMessage()
{
Sender = $"v/{sender}",
Recipient = recipient,
Subject = id,
Message = id
};
var cmd = new SendMessageCommand(message);
var response = await cmd.Execute();
Assert.IsNotNull(response, "Response is null");
Assert.IsTrue(response.Success, response.Status.ToString());
using (var db = new voatEntities())
{
var record = (from x in db.Messages
where
x.Sender == sender &&
x.SenderType == (int)Domain.Models.IdentityType.Subverse &&
x.Recipient == recipient &&
x.RecipientType == (int)Domain.Models.IdentityType.User &&
x.Title == id &&
x.Content == id
select x).FirstOrDefault();
Assert.IsNotNull(record, "Can not find message in database");
}
}
private void Send_Click(object sender, EventArgs e)
{
if (SendMessageCommand != null)
{
SendMessageCommand.Execute(null);
}
}
/// <summary>
/// Sends the standard message.
/// </summary>
/// <param name="commandSend">The command send.</param>
/// <returns></returns>
/// <exception cref="DotNetWorkQueueException">Failed to enqueue a record. The LUA enqueue script returned null</exception>
private async Task <string> SendStandardMessageAsync(SendMessageCommand commandSend)
{
var messageId = _messageIdFactory.Create().Create().ToString();
var meta = new RedisMetaData(_unixTimeFactory.Create().GetCurrentUnixTimestampMilliseconds());
var serialized = _serializer.Serializer.MessageToBytes(new MessageBody {
Body = commandSend.MessageToSend.Body
}, commandSend.MessageToSend.Headers);
commandSend.MessageToSend.SetHeader(_headers.StandardHeaders.MessageInterceptorGraph, serialized.Graph);
var jobName = _jobSchedulerMetaData.GetJobName(commandSend.MessageData);
var scheduledTime = DateTimeOffset.MinValue;
var eventTime = DateTimeOffset.MinValue;
if (!string.IsNullOrWhiteSpace(jobName))
{
scheduledTime = _jobSchedulerMetaData.GetScheduledTime(commandSend.MessageData);
eventTime = _jobSchedulerMetaData.GetEventTime(commandSend.MessageData);
}
var result = await _enqueueLua.ExecuteAsync(messageId,
serialized.Output, _serializer.InternalSerializer.ConvertToBytes(commandSend.MessageToSend.Headers), _serializer.InternalSerializer.ConvertToBytes(meta), jobName, scheduledTime, eventTime, commandSend.MessageData.Route).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(result))
{
throw new DotNetWorkQueueException("Failed to enqueue a record. The LUA enqueue script returned null");
}
messageId = result;
return(messageId);
}
public MainPageViewModel(INavigationService navigationService, IMessageService messageService)
: base(navigationService)
{
_messageService = messageService;
Title = "チャット";
SendMessageCommand = Text.Select(s => !string.IsNullOrEmpty(s)).ToAsyncReactiveCommand();
SendMessageCommand.Subscribe(async() =>
{
try
{
await _messageService.SendMessage(Text.Value);
Text.Value = null;
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e);
}
});
_messageService.Notified.Subscribe(message =>
{
Messages.Add(message);
});
}
public async Task SendMessage_ShouldSendMessage()
{
//Arrange
var handler = new MessageQueryHandler();
var messagesFromHandler = await handler.HandleAsync(new MessageQuery());
var messagesFromHandlerCount = messagesFromHandler.ToList().Count;
var firstGamblerFromDatabase = this.context.Gamblers.FirstOrDefault();
var lastGamblerFromDatabase = this.context.Gamblers.LastOrDefault();
//Act - do something
string body = "Test body!";
string subject = "Test subject!";
SendMessageCommand command = new SendMessageCommand
{
Body = body,
Subject = subject,
Id = Guid.NewGuid(),
FromGamblerId = firstGamblerFromDatabase.Id, //sender id
ToGamblerId = lastGamblerFromDatabase.Id // receiver id
};
//Assert - check results
await this.sendMessageHandler.HandleAsync(command);
var messagesFromDatabaseCount = this.context.Tickets.Count();
Assert.AreNotEqual(messagesFromDatabaseCount, messagesFromHandlerCount);
}
public async Task WithNackMessageReceived_CallbackIsCalledWithError()
{
// Arrange
var client = await GetConnectedClient();
var callbacks = new List <ValueTuple <bool, ErrorInfo> >();
var message = new ProtocolMessage(ProtocolMessage.MessageAction.Message, "Test");
void Callback(bool ack, ErrorInfo err)
{
callbacks.Add((ack, err));
}
// Act
client.ExecuteCommand(SendMessageCommand.Create(message, Callback));
client.ExecuteCommand(ProcessMessageCommand.Create(
new ProtocolMessage(ProtocolMessage.MessageAction.Nack)
{
MsgSerial = 0, Count = 1
}));
client.ExecuteCommand(SendMessageCommand.Create(message, Callback));
client.ExecuteCommand(ProcessMessageCommand.Create(
new ProtocolMessage(ProtocolMessage.MessageAction.Nack)
{
MsgSerial = 1, Count = 1
}));
await client.ProcessCommands();
// Assert
callbacks.Count.Should().Be(2);
Assert.True(callbacks.TrueForAll(c => c.Item1 == false)); // Nack
Assert.True(callbacks.TrueForAll(c => c.Item2 != null)); // Error
}
private async Task <ValidationResult> ValidateInput(SendMessageCommand sendMessageCommand)
{
//Validate queue input
var queueValidationResult = await ValidateInput(sendMessageCommand.QueueName, false);
if (queueValidationResult.IsValid == false)
{
return(queueValidationResult);
}
//Check if DateTime is in valid format
DateTime enqueueDate;
if (string.IsNullOrWhiteSpace(sendMessageCommand.ScheduledEnqueueTimeUtc) == false && DateTime.TryParseExact(sendMessageCommand.ScheduledEnqueueTimeUtc, _dateTimeFormat, CultureInfo.GetCultureInfo("en-US"), DateTimeStyles.None, out enqueueDate) == false)
{
return new ValidationResult {
IsValid = false, HttpResult = Request.CreateResponse(HttpStatusCode.BadRequest, String.Format("The scheduled enqueue time is not in the expected {0} format", _dateTimeFormat))
}
}
;
//Return success
return(new ValidationResult {
IsValid = true, HttpResult = Request.CreateResponse(HttpStatusCode.Accepted)
});
}
public void Create_Default()
{
var message = NSubstitute.Substitute.For<IMessage>();
var data = NSubstitute.Substitute.For<IAdditionalMessageData>();
var test = new SendMessageCommand(message, data);
Assert.Equal(message, test.MessageToSend);
Assert.Equal(data, test.MessageData);
}
public void Should_Get_SendMessageCommandHandler_When_Command_Is_SendMessage()
{
var command = new SendMessageCommand();
var handler = CommandHandlerFactory.GetHandler(command);
Assert.IsAssignableFrom <SendMessageCommandHandler>(handler);
}
public async Task <IActionResult> SendMessage(SendMessageCommand command)
{
var message = await _commandBus.ExecuteAsync <MessageDTO>(command);
await this._hubContext.Clients.All.SendAsync("messageSent", message.Payload);
return(NoContent());
}
void SendMessageCommand_CanExecuteChanged(object sender, EventArgs e)
{
var sendMessageButton = ApplicationBar.Buttons[0] as IApplicationBarMenuItem;
if (sendMessageButton != null && SendMessageCommand != null)
{
sendMessageButton.IsEnabled = SendMessageCommand.CanExecute(null);
}
}
public void Create_Default()
{
var message = Substitute.For <IMessage>();
var data = Substitute.For <IAdditionalMessageData>();
var test = new SendMessageCommand(message, data);
Assert.Equal(message, test.MessageToSend);
Assert.Equal(data, test.MessageData);
}
public async Task <ActionResult> SendMessage(string id, SendMessageCommand request)
{
request.ChatId = id;
request.UserId = CurrentUserService.UserId;
await Mediator.Send(request);
return(NoContent());
}
public async Task <IActionResult> SendMessage(SendMessageApiRequest request)
{
var command = new SendMessageCommand(Guid.NewGuid(), request.ConversationId, User.GetUserId(), request.Text);
await _commandDispatcher.SendAsync(command);
var result = await _queryDispatcher.QueryAsync(new GetMessageQuery(command.MessageId));
return(Ok(result));
}
public async Task Handle(SendMessageCommand cmd)
{
// you would save to the Db here
_log.LogDebug($"%%%%%%% The message is [{cmd.Msg}]");
// then raise an event to any interested party
var evt = new MessageStoredEvent(cmd.Msg);
await _bus.Enqueue(evt);
}
public void Create_Default()
{
var id = Substitute.For <IMessage>();
var message = new AdditionalMessageData();
var test = new SendMessageCommand(id, message);
Assert.Equal(id, test.MessageToSend);
Assert.Equal(message, test.MessageData);
}
public static void SendMessage(SendMessageCommand message)
{
if (!_connected)
{
Connect();
}
if (_hubConnection.State == ConnectionState.Connected)
_proxy.Invoke("SendByConnectionId", message.ConnectionId, message.Message);
}
