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); }