public static Message ToModel(this MessageAggregate message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var files = message.MessageAttachments == null ? new List <MessageJoinedFile>() : message.MessageAttachments.Select(a => a.ToModel()).ToList();
return(new Message
{
Id = message.Id,
Content = message.Content,
From = message.From,
To = message.To,
CreateDateTime = message.CreateDateTime,
IsRead = message.IsRead,
JoinedFiles = files,
ParentId = message.ParentId,
ProductId = message.ProductId,
ClientServiceId = message.ClientServiceId,
ServiceId = message.ServiceId,
Subject = message.Subject
});
}
public async Task <bool> Add(MessageAggregate message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
var record = message.ToModel();
_context.Messages.Add(record);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
return(true);
}
catch
{
transaction.Rollback();
return(false);
}
}
}
public async Task Handle(SendMessageCommand message, IMessageHandlerContext context)
{
var messageAggregate = new MessageAggregate(context);
messageAggregate.Create(message.Content, message.SenderSubject);
await messageAggregate.Send();
await _messageAggregateRepository.InsertMessage(messageAggregate);
}
public Task <bool> InsertMessage(MessageAggregate message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
return(InsertMessage(message.State));
}
public async Task <Result> Handle(Command command, CancellationToken cancellationToken)
{
var message = MessageAggregate.CreateMessage(command.UserId, command.Text);
await _repository.Add(message);
var result = new Result
{
Id = message.Id
};
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <HandleResultDto> Handle(AddMessageCommand request, CancellationToken cancellationToken)
{
var message = new MessageAggregate(request.UserName, request.ImgUrl, request.Message);
await this._messageRepository.AddAsync(message, cancellationToken);
await this._messageRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
return(new HandleResultDto
{
State = 1
});
}
public void Enrich(IHalResponseBuilder halResponseBuilder, MessageAggregate message)
{
if (halResponseBuilder == null)
{
throw new ArgumentNullException(nameof(halResponseBuilder));
}
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
halResponseBuilder.AddEmbedded(e => e.AddObject(_responseBuilder.GetMessage(message),
(l) =>
{
l.AddSelf(Constants.RouteNames.Messages + "/" + message.Id);
}));
}
public async Task Handle(AddMessageCommand message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var messageAggregate = new MessageAggregate
{
Id = Guid.NewGuid().ToString(),
Content = message.Content,
From = message.From,
To = message.To,
IsRead = false,
ProductId = message.ProductId,
ServiceId = message.ServiceId,
ParentId = message.ParentId,
Subject = message.Subject,
ClientServiceId = message.ClientServiceId,
CreateDateTime = DateTime.UtcNow
};
await _messageRepository.Add(messageAggregate);
_eventPublisher.Publish(new MessageAddedEvent
{
Id = messageAggregate.Id,
Content = messageAggregate.Content,
From = messageAggregate.From,
To = messageAggregate.To,
IsRead = messageAggregate.IsRead,
ProductId = messageAggregate.ProductId,
ServiceId = messageAggregate.ServiceId,
ClientServiceId = messageAggregate.ClientServiceId,
ParentId = messageAggregate.ParentId,
Subject = messageAggregate.Subject,
CreateDateTime = messageAggregate.CreateDateTime,
CommonId = message.CommonId
});
}
