Пример #1
0
        public async Task <IActionResult> GetConversationInfo([FromBody] PrivateMessagePaginationContract contract)
        {
            var input = new PrivateMessagePaginationContract
            {
                Cursor         = contract.Cursor,
                UserId         = _claimsService.GetUserClaims().Id,
                ContactUserId  = contract.ContactUserId,
                ConversationId = contract.ConversationId,
                PageSize       = contract.PageSize
            };
            var conversation = await _messageService.GetPrivateConversationInfo(input);

            var response = new ResponseMessage
            {
                Data      = conversation,
                IsSuccess = true
            };

            return(Ok(response));
        }
Пример #2
0
        public async Task <PrivateMessagePaginationResponseContract> GetPrivateConversationInfo(PrivateMessagePaginationContract input)
        {
            var conversation = !input.ConversationId.HasValue ? await GetConversationOfUser(input.UserId, input.ContactUserId) :
                               await _context.Set <Conversation>().SingleOrDefaultAsync(c => c.Id == input.ConversationId.Value);

            if (conversation != null)
            {
                var getMore = input.ConversationId.HasValue;

                Expression <Func <Message, bool> > predicate = m => m.ConversationId == conversation.Id;

                if (input.Cursor.HasValue)
                {
                    predicate = m => m.ConversationId == conversation.Id && m.Created < input.Cursor.Value;
                }

                var messages = await _context.Set <Message>()
                               .Where(predicate)
                               .OrderByDescending(m => m.Created)
                               .Select(x => new MessageDetailsContract
                {
                    Id            = x.Id,
                    Text          = x.Text,
                    AttachmentUrl = x.AttachmentUrl,
                    SentAt        = x.Created,
                    IsResponse    = x.SenderId != input.UserId,
                    MessageType   = (int)x.MessageType,
                    SentBy        = x.SenderId,
                    Seen          = false,
                })
                               .Take(input.PageSize)
                               .ToListAsync();

                var readReceipt = await _context.Set <ReadReceipt>()
                                  .FirstOrDefaultAsync(x => x.ConversationId == conversation.Id);

                if (readReceipt != null)
                {
                    messages.ForEach(message =>
                    {
                        if (message.Id == readReceipt.MessageId)
                        {
                            message.Seen = true;
                        }
                    });
                }

                var conversationResponse = new ConversationContract()
                {
                    Id       = conversation.Id,
                    Title    = conversation.Title,
                    Messages = messages.OrderBy(m => m.SentAt).ToList()
                };

                DateTime?nextCursor = null;
                if (messages.Count >= input.PageSize)
                {
                    nextCursor = messages.Last().SentAt;
                }

                return(new PrivateMessagePaginationResponseContract
                {
                    NextCursor = nextCursor,
                    Conversation = conversationResponse
                });
            }
            else
            {
                var defaultContact = await _context.Set <Contact>()
                                     .SingleOrDefaultAsync(uc => uc.UserId == input.ContactUserId);

                var title = defaultContact?.FirstName + ' ' + defaultContact?.LastName;

                var newConversation = new Conversation(title, input.UserId, defaultContact.UserId);

                await _context.AddAsync(newConversation);

                await _context.SaveChangesAsync();

                var conversationReponse = new ConversationContract
                {
                    Id       = newConversation.Id,
                    Title    = title,
                    Messages = new List <MessageDetailsContract>()
                };

                return(new PrivateMessagePaginationResponseContract
                {
                    NextCursor = null,
                    Conversation = conversationReponse
                });
            }
        }