public MessagesController
(
IMessageLinkBuilder linkBuilder,
ActionExecutor actionExecutor,
ListMessagesQuery listMessagesQuery,
GetMessageQuery getMessageQuery,
CreateMessageCommand createMessageCommand,
UpdateMessageCommand updateMessageCommand,
DeleteMessageCommand deleteMessageCommand
)
{
_linkBuilder = linkBuilder
?? throw new ArgumentNullException(nameof(linkBuilder));
_actionExecutor = actionExecutor
?? throw new ArgumentNullException(nameof(actionExecutor));
_listMessagesQuery = listMessagesQuery
?? throw new ArgumentNullException(nameof(listMessagesQuery));
_getMessageQuery = getMessageQuery
?? throw new ArgumentNullException(nameof(getMessageQuery));
_deleteMessageCommand = deleteMessageCommand
?? throw new ArgumentNullException(nameof(deleteMessageCommand));
_createMessageCommand = createMessageCommand
?? throw new ArgumentNullException(nameof(createMessageCommand));
_updateMessageCommand = updateMessageCommand
?? throw new ArgumentNullException(nameof(updateMessageCommand));
}
public CreateMessageCommand MapSingle(ITweet tweet)
{
var user = new UserModel
{
NetworkId = tweet.CreatedBy.IdStr,
Url = tweet.Url,
UserName = tweet.CreatedBy.Name,
AvatarUrl50 = tweet.CreatedBy.ProfileImageUrl,
MediaType = SocialMediaType.Twitter
};
var tags = tweet.Hashtags.Select(x => new HashtagModel
{
HashTag = new HashTagWord(x.Text),
IsEnabled = false
}).ToList();
var message = new CreateMessageCommand
{
MessageText = tweet.Text,
HashTags = tags,
MediaType = SocialMediaType.Twitter,
PostDate = tweet.TweetLocalCreationDate.ToUniversalTime(),
NetworkId = tweet.IdStr,
User = user
};
return(message);
}
public async Task AddMessageAsync(CreateMessageCommand command)
{
var message = new Message(command.Name, command.Email, command.Text);
await _context.Messages.AddAsync(message);
await _context.SaveChangesAsync();
}
public List <CreateMessageCommand> MapBunch(VkNewsFeed feed)
{
var results = new List <CreateMessageCommand>();
// vk doesn't return list of all hashtags in message
// todo: consider parsing message for hashtags. But it might be too memory consuming operation.
foreach (var post in feed.Feed)
{
var date = DateTimeOffset.FromUnixTimeSeconds(post.UnixTimeStamp).UtcDateTime;
var user = FillUser(post, feed);
var message = new CreateMessageCommand
{
MessageText = post.Text,
HashTags = ParseHashtags(post.Text).Select(x => new HashtagModel
{
HashTag = new HashTagWord(x),
IsEnabled = false
}).ToList(),
MediaType = SocialMediaType.VK,
PostDate = date,
NetworkId = post.Id.ToString(),
User = user
};
results.Add(message);
}
return(results);
}
//[Authorize(Roles = "client, freelancer")]
public async Task <IActionResult> PostMessage(int id, [FromBody] CreateMessageInputModel inputModel)
{
var command = new CreateMessageCommand(id, inputModel.Content);
await _mediator.Send(command);
return(NoContent());
}
public async Task <IActionResult> CreateMessage(int uId, int gId, CreateMessageCommand createMessageCommand)
{
createMessageCommand.Finalize(uId, gId);
var messageId = await _mediator.Send(createMessageCommand);
return(CreatedAtAction(nameof(CreateMessage), messageId));
}
public async Task Users_Should_SendMessages()
{
var command = new UserRegisterCommand
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
Password = "******",
Name = "Mirrabel",
Surname = "Ernest"
};
var command2 = new UserRegisterCommand
{
Id = new Guid("6759d0df-9838-4641-b332-f251b05fcd44"),
Email = "*****@*****.**",
Password = "******",
Name = "Mirrabel",
Surname = "Ernest"
};
// await _backendFixture.SendAsync<UserDto>(HttpMethod.Post, "api/users", command2);
await _backendFixture.LoginAsync(command.Email, command.Password);
var connection1 = _backendFixture.CreateHubConnection();
var message = new CreateMessageCommand
{
Id = Guid.NewGuid(),
Content = "Mario bross",
Receiver = new Guid("6759d0df-9838-4641-b332-f251b05fcd44")
};
await _backendFixture.LoginAsync(command2.Email, command2.Password);
var connection2 = _backendFixture.CreateHubConnection();
await connection2.StartAsync();
var tcs = new TaskCompletionSource <CreateMessageCommand>();
connection2.On(Channels.Chat.Messages, new[] { typeof(CreateMessageCommand) }, async(p1, p2) =>
{
tcs.SetResult(p1[0] as CreateMessageCommand);
},
new object());
await connection1.StartAsync();
await connection1.SendCoreAsync(Channels.Chat.Messages, new[] { message });
await tcs.Task;
tcs.Task.Result.Id.Should().Be(message.Id);
tcs.Task.Result.Content.Should().Be(message.Content);
tcs.Task.Result.Receiver.Should().Be(message.Receiver);
}
public static void CommandValidation(CreateMessageCommand command)
{
if (command.Name == null || command.Email == null || command.Text == null)
{
throw new InternalSystemException("Fields can't be empty!");
}
else if (!nameRegex.IsMatch(command.Name) || !emailRegex.IsMatch(command.Email) || !textRegex.IsMatch(command.Text))
{
throw new InternalSystemException("Please provide correct data!");
}
}
public Task <HttpResponseMessage> Post([FromBody] dynamic body)
{
var commandMessage = new CreateMessageCommand(
bodyMessage: (string)body.bodyMessage,
destination: (string)body.destination,
date: DateTime.Now,
idUser: (string)body.idUser
);
var message = _serviceMessage.Create(commandMessage);
return(CreateResponse(HttpStatusCode.Created, message));
}
public async Task Should_fail_with_status_bad_request_when_client_id_is_null_or_empty(string clientId)
{
// Arrange
var command = new CreateMessageCommand("The message", clientId);
var handler = new CreateMessageCommandHandler(_mockedRepository.Object);
// Act
var result = await handler.Handle(command, default);
// Assert
Assert.True(result.Failed);
Assert.IsType <BadRequest>(result.StatusCode);
}
public ValidationResult Handler(CreateMessageCommand command)
{
Message message = new Message(command.Sentence, command.TypeId, command.Title);
Type type = _typeRepository.GetById(command.TypeId);
RuleFor(m => m.Type).NotNull().WithMessage("The Type is empty or nullable");
//1-I need implement a validation to repository
Boolean result = _messageRepository.Create(message);
return(Validate(message));
}
public Message Create(CreateMessageCommand command)
{
var message = new Message(command.BodyMessage, command.Destination, command.Date, command.IdUser, false);
message.Validate();
_repository.Create(message);
if (Commit())
{
return(message);
}
return(null);
}
public void Executing_it_should_create_unit_of_work_with_factory()
{
var factoryMock = MockRepository.GenerateMock<IUnitOfWorkFactory>();
var contextMock = MockRepository.GenerateMock<IUnitOfWorkContext>();
factoryMock.Expect(t => t.CreateUnitOfWork()).Repeat.Once().Return(contextMock);
Func<CreateMessageCommand, Message> creation = (c) => new Message(c.Text);
var executor = new CreatingCommandExecutor<CreateMessageCommand, Message>(creation, factoryMock);
var cmd = new CreateMessageCommand();
executor.Execute(cmd);
factoryMock.VerifyAllExpectations();
}
public async Task <ActionResult <bool> > SaveMessage([FromBody] Message message)
{
var createMessageCommand = new CreateMessageCommand()
{
Message = message,
};
var result = await _mediator.Send(createMessageCommand);
if (result.Type == CommandResultTypeEnum.InvalidInput)
{
return(new BadRequestResult());
}
return(new OkObjectResult(result.Result));
}
public void Executing_it_should_create_unit_of_work_with_factory()
{
var factoryMock = MockRepository.GenerateMock <IUnitOfWorkFactory>();
var contextMock = MockRepository.GenerateMock <IUnitOfWorkContext>();
factoryMock.Expect(t => t.CreateUnitOfWork()).Repeat.Once().Return(contextMock);
Func <CreateMessageCommand, Message> creation = (c) => new Message(c.Text);
var executor = new CreatingCommandExecutor <CreateMessageCommand, Message>(creation, factoryMock);
var cmd = new CreateMessageCommand();
executor.Execute(cmd);
factoryMock.VerifyAllExpectations();
}
public async Task SendMessageAsync(CreateMessageCommand command)
{
await DispatchAsync(command);
command.CreatedAt = DateTime.UtcNow;
if (_connections.ContainsKey(command.Receiver))
{
await Clients.Client(_connections[command.Receiver]).SendAsync(Channels.Chat.Messages, command);
}
if (_connections.ContainsKey(command.RequestBy))
{
await Clients.Client(_connections[command.RequestBy]).SendAsync(Channels.Chat.Messages, command);
}
}
public ActionResult Contact(CreateMessageCommand command)
{
if (!ModelState.IsValid)
{
return(View("Contact"));
}
if (CaptchaIsValid())
{
var result = _commandBus.Send(command);
return(JsonMessage(result));
}
ViewBag.ErrMessage = NotificationViewMessage.InvalidaCaptcha;
return(View("Contact"));
}
private async Task OnMessageCreated(DiscordClient client, MessageCreateEventArgs eventArgs)
{
try
{
var message = eventArgs.Message;
var guild = eventArgs.Guild;
if (MessageIsCommand(message.Content))
{
return;
}
if (!IsReleventMessage(message))
{
return;
}
if (IsPrivateMessageChannel(message.Channel))
{
await message.Channel.SendMessageAsync("https://cdn.discordapp.com/emojis/740563346599968900.png?v=1");
return;
}
var todoMessage = new MessageCommandPayload(message, guild);
var command = new CreateMessageCommand(todoMessage);
_emoteCommandQueue.Enqueue(command);
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(OnMessageCreated));
var eventContextError = new EventErrorContext()
{
EventName = nameof(OnMessageCreated),
User = eventArgs.Author,
Channel = eventArgs.Channel,
Guild = eventArgs.Guild,
Message = eventArgs.Message
};
await _discordErrorLogger.LogDiscordError(eventContextError, ex.ToString());
}
}
public async Task <IActionResult> CreateMessage(int userId, CreateMessageCommand request)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
request.SenderId = userId;
var message = await Mediator.Send(request);
if (message != null)
{
return(CreatedAtRoute("GetMessage", new { userId = userId, messageId = message.Id }, message));
}
return(BadRequest());
}
public MessageEntity MapSingle(CreateMessageCommand message)
{
var userCommandMapper = new UserToEntityMapper();
var hashMapper = new HashTagCommandToEntityMapper();
{
var entity = new MessageEntity
{
MessageText = message.MessageText,
HashTags = hashMapper.MapBunch(message.HashTags),
MediaType = message.MediaType,
User = userCommandMapper.MapSingle(message.User),
PostDate = message.PostDate,
Id = message.Id,
NetworkId = message.NetworkId
};
return(entity);
}
}
public async Task Should_succeed_with_status_created_when_create_is_valid()
{
// Arrange
_mockedRepository.Setup(x => x.UnitOfWork).Returns(_mockedUnitOfWork.Object);
_mockedUnitOfWork.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(1);
var command = new CreateMessageCommand("New message", Guid.NewGuid().ToString());
var handler = new CreateMessageCommandHandler(_mockedRepository.Object);
// Act
var result = await handler.Handle(command, default);
// Assert
Assert.True(result.Succeeded);
Assert.IsType <Created>(result.StatusCode);
Assert.Equal(command.Message, result.Value.Message);
Assert.Equal(command.ClientId, result.Value.ClientId);
_mockedRepository.Verify(x => x.Add(It.IsAny <BoardMessage>()), Times.Once);
_mockedUnitOfWork.Verify(x => x.SaveChangesAsync(default), Times.Once);
public async Task <CommandResult> Handle(CreateMessageCommand command)
{
var mapper = new MessageCommandToEntityMapper();
var message = mapper.MapSingle(command);
if (!context.Messages.Any(z => z.NetworkId == message.NetworkId &&
z.User.NetworkId == message.User.NetworkId))
{
if (!context.Users.Any(x => x.NetworkId == message.User.NetworkId))
{
context.Users.Add(message.User);
await context.SaveChangesAsync();
}
message.User = await context.Users.FirstOrDefaultAsync(x => x.NetworkId == message.User.NetworkId);
message.PostDate = message.PostDate?.ToUniversalTime();
context.Messages.Add(message);
foreach (var tag in message.HashTags)
{
var tagToLink = await context.Hashtags.FirstOrDefaultAsync(x => x.HashTag == tag.HashTag);
if (tagToLink != null)
{
var tag2Message = new MessageHashTagRelationsEntity
{
HashTagEntity = tagToLink,
MessageEntity = message
};
context.TaggedMessages.Add(tag2Message);
}
}
await context.SaveChangesAsync();
}
return(new CommandResult {
Success = true
});
}
public async Task <IActionResult> Contact(CreateMessageCommand command)
{
if (!ModelState.IsValid)
{
ViewBag.ShowMessage = true;
ViewBag.Message = "Something went wrong";
return(View());
}
if (string.IsNullOrEmpty(command.Answer) || command.Answer.ToLowerInvariant() != "martha")
{
ViewBag.ShowMessage = true;
ViewBag.Message = "Answer isn't correct. Try again!";
return(View());
}
try
{
CreateMessageValidator.CommandValidation(command);
await _messageService.AddMessageAsync(command);
ViewBag.Added = true;
return(View());
}
catch (InternalSystemException ex)
{
ViewBag.ShowMessage = true;
ViewBag.Message = ex.Message;
return(View());
}
catch (Exception)
{
ViewBag.ShowMessage = true;
ViewBag.Message = "Something went wrong!";
return(View());
}
}
public async void Handle_ShouldCallInsertAttachment_WhenRequestHasAttachments()
{
// ARRANGE
var validator = new CreateMessageCommandValidator();
var messageRepositoryMock = new Mock <IMessageRepository>();
var attachmentRepositoryMock = new Mock <IAttachmentRepository>();
var loggerMock = new Mock <ILogger>();
var handler = new CreateMessageCommandHandler(
messageRepositoryMock.Object,
attachmentRepositoryMock.Object,
loggerMock.Object,
validator
);
var command = new CreateMessageCommand()
{
Message = new Domain.Models.Messages.Message()
{
MessageId = "1",
Attachments = new List <Attachment>()
{
new Attachment(),
new Attachment(),
}
}
};
messageRepositoryMock.Setup(x => x.InsertMessage(It.IsAny <Domain.Models.Messages.Message>())).ReturnsAsync(1);
// ACT
var response = await handler.Handle(command, new CancellationToken());
// ASSERT
Assert.Equal(CommandResultTypeEnum.Success, response.Type);
messageRepositoryMock.Verify(x => x.InsertMessage(It.IsAny <Domain.Models.Messages.Message>()), Times.Once);
attachmentRepositoryMock.Verify(x => x.InsertAttachment(It.IsAny <Attachment>(), command.Message.MessageId), Times.Exactly(2));
}
public void Executing_it_should_invoke_action()
{
var invoked = false;
var factoryMock = MockRepository.GenerateMock <IUnitOfWorkFactory>();
var contextMock = MockRepository.GenerateMock <IUnitOfWorkContext>();
factoryMock.Stub(t => t.CreateUnitOfWork()).Return(contextMock);
contextMock.Expect(t => t.Accept()).Repeat.Once();
Func <CreateMessageCommand, Message> creation = (c) =>
{
invoked = true;
return(new Message(c.Text));
};
var executor = new CreatingCommandExecutor <CreateMessageCommand, Message>(creation, factoryMock);
var cmd = new CreateMessageCommand();
executor.Execute(cmd);
invoked.Should().BeTrue();
}
public MessageModel Put([FromRoute] int id, [FromBody] CreateMessageCommand cmd)
{
_messageService.messages[id] = cmd.message;
return(new MessageModel(id, _messageService.messages[id]));
}
public void Executing_it_should_invoke_action()
{
var invoked = false;
var factoryMock = MockRepository.GenerateMock<IUnitOfWorkFactory>();
var contextMock = MockRepository.GenerateMock<IUnitOfWorkContext>();
factoryMock.Stub(t => t.CreateUnitOfWork()).Return(contextMock);
contextMock.Expect(t => t.Accept()).Repeat.Once();
Func<CreateMessageCommand, Message> creation = (c) =>
{
invoked = true;
return new Message(c.Text);
};
var executor = new CreatingCommandExecutor<CreateMessageCommand, Message>(creation, factoryMock);
var cmd = new CreateMessageCommand();
executor.Execute(cmd);
invoked.Should().BeTrue();
}
public IActionResult Post([FromBody] CreateMessageCommand cmd)
{
_messageService.AddMessage(cmd.message);
return(NoContent());
}
public async Task <ActionResult <int> > Create([FromBody] CreateMessageCommand command)
{
var messageId = await Mediator.Send(command);
return(Ok(messageId));
}
public async Task <ActionResult <MessageViewModel> > CreateMessage(CreateMessageCommand command)
{
var result = await Mediator.Send(command);
return(Ok(result));
}
public void SendMessage(string message, string connectionId)
{
var command = new CreateMessageCommand(RealTimeChatUsersService.Users[connectionId], message);
this.mediator.Send(command);
}
public async Task <ActionResult> Create(int receiverId,
CreateMessageCommand command)
=> await this.Send(command.SetId(receiverId));
