public async Task <IActionResult> GetMessageUser(int userid, [FromQuery] MessageParamsDto query)
        {
            try
            {
                if (userid != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
                {
                    return(Unauthorized());
                }

                query.UserID = userid;

                var messages = await _datingrepo.GetMessagesForUser(query);

                var result = _mapper.Map <IEnumerable <MessageReturnDto> >(messages);

                Response.AddPaginationHeader(messages.TotalCount, messages.TotalPages,
                                             messages.PageSize, messages.CurrentPage);

                return(Ok(result));
            }
            catch (Exception ex)
            {
                throw new Exception("Error while fetching user messages");
            }
        }
Exemplo n.º 2
0
        public async Task <PageList <Messages> > GetMessagesForUser(MessageParamsDto query)
        {
            var messages = _dbContext.Messages
                           .Include(u => u.Sender).ThenInclude(p => p.Photos)
                           .Include(u => u.Receiver).ThenInclude(p => p.Photos)
                           .AsQueryable();

            switch (query.MessageType)
            {
            case "Inbox":
                messages = messages.Where(u => u.ReceiverID == query.UserID && u.ReceiverDeleted == false);
                break;

            case "Outbox":
                messages = messages.Where(u => u.SenderID == query.UserID && u.SenderDeleted == false);
                break;

            default:
                messages = messages.Where(u => u.ReceiverID == query.UserID &&
                                          u.ReceiverDeleted == false && u.IsRead == false);
                break;
            }

            messages = messages.OrderByDescending(u => u.SendDate);

            var messageList = await PageList <Messages> .CreateAsync(query.PageNumber, query.PageSize, messages);

            return(messageList);
        }
Exemplo n.º 3
0
        public async Task <PagedList <Message> > GetMessagesForuser(MessageParamsDto messageParams)
        {
            var messages = _context.Messages
                           .AsQueryable();

            switch (messageParams.MessageContainer)
            {
            case "Inbox":
                messages = messages.Where(i => i.RecipientId == messageParams.UserId && i.ReceipientDeleted == false);
                break;

            case "Outbox":
                messages = messages.Where(o => o.SenderId == messageParams.UserId && o.SenderDeleted == false);
                break;

            default:
                messages = messages.Where(u => u.RecipientId == messageParams.UserId && u.ReceipientDeleted == false &&
                                          u.IsRead == false);
                break;
            }

            messages = messages.OrderByDescending(d => d.MessageSent);

            return(await PagedList <Message> .CreateAsync(messages, messageParams.PageNumber, messageParams.PageSize));
        }
Exemplo n.º 4
0
        public async Task <IActionResult> GetMessages(int userId, [FromQuery] MessageParamsDto messageParams)
        {
            if (userId != int.Parse(User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier).Value))
            {
                return(Unauthorized());
            }

            messageParams.UserId = userId;

            var messagesFromRepo = await _repo.GetMessagesForuser(messageParams);

            var messages = _mapper.Map <IEnumerable <MessageToReturnDto> >(messagesFromRepo);

            Response.AddPaginationHeader(new PaginationHeaders(messagesFromRepo.PageNumber, messagesFromRepo.PageSize,
                                                               messagesFromRepo.TotalCount, messagesFromRepo.TotalPages));

            return(Ok(messages));
        }