public async Task CreateMessage(CreateMessageRequest request) { async Task ProcessRequest() { var message = await _mediator .Send(new CreateMessageCommand { UserId = long.Parse(Context.UserIdentifier), RoomId = request.RoomId, Content = request.Content }); var response = new CreateMessageResponse { UserId = message.UserId, Content = message.Content, Date = message.CreatedOn }; await Clients .Group(message.RoomId.ToString()) .SendAsync(_receiveMessageName, response); } await HandleError(ProcessRequest); }
private async Task <HaveMessage> SaveMessage(CreateMessageRequest message) { //var isBlock = await _context.BlockUsers.AnyAsync(x => (x.FromUserId == message.SenderId && x.ToUserId == message.ReceiverId) || (x.FromUserId == message.ReceiverId && x.ToUserId == message.SenderId)); //if (isBlock) //{ // return null; //} var newMessage = new HaveMessage() { SenderId = message.SenderId, ReceiverId = message.ReceiverId, Content = message.Content, SentAt = DateTime.Now }; try { _context.HaveMessages.Add(newMessage); await _context.SaveChangesAsync(); } catch (Exception) { return(null); } return(newMessage); }
public Message(CreateMessageRequest message) { SenderId = message.SenderId; Content = message.Content; CreatedAt = DateTime.UtcNow; ConversationId = message.ConversationId; }
public void ShouldThrowIfChannelDoesNotExist() { // Arrange var member = new Member { Id = new Guid("20CAE535-7CE3-4ED4-9D8F-2693953E94D3") }; _memberRepositoryMock.Setup(x => x.GetMemberBySaasUserIdAsync(It.IsAny <string>())) .ReturnsAsync(member) .Verifiable(); _channelRepositoryMock.Setup(x => x.IsChannelExistsAndOpenAsync(It.IsAny <Guid>())) .ReturnsAsync(false) .Verifiable(); var request = new CreateMessageRequest("864EB62D-D833-47FA-8A88-DDBFE76AE6A7", new Guid("A455F139-09E6-4EF5-B55A-D4C94D05DFDE"), MessageType.Default, "body"); // Act Func <Task> act = async() => { await _messageService.CreateMessageAsync(request); }; // Assert act.Should().Throw <NetKitChatNotFoundException>() .And.Message.Should().Be($"Unable to create message. Channel {nameof(request.ChannelId)}:{request.ChannelId} is not found."); VerifyMocks(); }
public async Task <ActionResult <Guid> > Post([FromForm] string text) { var request = new CreateMessageRequest(text); var response = await mediator.Send(request); return(CreateMessageResponse((dynamic)response)); }
public async Task CreateMessageAsyncTest() { // Arrange var request = new CreateMessageRequest(SaasUserId) { Body = "test", ChannelId = _channelId, Type = MessageType.Default, ImageUrl = "test" }; // Act var channel = await _channelService.GetChannelByIdAsync(new ChannelRequest(SaasUserId, _channelId)); var oldChannelMessagesCount = await _channelService.GetChannelMessageCountAsync(new ChannelRequest(SaasUserId, channel.Id)); var message = await _messageService.CreateMessageAsync(request); var newChannel = await _channelService.GetChannelByIdAsync(new ChannelRequest(SaasUserId, _channelId)); var newChannelMessagesCount = await _channelService.GetChannelMessageCountAsync(new ChannelRequest(SaasUserId, newChannel.Id)); // Assert Assert.NotNull(message); Assert.Equal(request.Body, message.Body); Assert.Equal(request.ChannelId, message.ChannelId); Assert.Equal(request.Type, message.Type); Assert.Equal(request.ImageUrl, message.ImageUrl); Assert.Equal(_channelId, message.ChannelId); Assert.True(newChannelMessagesCount > oldChannelMessagesCount); }
public async Task <IActionResult> Create([FromBody] CreateMessageRequest request) { var message = new Message { Text = request.Text, UserId = HttpContext.GetUserId() }; var created = await _messageService.CreateMessageAsync(message); if (!created) { return(BadRequest(new ErrorResponse { Errors = new List <ErrorModel> { new ErrorModel { Message = "Not able to create the message" } } })); } var locationUri = _uriService.GetMessageUri(message.Id.ToString()); var response = new MessageResponse { Id = message.Id }; return(Created(locationUri, new Response <MessageResponse>(response))); }
public async Task DeleteMessageAsyncTest() { // Arrange var request = new CreateMessageRequest(SaasUserId) { Body = "test", ChannelId = _channelId, Type = MessageType.Default, ImageUrl = "test" }; var message = await _messageService.CreateMessageAsync(request); // Act var messages = await _messageService.GetChannelMessagesAsync(new MessageRequest(SaasUserId, _channelId, 1, 10)); await _messageService.DeleteMessageAsync(new DeleteMessageRequest(SaasUserId, message.Id)); var newMessages = await _messageService.GetChannelMessagesAsync(new MessageRequest(SaasUserId, _channelId, 1, 10)); // Assert Assert.NotNull(newMessages); Assert.Empty(newMessages.Results); Assert.True(messages.Results.Count() > newMessages.Results.Count()); }
public async Task GetChannelMessagesAsyncTest() { // Arrange var request = new CreateMessageRequest(SaasUserId) { Body = "test", ChannelId = _channelId, Type = MessageType.Default, ImageUrl = "test" }; // Act var messages = await _messageService.GetChannelMessagesAsync(new MessageRequest(SaasUserId, _channelId, 1, 10)); var message = await _messageService.CreateMessageAsync(request); var newMessages = await _messageService.GetChannelMessagesAsync(new MessageRequest(SaasUserId, _channelId, 1, 10)); // Assert Assert.NotNull(newMessages); Assert.NotEmpty(newMessages.Results); Assert.Equal(request.Body, newMessages.Results.First().Body); Assert.Equal(request.Type, newMessages.Results.First().Type); Assert.Equal(request.ImageUrl, newMessages.Results.First().ImageUrl); Assert.True(newMessages.Results.Count() > messages.Results.Count()); }
public async Task <IActionResult> AddMessage([FromBody] CreateMessageRequest messageRequest) { var message = mapper.Map <Message>(messageRequest); await messageService.CreateMessageAsync(message); return(Ok()); }
/// <summary> /// 新建消息 /// </summary> /// <param name="request"></param> /// <returns></returns> public CreateMessageResult CreateMessage(CreateMessageRequest request) { var result = new CreateMessageResult(); var messageBody = new MessageBody() { Title = request.Title, Content = request.Content }; var message = new Message() { AppId = request.AppId }; message.SetBody(messageBody); try { Validate(message); AppIdIsInvalid(request.AppId); } catch (BusinessRuleException excep) { // TODO... //return result.Create(excep); } _messageRepository.Register(message); return(result); }
public async Task <IActionResult> Post([FromForm] CreateMessageRequest request) { var result = await SaveMessage(request); if (result == null) { return(BadRequest("Can not send message now!")); } var sender = await _context.Users.FindAsync(request.SenderId); var receiver = await _context.Users.FindAsync(request.ReceiverId); var display = new UserDisplay(sender, _storageService); var response = new ChatResponse() { SenderId = result.SenderId, ReceiverId = result.ReceiverId, Content = result.Content, SentAt = result.SentAt, Id = result.Id, FullName = display.FullName, Avatar = display.AvatarPath }; await _hub.Clients.Clients(receiver.ConnectionId, sender.ConnectionId).SendAsync("transferData", response); return(Ok(new { Message = "Request complete!" })); }
public void It_Should_Return_Error_When_User_Is_Null() { // Setup Mocks ============================================ var unitOfWork = new Mock <IUnitOfWork>(); unitOfWork.Setup(x => x.Save()).Returns(Task.CompletedTask); var messageRepository = new Mock <IMessageRepository>(); messageRepository.Setup(x => x.Save(It.IsAny <Message>())).Returns(Task.FromResult(true)); var userRepository = new Mock <IUserRepository>(); userRepository.Setup(x => x.FindRoomOfUserById(It.IsAny <Guid>())).Returns(Task.FromResult <User>(null)); // ======================================================== var request = new CreateMessageRequest(); request.userIdentifier = Guid.NewGuid(); request.text = "hello world"; var service = new MessageService(unitOfWork.Object, userRepository.Object, messageRepository.Object); try { Task <CreateMessageResponse> response = service.CreateMessage(request); } catch (Exception e) { Assert.IsInstanceOfType(e, typeof(ApplicationError)); } }
public async Task CreateMessage(CreateMessageRequest request) { try { var ctx = new ValidationContext(request); var results = new List <ValidationResult>(); Validator.TryValidateObject(request, ctx, results, true); if (results.Count > 0) { throw new ApplicationError("[CreateMessage]", 4); } var response = await _messageService.CreateMessage(request); await Clients.Caller.MessageCreated(response); await Clients.OthersInGroup(response.roomIdentifier.ToString()).BrMessageCreated(response); } catch (Exception e) { var errorResponse = ApplicationError.GetError <CreateMessageResponse>(e, "[CreateMessage]"); _logger.LogError(e.Message); await Clients.Caller.MessageCreated(errorResponse); } }
private static void createMessage(IoTDAClient client) { CreateMessageRequest req = new CreateMessageRequest { InstanceId = "1a7ffc5c-d89c-44dd-8265-b1653d951ce0", DeviceId = "", Body = new DeviceMessageRequest() { MessageId = "", Name = "", Message = "", Topic = "" } }; try { var resp = client.CreateMessage(req); Console.WriteLine(resp); } catch (RequestTimeoutException requestTimeoutException) { Console.WriteLine(requestTimeoutException.ErrorMessage); } catch (ServiceResponseException clientRequestException) { Console.WriteLine(clientRequestException.HttpStatusCode); Console.WriteLine(clientRequestException.ErrorCode); Console.WriteLine(clientRequestException.ErrorMsg); } catch (ConnectionException connectionException) { Console.WriteLine(connectionException.ErrorMessage); } }
public IHttpActionResult Create(int chatId, CreateMessageRequest request) { if (!HasValidCookie) { return(Unauthorized()); } var chatConnections = DBContext.GetChatConnectionsByUserId(CurrentUserId); if (!chatConnections.Any(i => i.ChatId == request.ChatId && i.Status == ConnectionStatus.Accepted) || request.ChatId != chatId) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest()); } Message message = new Message { ChatId = request.ChatId, UserId = request.UserId, Content = request.Content }; message.UpdatedAt = System.DateTime.UtcNow; message.UpdatedBy = CurrentUserId; message.CreatedAt = System.DateTime.UtcNow; message.CreatedBy = CurrentUserId; return(Ok(ToJsonString(DBContext.CreateMessage(message)))); }
public async Task <MessageResponse> CreateMessageAsync(CreateMessageRequest request) { var channel = await UnitOfWork.ChannelRepository.GetChannelByIdAsync(request.ChannelId); Ensure.That(channel).WithException(x => new NotFoundException(new ErrorDto(ErrorCode.NotFound, "Channel does not exist."))).IsNotNull(); var member = await UnitOfWork.MemberRepository.GetMemberBySaasUserIdAsync(request.SaasUserId); Ensure.That(member).WithException(x => new NotFoundException(new ErrorDto(ErrorCode.NotFound, "Member does not exist."))).IsNotNull(); var message = new Domain.Message.Message { Id = Guid.NewGuid(), ChannelId = request.ChannelId, OwnerId = member.Id, Owner = member, Body = request.Body, Created = DateTimeOffset.UtcNow, Type = request.Type, ImageUrl = request.ImageUrl }; using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await UnitOfWork.MessageRepository.AddMessageAsync(message); await AddLastReadMessageAsync(new AddLastReadMessageRequest(request.ChannelId, message.Id, request.SaasUserId)); transactionScope.Complete(); } return(message.ToMessageResponse(null, _cloudStorageConfiguration)); }
public async Task CreateMessage_Should_CreateMessage() { //Arrange var createMessageRequest = new CreateMessageRequest { MessageContents = "This is a test message" }; const string username = "******"; var testMessage = new Message { MessageId = 1, CreatedBy = "TestUser", Created = DateTime.Now.AddHours(-1), MessageContent = "Test Message" }; var getMessageRequest = new GetMessagesRequest(); var fakeMessageBoardRepository = A.Fake <IMessageBoardRepository>(); A.CallTo(() => fakeMessageBoardRepository.CreateMessage(username, createMessageRequest)).Returns(testMessage); var messageService = new MessageService(fakeMessageBoardRepository); //Act var createdMessage = messageService.CreateMessage(username, createMessageRequest); //Assert A.CallTo(() => fakeMessageBoardRepository.CreateMessage(username, createMessageRequest)).MustHaveHappened(1, Times.Exactly); createdMessage.Should().Be(testMessage); }
private Message <string, string> BuildMessage(CreateMessageRequest request) { return(new Message <string, string> { Key = Guid.NewGuid().ToString(), Value = JsonSerializer.Serialize(request) }); }
private void GivenServicesReturnExpectedValues(CreateMessageRequest parsedInput, WebexTeamsMessage apiResponse, GlobalXMessage parsedApiResponse, Person sender) { _messageParser.ParseCreateMessageRequest(_input).Returns(parsedInput); _apiService.SendMessageAsync(parsedInput).Returns(Task.FromResult(apiResponse)); _messageParser.ParseMessage(apiResponse).Returns(parsedApiResponse); _apiService.GetPersonAsync(apiResponse.PersonId).Returns(Task.FromResult(sender)); }
internal void TestSendMessage(CreateMessageRequest request, string httpResponse, Message response) { this.Given(x => GivenACreateMessageRequest(request)) .When(x => WhenSendingAMessage(httpResponse)) .Then(x => ThenItShouldCallTheHttpClientPost()) .And(x => ThenItShouldReturnTheMessage(response)) .BDDfy(); }
internal void TestParseCreateMessageRequest(GlobalXMessage input, CreateMessageRequest output) { this.Given(x => GivenAGlobalXMessage(input)) .When(x => WhenParsingACreateMessageRequest()) .Then(x => ThenItShouldReturnACreateMessageRequest(output)) .And(x => ThenItShouldNotThrowAnException()) .BDDfy(); }
public async Task <IActionResult> CreateMessageAsync(Guid channelId, [FromBody] CreateMessageRequest request) { request.ChannelId = channelId; request.SaasUserId = GetCurrentUserId(); var message = await _messageService.CreateMessageAsync(request); return(Ok(message)); }
public async Task <MessageResponse> CreateMessageAsync(CreateMessageRequest request) { var member = await UnitOfWork.MemberRepository.GetMemberBySaasUserIdAsync(request.SaasUserId); if (member == null) { throw new NetKitChatNotFoundException($"Unable to create message. Member {nameof(request.SaasUserId)}:{request.SaasUserId} is not found."); } var isChannelOpen = await UnitOfWork.ChannelRepository.IsChannelExistsAndOpenAsync(request.ChannelId); if (!isChannelOpen) { throw new NetKitChatNotFoundException($"Unable to create message. Channel {nameof(request.ChannelId)}:{request.ChannelId} is not found."); } // move image to persistent container if (!string.IsNullOrWhiteSpace(request.ImageUrl)) { request.ImageUrl = await _cloudImageProvider.CopyImageToDestinationContainerAsync(request.ImageUrl); } var message = new Message { Id = Guid.NewGuid(), ChannelId = request.ChannelId, OwnerId = member.Id, Body = request.Body, Created = _dateTimeProvider.GetUtcNow(), Type = request.Type, ImageUrl = request.ImageUrl, AccessibilityStatus = AccessibilityStatus.Present }; await UnitOfWork.ExecuteTransactionAsync(async() => { if (request.Type == MessageType.Forward) { var forwardedMessage = await UnitOfWork.MessageRepository.GetMessageWithOwnerAndForwardMessageAsync(request.ForwardedMessageId); if (forwardedMessage == null) { throw new NetKitChatNotFoundException($"Unable to create message. Forward message {nameof(request.ForwardedMessageId)}:{request.ForwardedMessageId} is not found."); } var forwardMessage = DomainModelsMapper.MapToForwardMessage(forwardedMessage); forwardMessage.Id = Guid.NewGuid(); await UnitOfWork.ForwardMessageRepository.AddForwardMessageAsync(forwardMessage); message.ForwardMessageId = forwardMessage.Id; } await UnitOfWork.MessageRepository.AddMessageAsync(message); await UnitOfWork.ChannelMemberRepository.SetLastReadMessageAsync(member.Id, request.ChannelId, message.Id); }); message = await UnitOfWork.MessageRepository.GetMessageWithOwnerAndForwardMessageAsync(message.Id); return(DomainModelsMapper.MapToMessageResponse(message)); }
public async Task CreateMessage(string channelId, CreateMessageRequest createMessageRequest) { Url url = new Url(DiscordConstants.BaseUrl).AppendPathSegments("channels", channelId, "messages"); string json = JsonConvert.SerializeObject(createMessageRequest, Formatting.None, jsonSerializerSettings); StringContent content = new StringContent(json, Encoding.UTF8, "application/json"); HttpResponseMessage responseMessage = await httpClient.PostAsync(url, content); string responseString = await responseMessage.Content.ReadAsStringAsync(); }
public async Task <Message> SendMessageAsync(CreateMessageRequest request) { var json = JsonConvert.SerializeObject(request, _defaultJsonSerializerSettings); var result = await _httpClientProxy.PostAsync("/v1/messages", json).ConfigureAwait(false); var resultObject = JsonConvert.DeserializeObject <Message>(result, _defaultJsonSerializerSettings); return(resultObject); }
internal void TestSendMessage(GlobalXMessage input, CreateMessageRequest parsedInput, WebexTeamsMessage apiResponse, GlobalXMessage parsedApiResponse, Person sender, GlobalXMessage output) { this.Given(x => GivenAGlobalXMessage(input)) .And(x => GivenServicesReturnExpectedValues(parsedInput, apiResponse, parsedApiResponse, sender)) .When(x => WhenSendingAMessage()) .Then(x => ThenItShouldCallApiService()) .And(x => ThenItShouldReturnAMessage(output)) .BDDfy(); }
public async Task WhenCreateMessageGetsCalled() { Setup(); _createMessageRequest = new Fixture().Create <CreateMessageRequest>(); AuthService.Setup(service => service.AuthorizeSelf(It.IsAny <string>(), It.IsAny <Guid>())) .Returns(false); _result = await MessagesController.CreateMessage(_createMessageRequest); }
public async Task <IActionResult> ProduceMessage(CreateMessageRequest request) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _service.ProduceAsync(request); return(Ok()); }
private void WhenParsingACreateMessageRequest() { try { _createMessageRequest = _subject.ParseCreateMessageRequest(_globalXMessage); } catch (Exception e) { _exception = e; } }