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); }