public async void NewMessageUpdateUserChatsAsync(MessageVm message)
{
try
{
UserVm senderInfo = await loadUsersService.GetUserAsync(message.SenderId.GetValueOrDefault()).ConfigureAwait(false);
IEnumerable <long> usersId = await loadChatsService.GetChatUsersIdAsync(message.ConversationId.GetValueOrDefault()).ConfigureAwait(false);
foreach (long userId in usersId)
{
List <ConversationPreviewVm> cachedChats = (await GetUserChatsAsync(userId).ConfigureAwait(false))?.ToList();
if (cachedChats == null || cachedChats.All(opt => opt.ConversationId != message.ConversationId))
{
cachedChats = (await loadChatsService.GetUserChatPreviewAsync(userId, DateTime.UtcNow.ToUnixTime()).ConfigureAwait(false))?.ToList();
UpdateUserChats(userId, cachedChats);
continue;
}
ConversationPreviewVm updatedChat = cachedChats.FirstOrDefault(opt => opt.ConversationId == message.ConversationId);
if (updatedChat != null)
{
updatedChat.LastMessageSenderId = message.SenderId;
updatedChat.LastMessageTime = message.SendingTime;
updatedChat.LastMessageSenderName = senderInfo.NameFirst;
updatedChat.PreviewText = message.Text;
updatedChat.LastMessageId = message.GlobalId;
updatedChat.Read = false;
updatedChat.AttachmentType = (AttachmentType?)message.Attachments?.FirstOrDefault()?.Type ?? null;
UpdateUserChats(userId, cachedChats);
}
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
//Adds a work to the user's read list
public MessageVm AddToList(Rating rating)
{
Work subject = repo.Find <Work>(rating.WorkId);
ApplicationUser owner = GetUserById(rating.OwnerId);
string message = "Success.";
bool cont = true;
foreach (Rating i in owner.MyRatings)
{
if (i.WorkId == rating.WorkId)
{
message = "This item is already in your list.";
cont = false;
}
}
if (cont)
{
//Calculate new average rating for work:
subject.AvgRating = ((subject.AvgRating * subject.RatingCount) + rating.Score) / (subject.RatingCount + 1);
subject.RatingCount++;
//Add work to user's list:
owner.Read.Add(subject);
//Add rating to user's ratings:
owner.MyRatings.Add(rating);
repo.SaveChanges();
}
MessageVm returnObj = new MessageVm();
returnObj.Message = message;
return(returnObj);
}
public void SendMessageToGroup(MessageVm message)
{
message.Author = Context.User.Identity.Name;
Clients.Group(message.RecipientName).SendAsync("ShowMessage", message);
}
public void SendMessageAll(MessageVm message)
{
message.Author = Context.User.Identity.Name;
Clients.All.SendAsync("ShowMessage", message);
}
public async Task <bool> CheckEditedMessageAttachmentsAsync(MessageVm message, long userId)
{
try
{
foreach (var attachment in message.Attachments)
{
switch (attachment.Type)
{
case AttachmentType.Audio:
case AttachmentType.File:
case AttachmentType.Picture:
case AttachmentType.Video:
{
if (attachment.Payload is string stringPayload)
{
var fileInfo = _filesService.GetFileInfoAsync(stringPayload);
if (fileInfo == null)
{
return(false);
}
}
else
{
return(false);
}
}
break;
case AttachmentType.ForwardedMessages:
{
if (attachment.Payload is ForwardedMessagesInfo messagesInfo)
{
var messages = await _loadMessagesService.GetMessagesByIdAsync(
messagesInfo.MessagesGlobalId,
messagesInfo.ConversationType,
messagesInfo.ConversationId.GetValueOrDefault(),
userId).ConfigureAwait(false);
if (messages == null || !messages.Any())
{
return(false);
}
}
else if (attachment.Payload is List <MessageVm> messages)
{
await _createMessagesService.SaveForwardedMessagesAsync(MessageConverter.GetMessagesDto(messages)).ConfigureAwait(false);
}
else
{
return(false);
}
}
break;
case AttachmentType.Poll:
{
if (attachment.Payload is PollVm poll)
{
var existingPoll = await _pollsService.GetPollAsync(
poll.PollId.GetValueOrDefault(),
message.ConversationId.GetValueOrDefault(),
message.ConversationType).ConfigureAwait(false);
if (existingPoll == null)
{
poll = await PollConverter.InitPollConversationAsync(poll, message).ConfigureAwait(false);
poll.PollId = RandomExtensions.NextGuid();
await _pollsService.SavePollAsync(PollConverter.GetPollDto(poll, userId)).ConfigureAwait(false);
attachment.Payload = poll;
}
}
}
break;
case AttachmentType.VoiceMessage:
{
await ValidateVoiceMessageAttachmentAsync(attachment);
}
break;
}
}
return(true);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
return(false);
}
}
private async Task <bool> HandleAndValidatePollAttachmentAsync(AttachmentVm attachment, MessageVm message)
{
try
{
PollVm pollAttachment;
if (attachment.Payload.GetType() == typeof(string))
{
pollAttachment = ObjectSerializer.JsonToObject <PollVm>((string)attachment.Payload);
}
else
{
pollAttachment = ObjectSerializer.JsonToObject <PollVm>(ObjectSerializer.ObjectToJson(attachment.Payload));
}
bool isValid = !string.IsNullOrWhiteSpace(pollAttachment.Title) &&
pollAttachment.Title.Length < 100 &&
pollAttachment.PollOptions != null &&
pollAttachment.PollOptions.All(opt => !string.IsNullOrWhiteSpace(opt.Description));
if (isValid)
{
pollAttachment = await PollConverter.InitPollConversationAsync(pollAttachment, message).ConfigureAwait(false);
if (pollAttachment.PollId == null || pollAttachment.PollId == Guid.Empty)
{
pollAttachment.PollId = RandomExtensions.NextGuid();
}
attachment.Payload = pollAttachment;
await _pollsService.SavePollAsync(PollConverter.GetPollDto(pollAttachment, message.SenderId.GetValueOrDefault())).ConfigureAwait(false);
return(true);
}
return(false);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
return(false);
}
}
public async Task <bool> ValidateAttachmentsAsync(IEnumerable <AttachmentVm> attachments, MessageVm message, long?userId, bool anotherNodeMessage)
{
bool isValid;
foreach (var attachment in attachments)
{
switch (attachment.Type)
{
case AttachmentType.ForwardedMessages:
{
isValid = await ValidateForwardedMessagesAttachment(attachment, userId, anotherNodeMessage).ConfigureAwait(false);
attachment.Hash = Array.Empty <byte>();
}
break;
case AttachmentType.Picture:
case AttachmentType.File:
case AttachmentType.Audio:
case AttachmentType.Video:
{
isValid = await ValidateMediaAttachment(attachment).ConfigureAwait(false);
}
break;
case AttachmentType.EncryptedMessage:
{
await ThrowIfEncryptionForbiddenAsync(message.SenderId ?? userId.GetValueOrDefault(), message.ReceiverId.Value);
isValid = true;
}
break;
case AttachmentType.KeyMessage:
{
await ThrowIfEncryptionForbiddenAsync(message.SenderId ?? userId.GetValueOrDefault(), message.ReceiverId.Value);
isValid = ValidateKeyAttachment(attachment);
}
break;
case AttachmentType.Poll:
{
if (message.ConversationType == ConversationType.Dialog)
{
return(false);
}
isValid = await HandleAndValidatePollAttachmentAsync(attachment, message).ConfigureAwait(false);
}
break;
case AttachmentType.VoiceMessage:
{
isValid = await ValidateVoiceMessageAttachmentAsync(attachment).ConfigureAwait(false);
}
break;
case AttachmentType.VideoMessage:
{
isValid = false;
}
break;
default:
{
isValid = false;
}
break;
}
if (!isValid)
{
return(false);
}
}
return(true);
}
public async Task ThrowIfAttachmentsInvalid()
{
var user = fillTestDbHelper.Users.FirstOrDefault();
var secondUser = fillTestDbHelper.Users.LastOrDefault();
var file = fillTestDbHelper.Files.FirstOrDefault();
var message = MessageConverter.GetMessageDto(fillTestDbHelper.Messages.FirstOrDefault());
var messageVm = new MessageVm
{
SenderId = user.Id,
Attachments = new List<AttachmentVm>
{
new AttachmentVm
{
Payload = file.Id,
Type = AttachmentType.File
},
new AttachmentVm
{
Payload = new ForwardedMessagesInfo(new List<Guid>{ message.GlobalId }, message.ConversationId, message.ConversationType),
Type = AttachmentType.ForwardedMessages
},
new AttachmentVm
{
Payload = new PollVm
{
ConversationId = message.ConversationId,
ConversationType = message.ConversationType,
PollOptions = new List<PollOptionVm>
{
new PollOptionVm
{
Description = "Desc",
OptionId = 1
}
},
Title = "Title"
},
Type = AttachmentType.Poll
}
}
};
await attachmentsService.ThrowIfAttachmentsInvalidAsync(messageVm, false);
var invalidKeyAttachment = new MessageVm
{
SenderId = user.Id,
ReceiverId = secondUser.Id,
Attachments = new List<AttachmentVm>
{
new AttachmentVm
{
Type = AttachmentType.KeyMessage,
Payload = new object()
}
}
};
var invalidFileMessage = new MessageVm
{
SenderId = user.Id,
Attachments = new List<AttachmentVm>
{
new AttachmentVm
{
Payload = "Non existing file ID",
Type = AttachmentType.File,
}
}
};
var invalidForwardedMessage = new MessageVm
{
SenderId = user.Id,
Attachments = new List<AttachmentVm>
{
new AttachmentVm
{
Payload = RandomExtensions.NextString(3),
Type = AttachmentType.ForwardedMessages
}
}
};
var invalidPollMessage = new MessageVm
{
SenderId = user.Id,
Attachments = new List<AttachmentVm>
{
new AttachmentVm
{
Payload = new PollVm
{
Title = "t"
}
}
}
};
await Assert.ThrowsAnyAsync<InvalidAttachmentsException>(async () => await attachmentsService.ThrowIfAttachmentsInvalidAsync(invalidFileMessage, false));
await Assert.ThrowsAnyAsync<InvalidAttachmentsException>(async () => await attachmentsService.ThrowIfAttachmentsInvalidAsync(invalidForwardedMessage, false));
await Assert.ThrowsAnyAsync<InvalidAttachmentsException>(async () => await attachmentsService.ThrowIfAttachmentsInvalidAsync(invalidPollMessage, false));
await Assert.ThrowsAnyAsync<InvalidAttachmentsException>(async () => await attachmentsService.ThrowIfAttachmentsInvalidAsync(invalidKeyAttachment, false));
}
public MessagesDeletedNodeNotice(long?conversationId, ConversationType conversationType, MessageVm message, long requestorId)
{
Messages = new List <MessageVm> {
message
};
ConversationType = conversationType;
ConversationId = conversationId;
NoticeCode = NodeNoticeCode.MessagesDeleted;
RequestorId = requestorId;
}
/*
* Message
*/
/// <summary>
/// Map using Automapper
/// </summary>
public static MessageDto MapToDto(this MessageVm MessageVm)
{
return(Mapper.Map <MessageVm, MessageDto>(MessageVm));
}
public IActionResult Index(MessageVm messageModel)
{
return(View(messageModel));
}
public async void NewMessageUpdateUserDialogsAsync(MessageVm message, long receiverDialogId)
{
try
{
List <ConversationPreviewVm> senderDialogs = (await GetUserDialogsAsync(message.SenderId.Value).ConfigureAwait(false))?.ToList();
IEnumerable <ConversationPreviewVm> receiverDialogs = await GetUserDialogsAsync(message.ReceiverId.Value).ConfigureAwait(false);
if (senderDialogs != null)
{
ConversationPreviewVm changedSenderDialog = senderDialogs
.FirstOrDefault(opt => opt.ConversationId == message.ConversationId);
if (changedSenderDialog != null)
{
changedSenderDialog.LastMessageSenderId = message.SenderId;
changedSenderDialog.LastMessageTime = message.SendingTime;
changedSenderDialog.PreviewText = message.Text;
changedSenderDialog.AttachmentType = message.Attachments?.FirstOrDefault()?.Type;
changedSenderDialog.Read = false;
changedSenderDialog.LastMessageId = message.GlobalId;
}
else
{
senderDialogs = (await loadDialogsService.GetUserDialogsPreviewAsync(message.SenderId.Value).ConfigureAwait(false)).ToList();
}
}
else
{
senderDialogs = (await loadDialogsService.GetUserDialogsPreviewAsync(message.SenderId.Value).ConfigureAwait(false)).ToList();
}
if (receiverDialogs != null)
{
ConversationPreviewVm changedReceiverDialog = receiverDialogs
.FirstOrDefault(opt => opt.ConversationId == receiverDialogId);
if (changedReceiverDialog != null)
{
changedReceiverDialog.LastMessageSenderId = message.SenderId;
changedReceiverDialog.LastMessageTime = message.SendingTime;
changedReceiverDialog.PreviewText = message.Text;
changedReceiverDialog.AttachmentType = message.Attachments?.FirstOrDefault()?.Type;
changedReceiverDialog.Read = false;
changedReceiverDialog.LastMessageId = message.GlobalId;
receiverDialogs = receiverDialogs.Where(opt => opt.ConversationId != changedReceiverDialog.ConversationId);
receiverDialogs = receiverDialogs.Append(changedReceiverDialog);
}
else
{
receiverDialogs = await loadDialogsService.GetUserDialogsPreviewAsync(message.ReceiverId.Value).ConfigureAwait(false);
}
}
else
{
receiverDialogs = await loadDialogsService.GetUserDialogsPreviewAsync(message.ReceiverId.Value).ConfigureAwait(false);
}
UpdateUserDialogs(message.SenderId.Value, senderDialogs.OrderByDescending(opt => opt.LastMessageTime));
UpdateUserDialogs(message.ReceiverId.Value, receiverDialogs.OrderByDescending(opt => opt.LastMessageTime));
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
//Adds a review
public MessageVm AddReview(ReviewVm review)
{
Work subject = repo.Query <Work>().Where(w => w.Id == review.WorkId).Include(w => w.Reviews).FirstOrDefault();
ApplicationUser owner = GetUserById(review.OwnerId);
Rating subjectRating = new Rating();
MessageVm returnObj = new MessageVm();;
bool quit = false;
//Find the user's rating for this work:
int i = 0;
while (!quit && i < owner.MyRatings.Count)
{
if (owner.MyRatings[i].WorkId == review.WorkId)
{
subjectRating = owner.MyRatings[i];
quit = true;
}
i++;
}
//Set error flag if no rating was found:
if (subjectRating.Score == 0)
{
returnObj.Error = true;
}
//Check if the user has already created a review of this work:
quit = false;
int j = 0;
while (!quit && j < owner.MyReviews.Count)
{
if (owner.MyReviews[j].WorkId == review.WorkId)
{
returnObj.Error = true;
quit = true;
}
j++;
}
if (!returnObj.Error)
{
Review reviewToAdd = new Review
{
OwnerId = review.OwnerId,
OwnerName = owner.UserName,
Content = review.Content,
Score = subjectRating.Score,
DateAdded = DateTime.Now,
IsActive = true,
};
if (subject.Reviews.Count == 0)
{
subject.Reviews = new List <Review>();
}
owner.MyReviews.Add(reviewToAdd);
subject.Reviews.Add(reviewToAdd);
repo.SaveChanges();
}
return(returnObj);
}
