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