/// <inheritdoc />
public long Handle(DeleteMessageCommand <int> command)
{
using (var db = _connectionInformation.GetDatabase())
{
db.Database.BeginTrans();
try
{
var col = db.Database.GetCollection(_tableNameHelper.QueueName);
var result = col.Delete(command.QueueId);
//note - continue in case we have orphaned records, regardless of result.
var meta = db.Database.GetCollection <Schema.MetaDataTable>(_tableNameHelper.MetaDataName);
meta.DeleteMany(x => x.QueueId == command.QueueId);
var status = db.Database.GetCollection <Schema.StatusTable>(_tableNameHelper.StatusName);
status.DeleteMany(x => x.QueueId == command.QueueId);
var errorTrack = db.Database.GetCollection <Schema.ErrorTrackingTable>(_tableNameHelper.ErrorTrackingName);
errorTrack.DeleteMany(x => x.QueueId == command.QueueId);
var metaErrors = db.Database.GetCollection <Schema.MetaDataErrorsTable>(_tableNameHelper.MetaDataErrorsName);
metaErrors.DeleteMany(x => x.QueueId == command.QueueId);
db.Database.Commit();
return(result ? 1 : 0);
}
catch
{
db.Database.Rollback();
throw;
}
}
}
public async Task HandleAsync(DeleteMessageCommand command)
{
var msg = await _context.Message.Where(x => x.Id == command.Id).FirstOrDefaultAsync();
_context.Message.Remove(msg);
await _context.SaveChangesAsync();
}
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 async Task Should_succeed_with_status_deleted_when_delete_is_valid()
{
// Arrange
var message = MockedMessageBuilder
.SetId(1)
.SetMessage("The message")
.SetClientId(Guid.NewGuid().ToString())
.Build()
.Object;
_mockedRepository.Setup(x => x.GetAsync(It.IsAny <int>())).ReturnsAsync(message);
_mockedRepository.Setup(x => x.UnitOfWork).Returns(_mockedUnitOfWork.Object);
_mockedUnitOfWork.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).ReturnsAsync(1);
var command = new DeleteMessageCommand(message.Id, message.ClientId);
var handler = new DeleteMessageCommandHandler(_mockedRepository.Object);
// Act
var result = await handler.Handle(command, default);
// Assert
Assert.True(result.Succeeded);
Assert.IsType <Deleted>(result.StatusCode);
_mockedRepository.Verify(x => x.GetAsync(command.MessageId), Times.Once);
_mockedRepository.Verify(x => x.Remove(message), Times.Once);
_mockedUnitOfWork.Verify(x => x.SaveChangesAsync(default), Times.Once);
public void Create_Default()
{
const int id = 19334;
var test = new DeleteMessageCommand <long>(id);
Assert.Equal(id, test.QueueId);
}
public void Create_Default(string number)
{
var id = new RedisQueueId(number);
var test = new DeleteMessageCommand(id);
Assert.Equal(id, test.Id);
}
public void Delete(string pipeName, string messageName)
{
var deleteMessageCommand = new DeleteMessageCommand(
pipeName,
Guid.Parse(messageName));
_commandProcessor.Send(deleteMessageCommand);
Request.CreateResponse(HttpStatusCode.OK);
}
public async Task Should_fail_with_status_bad_request_when_client_id_is_null_or_empty(string clientId)
{
// Arrange
var command = new DeleteMessageCommand(1, clientId);
var handler = new DeleteMessageCommandHandler(_mockedRepository.Object);
// Act
var result = await handler.Handle(command, default);
// Assert
Assert.True(result.Failed);
Assert.IsType <BadRequest>(result.StatusCode);
}
/// <inheritdoc />
public void Handle(DeleteMessageCommand <long> command, IDbCommand dbCommand, CommandStringTypes commandType)
{
//set ID if not set
if (!dbCommand.Parameters.Contains("@QueueID"))
{
var param = dbCommand.CreateParameter();
param.ParameterName = "@QueueID";
param.DbType = DbType.Int64;
param.Value = command.QueueId;
dbCommand.Parameters.Add(param);
}
dbCommand.CommandText = _commandCache.GetCommand(commandType);
}
public async Task Should_fail_with_status_not_found_when_deleting_message_that_does_not_exist()
{
// Arrange
_mockedRepository.Setup(x => x.GetAsync(It.IsAny <int>())).ReturnsAsync((BoardMessage)null);
var command = new DeleteMessageCommand(1, Guid.NewGuid().ToString());
var handler = new DeleteMessageCommandHandler(_mockedRepository.Object);
// Act
var result = await handler.Handle(command, default);
// Assert
Assert.True(result.Failed);
Assert.IsType <NotFound>(result.StatusCode);
_mockedRepository.Verify(x => x.GetAsync(command.MessageId), Times.Once);
}
public static DeleteMessageCommand ToDeleteMessageCommand(this JObject jObj)
{
var result = new DeleteMessageCommand();
var values = jObj.ToObject <Dictionary <string, object> >();
if (values.TryGet(MedikitApiConstants.SearchNames.AssertionToken, out string assertionToken))
{
result.AssertionToken = assertionToken;
}
if (values.TryGet(MedikitApiConstants.DeleteMessageNames.MessageIds, out string message))
{
result.MessageIds = JArray.Parse(message).Select(_ => _.ToString()).ToList();
}
return(result);
}
public async Task DeleteMessageCommandHandler_ShouldSoftDeleteMessage()
{
// Arrange
DeleteMessageCommand request = new DeleteMessageCommand {
MessageId = 1
};
IQueryable <Message> databaseMessage = new[]
{
new Message {
MessageId = 1, IsDeleted = false
}
}
.AsQueryable()
.BuildMock()
.Object;
Message passedMessage = null;
_unitOfWorkMock
.Setup(m => m.Messages.GetById(request.MessageId))
.Returns(databaseMessage);
_unitOfWorkMock
.Setup(m => m.Messages.Update(It.IsAny <Message>()))
.Callback <Message>(m => passedMessage = m);
_unitOfWorkMock
.Setup(m => m.CommitAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(1);
DeleteMessageCommand.Handler handler = new DeleteMessageCommand.Handler(_unitOfWorkMock.Object);
// Act
await handler.Handle(request);
// Assert
_unitOfWorkMock.Verify(m => m.Messages.Update(It.IsAny <Message>()), Times.Once);
Assert.NotNull(passedMessage);
Assert.Equal(request.MessageId, passedMessage.MessageId);
Assert.True(passedMessage.IsDeleted);
_unitOfWorkMock.Verify(m => m.CommitAsync(It.IsAny <CancellationToken>()), Times.AtLeastOnce);
}
public async Task <ActionResult> DeleteMessage([FromRoute] int messageId, CancellationToken cancellationToken = default)
{
// Check if the message exists
MessageExistsQuery existsQuery = new MessageExistsQuery {
MessageId = messageId
};
bool exists = await _mediator.Send(existsQuery, cancellationToken);
if (!exists)
{
return(NotFound(new ErrorResource
{
StatusCode = StatusCodes.Status404NotFound,
Message = $"Message with ID '{messageId}' does not exist"
}));
}
// Check if the user is the author of the message and thus allowed to update it
IsAuthorOfMessageQuery isAuthorQuery = new IsAuthorOfMessageQuery {
MessageId = messageId
};
bool isAuthor = await _mediator.Send(isAuthorQuery, cancellationToken);
if (!isAuthor)
{
return(StatusCode(StatusCodes.Status403Forbidden, new ErrorResource
{
StatusCode = StatusCodes.Status403Forbidden,
Message = "Only the author of a message is allowed to delete a message"
}));
}
// Delete the message
DeleteMessageCommand deleteCommand = new DeleteMessageCommand {
MessageId = messageId
};
await _mediator.Send(deleteCommand, cancellationToken);
return(NoContent());
}
private void btnDelete_Click(object sender, EventArgs e)
{
var msgs = lstMessages.SelectedItems.Cast <ListViewItem>().Select(item => (IMessage)item.Tag);
if (msgs.Any())
{
string confirm;
if (msgs.Count() == 1)
{
confirm = "Delete this message?";
}
else
{
confirm = "Delete these " + msgs.Count() + " messages?";
}
if (MessageBox.Show(confirm, "Confirm Delete", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
// delete messages from inbox/outbox/sentbox
foreach (var msg in msgs)
{
if (Empire.Current.IncomingMessages.Contains(msg) || Empire.Current.SentMessages.Contains(msg))
{
var cmd = new DeleteMessageCommand(msg);
Empire.Current.Commands.Add(cmd);
cmd.Execute();
}
var sendCommand = Empire.Current.Commands.OfType <SendMessageCommand>().SingleOrDefault(cmd => cmd.Message == msg);
if (sendCommand != null)
{
Empire.Current.Commands.Remove(sendCommand);
}
}
// refresh
BindEmpire(empire, tabDiplomacy);
}
}
else
{
MessageBox.Show("Please select one or more messages to delete before clicking the delete button.");
}
}
/// <inheritdoc />
public long Handle(DeleteMessageCommand <long> command)
{
using (var connection = _dbConnectionFactory.Create())
{
connection.Open();
using (var trans = _transactionFactory.Create(connection).BeginTransaction())
{
using (var commandSql = connection.CreateCommand())
{
commandSql.Transaction = trans;
//delete the meta data record
_prepareCommand.Handle(command, commandSql, CommandStringTypes.DeleteFromMetaData);
commandSql.ExecuteNonQuery();
//delete the message body
_prepareCommand.Handle(command, commandSql, CommandStringTypes.DeleteFromQueue);
commandSql.ExecuteNonQuery();
//delete any error tracking information
_prepareCommand.Handle(command, commandSql, CommandStringTypes.DeleteFromErrorTracking);
commandSql.ExecuteNonQuery();
_prepareCommand.Handle(command, commandSql, CommandStringTypes.DeleteFromMetaDataErrors);
commandSql.ExecuteNonQuery();
//delete status record
if (!_options.Value.EnableStatusTable)
{
trans.Commit();
return(1);
}
_prepareCommand.Handle(command, commandSql, CommandStringTypes.DeleteFromStatus);
commandSql.ExecuteNonQuery();
trans.Commit();
return(1);
}
}
}
}
public async Task Should_fail_with_status_bad_request_when_attempting_to_delete_message_created_by_another_client()
{
// Arrange
var message = MockedMessageBuilder
.SetId(1)
.SetMessage("The message")
.SetClientId(Guid.NewGuid().ToString())
.Build()
.Object;
_mockedRepository.Setup(x => x.GetAsync(It.IsAny <int>())).ReturnsAsync(message);
var command = new DeleteMessageCommand(message.Id, Guid.NewGuid().ToString());
var handler = new DeleteMessageCommandHandler(_mockedRepository.Object);
// Act
var result = await handler.Handle(command, default);
// Assert
Assert.True(result.Failed);
Assert.IsType <BadRequest>(result.StatusCode);
_mockedRepository.Verify(x => x.GetAsync(command.MessageId), Times.Once);
}
private async Task OnMessageDeleted(DiscordClient client, MessageDeleteEventArgs eventArgs)
{
try
{
var channel = eventArgs.Channel;
var message = eventArgs.Message;
var guild = eventArgs.Guild;
if (IsPrivateMessageChannel(channel))
{
return;
}
var messageId = message.Id;
var todoMessage = new MessageIdPayload(messageId, guild);
var command = new DeleteMessageCommand(todoMessage);
_emoteCommandQueue.Enqueue(command);
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(OnMessageDeleted));
var eventContextError = new EventErrorContext()
{
EventName = nameof(OnMessageDeleted),
User = null,
Channel = eventArgs.Channel,
Guild = eventArgs.Guild
};
await _discordErrorLogger.LogDiscordError(eventContextError, ex.ToString());
}
}
/// <inheritdoc />
public long Handle(DeleteMessageCommand <long> command)
{
return(!_databaseExists.Exists(_connectionInformation.ConnectionString) ? 0 : _decorated.Handle(command));
}
/// <inheritdoc />
public bool Handle(DeleteMessageCommand <string> command)
{
var result = _deleteLua.Execute(command.QueueId);
return(result.HasValue && result.Value == 1);
}
public async Task <ActionResult> Delete(
[FromRoute] DeleteMessageCommand command)
=> await this.Send(command);
public void MySetup() => _command = new DeleteMessageCommand(Logger, State);
public Task <bool> DeleteSentboxMessages(DeleteMessageCommand command)
{
command.Source = EHealthBoxSources.SENTBOX;
return(_mediator.Send(command));
}
public async Task Handle(DeleteMessageCommand command) => await command.Execute(_awsSqsClient);
public JsonResult DeleteMessage(DeleteMessageCommand command)
{
var result = _commandBus.Send(command);
return(JsonMessage(result));
}
public void Create_Default(string number)
{
var test = new DeleteMessageCommand <string>(number);
Assert.Equal(number, test.QueueId);
}
