public async Task <BlogResponse> DeleteAsync(string id)
{
var response = new BlogResponse();
var message = await _messages.FindAsync(id.ToObjectId());
if (message is null)
{
response.IsFailed($"The message id not exists.");
return(response);
}
if (message.Reply is not null)
{
if (message.Reply.Any())
{
response.IsFailed($"The reply message is not empty.");
return(response);
}
}
await _messages.DeleteAsync(id.ToObjectId());
return(response);
}
public async Task HandleNotificationAsync(IMessageDelete notification, CancellationToken ct)
{
var message = notification;
var channelId = notification.ChannelID;
var guild = notification.GuildID;
var isThreadChannel = await _threadService.IsThreadChannelAsync(channelId, ct);
if (!isThreadChannel)
{
return;
}
using var logScope = MessageLogMessages.BeginMessageNotificationScope(_logger, guild.Value.Value, channelId.Value, notification.ID.Value);
MessageLogMessages.MessageDeletedHandling(_logger);
await TryTrackMessageAsync(
guild,
null,
async (_) =>
{
MessageLogMessages.MessageRecordDeleting(_logger);
await _messageRepository.DeleteAsync(notification.ID.Value);
MessageLogMessages.MessageRecordDeleted(_logger);
});
MessageLogMessages.MessageDeletedHandled(_logger);
}
public async Task <bool> DeleteAsync(int id)
{
try
{
return(await _messageRepository.DeleteAsync(id));
}
catch (DataException)
{
throw;
}
}
public async Task OnMessageDeleteAsync(Message message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
await _messageRepository.DeleteAsync(message);
await NotifyClients(message.Chat.Id, client => client.onMessageDeleteAsync(message));
}
public async Task <ServiceResponse <bool> > DeleteMessageAsync(MessageGetDTO message)
{
ServiceResponse <bool> serviceResponse = new ServiceResponse <bool>();
try
{
if ((DateTime.UtcNow.Day - message.DateTime.Day) >= 1)
{
serviceResponse.Success = false;
serviceResponse.Message = "Срок истек";
return(serviceResponse);
}
var b = await _messageRepository.HasUserWithId(message.UserId, message.Id);
if (!b)
{
serviceResponse.Success = false;
serviceResponse.Message = "Нет доступа";
return(serviceResponse);
}
if (await _messageRepository.DeleteAsync(message.Id))
{
await _context.SaveChangesAsync();
_chatEventRepository.Add(new ChatEvent()
{
UserId = message.UserId,
DialogId = message.DialogId,
TypeOfActionId = (int)ActionTypes.MessageDeleted
});
await _context.SaveChangesAsync();
_botNotifier.NotifyAsync();
serviceResponse.Data = true;
}
else
{
serviceResponse.Success = false;
serviceResponse.Message = "Сообщение не найдено";
return(serviceResponse);
}
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message + ex.InnerException;
return(serviceResponse);
}
return(serviceResponse);
}
public async Task <bool> DeleteMessagesForUserAsync(string userId, CancellationToken cancellationToken = default(CancellationToken))
{
var messages = await _messageRepository.GetMessagesByUserSendRecIdAsync(userId);
foreach (var m in messages)
{
foreach (var mr in m.MessageRecipients.ToList())
{
await _messageRecipientRepository.DeleteAsync(mr, cancellationToken);
}
await _messageRepository.DeleteAsync(m, cancellationToken);
}
var messageRecipients = await _messageRecipientRepository.GetMessageRecipientByUserAsync(userId);
foreach (var m in messageRecipients)
{
await _messageRecipientRepository.DeleteAsync(m, cancellationToken);
}
return(true);
}
/// <summary>
/// 删除消息
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
public async Task DeleteMessage(int Id)
{
await repository.DeleteAsync(Id);
}
public async Task RemoveAsync(int id)
{
await _messageRepository.DeleteAsync(id);
}
public async Task DeleteMessageAsync(ObjectId messageId) => await _messageRepository.DeleteAsync(messageId);
private async Task DeliverMessageAsync(Message message)
{
message.NumberOfDeliveryAttempts++;
bool isLastAttempt = message.NumberOfDeliveryAttempts >= 3;
var deliveryResults = new List <DeliveryResult>();
try
{
var remainingRecipients = new List <Recipient>(message.Recipients);
var localDelivery = new LocalDelivery(_accountRepository, _messageRepository, _folderRepository, _log);
deliveryResults.AddRange(await localDelivery.DeliverAsync(message, remainingRecipients.Where(recipient => recipient.AccountId != 0).ToList()));
var externalDelivery = new ExternalDelivery(_messageRepository, _dnsClient, _log);
deliveryResults.AddRange(await externalDelivery.DeliverAsync(message, remainingRecipients.Where(recipient => recipient.AccountId == 0).ToList()));
var failedRecipients =
deliveryResults.Where(result => result.ReplyCodeSeverity == ReplyCodeSeverity.PermanentNegative ||
(isLastAttempt && result.ReplyCodeSeverity == ReplyCodeSeverity.TransientNegative));
await SubmitBounceMessageAsync(message, failedRecipients);
var deliveryCompleted =
deliveryResults.Any(result => result.ReplyCodeSeverity == ReplyCodeSeverity.TransientNegative);
if (isLastAttempt || !deliveryCompleted)
{
await _messageRepository.DeleteAsync(message);
}
}
catch (Exception ex)
{
var logEvent = new LogEvent()
{
EventType = LogEventType.Application,
LogLevel = LogLevel.Error,
Protocol = "SMTPD",
};
if (isLastAttempt)
{
logEvent.Message = "Failed delivering message due to an error. Giving up.";
}
else
{
logEvent.Message = "Failed delivering message due to an error. Will retry later.";
}
_log.LogException(logEvent, ex);
if (isLastAttempt)
{
await _messageRepository.DeleteAsync(message);
}
else
{
await _messageRepository.UpdateAsync(message);
}
}
}
