public async Task AddMessageAttachmentAsync(AddMessageAttachmentRequest request)
{
try
{
var member = await _memberService.GetMemberSummaryBySaasUserIdAsync(request.SaasUserId);
var message = await _messageService.GetMessageByIdAsync(request.MessageId);
if (message.Sender.Id != member.Id)
{
throw new Exception(String.Format(LanguageResources.Msg_AccessPermission, message.Id));
}
var attachmentsCount = await _messageService.GetMessageAttachmentsCount(message.Id);
if (attachmentsCount == 10)
{
throw new Exception(LanguageResources.Msg_LimitedAttachments);
}
await _messageService.AddMessageAttachmentAsync(request);
await _messageNotificationHub.OnAddMessageAttachment(member, message);
}
catch (ServiceException ex)
{
if (ex.Errors.Any(x => x.Description == "Message does not exist."))
{
_logger.Event(PropertyNames.EventId).With.Message("Exception: Message does not exist. MessageId: {messageId}", request.MessageId).Exception(ex).AsError();
throw new Exception(String.Format(LanguageResources.Msg_NotFound, request.MessageId));
}
}
}
public void ShouldThrowIfAttachmentLimitExceeded()
{
// Arrange
var request = new AddMessageAttachmentRequest("864EB62D-D833-47FA-8A88-DDBFE76AE6A7", new Guid("A455F139-09E6-4EF5-B55A-D4C94D05DFDE"), null, "jpg", "image/jpeg", 0);
var member = new Member
{
Id = new Guid("ABF2CA08-5374-4CED-BE87-6EA93A8B90DA")
};
_messageRepositoryMock.Setup(x => x.GetMessageWithOwnerAndForwardMessageAsync(It.IsAny <Guid>()))
.ReturnsAsync(new Message {
OwnerId = member.Id
})
.Verifiable();
_memberRepositoryMock.Setup(x => x.GetMemberBySaasUserIdAsync(It.IsAny <string>()))
.ReturnsAsync(member)
.Verifiable();
_attachmentRepositoryMock.Setup(x => x.GetMessageAttachmentsCountAsync(It.IsAny <Guid>()))
.ReturnsAsync(MessageAttachmentsLimit)
.Verifiable();
// Act
Func <Task> act = async() => { await _messageService.AddMessageAttachmentAsync(request); };
// Assert
act.Should().Throw <NetKitChatInvalidOperationException>()
.And.Message.Should().Be($"Unable to add message attachment. Attachment limit {MessageAttachmentsLimit} exceeded.");
VerifyMocks();
}
public async Task <IActionResult> AddMessageAttachmentAsync(Guid messageId, IFormCollection model)
{
// TODO: Improve validation to validate both WebAPI and SignalR request models in the same place.
var file = model?.Files?.FirstOrDefault();
if (file == null || file.Length <= 0)
{
return(BadRequest("Attached file can not be empty"));
}
// TODO: Replace this helper by some NuGet or smth else.
var extension = AttachmentsUtils.GetExtensionFromMimeType(file.ContentType);
var supportedExtensions = new[] { "jpg", "png", "mp4" };
if (extension == null || !supportedExtensions.Contains(extension))
{
return(BadRequest($"Only {string.Join(", ", supportedExtensions)} formats are supported"));
}
using (var stream = file.OpenReadStream())
{
var request = new AddMessageAttachmentRequest(GetCurrentSaasUserId(), messageId, stream, extension, file.ContentType, file.Length);
var result = await _messageSocketService.AddMessageAttachmentAsync(request);
return(Ok(result));
}
}
public void ShouldThrowIfMemberIsNotMessageOwner()
{
// Arrange
_messageRepositoryMock.Setup(x => x.GetMessageWithOwnerAndForwardMessageAsync(It.IsAny <Guid>()))
.ReturnsAsync(new Message {
OwnerId = new Guid("F19AD922-B0DB-4686-8CB4-F51902800CAE")
})
.Verifiable();
_memberRepositoryMock.Setup(x => x.GetMemberBySaasUserIdAsync(It.IsAny <string>()))
.ReturnsAsync(new Member {
Id = new Guid("ABF2CA08-5374-4CED-BE87-6EA93A8B90DA")
})
.Verifiable();
var request = new AddMessageAttachmentRequest("864EB62D-D833-47FA-8A88-DDBFE76AE6A7", new Guid("A455F139-09E6-4EF5-B55A-D4C94D05DFDE"), null, "jpg", "image/jpeg", 0);
// Act
Func <Task> act = async() => { await _messageService.AddMessageAttachmentAsync(request); };
// Assert
act.Should().Throw <NetKitChatAccessForbiddenException>()
.And.Message.Should().Be($"Unable to add message attachment. Message {nameof(request.MessageId)}:{request.MessageId} owner required.");
VerifyMocks();
}
public async Task <AttachmentResponse> AddMessageAttachmentAsync(AddMessageAttachmentRequest request)
{
var message = await UnitOfWork.MessageRepository.GetMessageByIdAsync(request.MessageId);
Ensure.That(message).WithException(x => new NotFoundException(new ErrorDto(ErrorCode.NotFound, "Message does not exist."))).IsNotNull();
var messageAttachments = await UnitOfWork.AttachmentRepository.GetMessageAttachmentsAsync(message.Id);
if (messageAttachments.Count == _attachmentConfiguration.Limit)
{
throw new LimitedAttachmentsException(new ErrorDto(ErrorCode.LimmitedAttachmentsError, "Attachments count is limited."));
}
var attachment = new Domain.Attachment.Attachment
{
Id = Guid.NewGuid(),
ContentType = request.ContentType,
Created = DateTimeOffset.UtcNow,
FileName = Guid.NewGuid() + "." + request.Extension,
MessageId = request.MessageId,
Size = request.Size
};
// Save attachment in database
await UnitOfWork.AttachmentRepository.AddAttachmentAsync(attachment);
// Save attachment in blob storage
await _contentStorage.SaveContentAsync(attachment.FileName, request.Content, _cloudStorageConfiguration.MessageAttachmentsContainer);
return(attachment.ToAttachmentResponse());
}
public async Task AddMessageAttachmentAsync(AddMessageAttachmentRequest request)
{
await CheckAccessTokenAndExecute(new TaskReference(async() =>
{
request.SaasUserId = Context.GetSaasUserId();
await _messageSocketService.AddMessageAttachmentAsync(request);
}),
request.RequestId);
}
public async Task <AttachmentResponse> AddMessageAttachmentAsync(AddMessageAttachmentRequest request)
{
var attachmentResponse = await _messageService.AddMessageAttachmentAsync(request);
var message = await _messageService.GetMessageByIdAsync(request.MessageId);
await _messageNotificationService.OnAddMessageAttachment(message.ChannelId);
return(attachmentResponse);
}
public async Task <AttachmentResponse> AddMessageAttachmentAsync(AddMessageAttachmentRequest request)
{
var message = await UnitOfWork.MessageRepository.GetMessageWithOwnerAndForwardMessageAsync(request.MessageId);
if (message == null)
{
throw new NetKitChatNotFoundException($"Unable to add message attachment. Message {nameof(request.MessageId)}:{request.MessageId} is not found.");
}
if (message.Type == MessageType.System)
{
throw new NetKitChatInvalidOperationException($"Unable to add attachment to system message. Message {nameof(request.MessageId)}:{request.MessageId}.");
}
var member = await UnitOfWork.MemberRepository.GetMemberBySaasUserIdAsync(request.SaasUserId);
if (member == null)
{
throw new NetKitChatNotFoundException($"Unable to add message attachment. Member {nameof(request.SaasUserId)}:{request.SaasUserId} is not found.");
}
if (member.Id != message.OwnerId)
{
throw new NetKitChatAccessForbiddenException($"Unable to add message attachment. Message {nameof(request.MessageId)}:{request.MessageId} owner required.");
}
var isAttachmentLimitExceeded = await IsAttachmentLimitExceededAsync(message.Id);
if (isAttachmentLimitExceeded)
{
throw new NetKitChatInvalidOperationException($"Unable to add message attachment. Attachment limit {_messagesConfiguration.MessageAttachmentsLimit} exceeded.");
}
var attachment = new Attachment
{
Id = Guid.NewGuid(),
ContentType = request.ContentType,
Created = _dateTimeProvider.GetUtcNow(),
FileName = $"{Guid.NewGuid()}.{request.Extension}",
MessageId = request.MessageId,
Size = request.Size
};
// Save attachment in database
await UnitOfWork.AttachmentRepository.AddAttachmentAsync(attachment);
// Save attachment in cloud
await _cloudAttachmentProvider.SaveAttachmentAsync(attachment.FileName, request.Content);
return(DomainModelsMapper.MapToAttachmentResponse(attachment));
}
public void ShouldThrowIfMessageDoesNotExist()
{
// Arrange
_messageRepositoryMock.Setup(x => x.GetMessageWithOwnerAndForwardMessageAsync(It.IsAny <Guid>()))
.ReturnsAsync((Message)null)
.Verifiable();
var request = new AddMessageAttachmentRequest("864EB62D-D833-47FA-8A88-DDBFE76AE6A7", new Guid("A455F139-09E6-4EF5-B55A-D4C94D05DFDE"), null, "jpg", "image/jpeg", 0);
// Act
Func <Task> act = async() => { await _messageService.AddMessageAttachmentAsync(request); };
// Assert
act.Should().Throw <NetKitChatNotFoundException>()
.And.Message.Should().Be($"Unable to add message attachment. Message {nameof(request.MessageId)}:{request.MessageId} is not found.");
VerifyMocks();
}
public async Task ShouldAddAttachment()
{
// Arrange
var request = new AddMessageAttachmentRequest("864EB62D-D833-47FA-8A88-DDBFE76AE6A7", new Guid("A455F139-09E6-4EF5-B55A-D4C94D05DFDE"), null, "jpg", "image/jpeg", 0);
var member = new Member
{
Id = new Guid("ABF2CA08-5374-4CED-BE87-6EA93A8B90DA")
};
_messageRepositoryMock.Setup(x => x.GetMessageWithOwnerAndForwardMessageAsync(It.IsAny <Guid>()))
.ReturnsAsync(new Message {
Id = request.MessageId, OwnerId = member.Id
})
.Verifiable();
_memberRepositoryMock.Setup(x => x.GetMemberBySaasUserIdAsync(It.IsAny <string>()))
.ReturnsAsync(member)
.Verifiable();
_attachmentRepositoryMock.Setup(x => x.GetMessageAttachmentsCountAsync(It.Is <Guid>(messageId => messageId.Equals(request.MessageId))))
.ReturnsAsync(MessageAttachmentsLimit - 1)
.Verifiable();
_attachmentRepositoryMock.Setup(x => x.AddAttachmentAsync(It.IsAny <Attachment>()))
.Returns(Task.CompletedTask)
.Verifiable();
string attachmentFileName = null;
_cloudAttachmentProviderMock.Setup(x => x.SaveAttachmentAsync(It.IsAny <string>(), It.IsAny <Stream>()))
.Callback <string, Stream>((name, stream) => attachmentFileName = name)
.ReturnsAsync(new Uri("http://localhost"))
.Verifiable();
Attachment attachmentToMap = null;
_domainModelsMapperMock.Setup(x => x.MapToAttachmentResponse(It.IsAny <Attachment>()))
.Callback <Attachment>(x => attachmentToMap = x)
.Returns(new AttachmentResponse())
.Verifiable();
var utcNow = DateTimeOffset.UtcNow;
_dateTimeProviderMock.Setup(x => x.GetUtcNow())
.Returns(utcNow)
.Verifiable();
// Act
await _messageService.AddMessageAttachmentAsync(request);
// Assert
VerifyMocks();
attachmentToMap.ContentType.Should().Be(request.ContentType);
attachmentToMap.Created.Should().Be(utcNow);
attachmentToMap.FileName.Should().Be(attachmentFileName);
attachmentToMap.MessageId.Should().Be(request.MessageId);
attachmentToMap.Size.Should().Be(request.Size);
attachmentFileName.Should().EndWith($".{request.Extension}");
}
