Exemple #1
0
        public List <ItemModels.MessagePreview> GetPreviews(int boardId, int page, int unread)
        {
            var participation    = new List <DataModels.Participant>();
            var viewLogs         = new List <DataModels.ViewLog>();
            var historyTimeLimit = SettingsRepository.HistoryTimeLimit();

            if (UserContext.IsAuthenticated)
            {
                participation = DbContext.Participants.Where(r => r.UserId == UserContext.ApplicationUser.Id).ToList();
                viewLogs      = DbContext.ViewLogs.Where(r => r.LogTime >= historyTimeLimit && r.UserId == UserContext.ApplicationUser.Id).ToList();
            }

            var sortedMessageIds = GetIndexIds(boardId, page, unread, historyTimeLimit, participation, viewLogs);

            var messageQuery = from message in DbContext.Messages
                               where sortedMessageIds.Contains(message.Id)
                               select new {
                message.Id,
                message.ShortPreview,
                message.ViewCount,
                message.ReplyCount,
                message.TimePosted,
                message.LastReplyId,
                message.LastReplyById,
                message.LastReplyPosted
            };

            var messages = messageQuery.ToList();

            var take            = SettingsRepository.MessagesPerPage();
            var popularityLimit = SettingsRepository.PopularityLimit();

            var messagePreviews = new List <ItemModels.MessagePreview>();

            foreach (var messageId in sortedMessageIds)
            {
                var message = messages.First(item => item.Id == messageId);

                var messagePreview = new ItemModels.MessagePreview {
                    Id           = message.Id,
                    ShortPreview = string.IsNullOrEmpty(message.ShortPreview.Trim()) ? "No subject" : message.ShortPreview,
                    Views        = message.ViewCount,
                    Replies      = message.ReplyCount,
                    Pages        = Convert.ToInt32(Math.Ceiling(1.0 * message.ReplyCount / take)),
                    LastReplyId  = message.Id,
                    Popular      = message.ReplyCount > popularityLimit,
                    Pinned       = PinRepository.Any(item => item.MessageId == message.Id)
                };

                messagePreviews.Add(messagePreview);

                var lastMessageTime = message.TimePosted;

                if (message.LastReplyId != 0)
                {
                    var lastReplyDetails = (from item in DbContext.Messages
                                            join postedBy in DbContext.Users on item.PostedById equals postedBy.Id
                                            where item.Id == message.LastReplyId
                                            select new {
                        postedBy.DisplayName,
                        item.ShortPreview
                    }).FirstOrDefault();

                    if (lastReplyDetails != null)
                    {
                        messagePreview.LastReplyId       = message.LastReplyId;
                        messagePreview.LastReplyPreview  = lastReplyDetails.ShortPreview;
                        messagePreview.LastReplyByName   = lastReplyDetails.DisplayName;
                        messagePreview.LastReplyById     = message.LastReplyById;
                        messagePreview.LastReplyPosted   = message.LastReplyPosted.ToPassedTimeString();
                        messagePreview.LastReplyPostedDT = message.LastReplyPosted;
                        lastMessageTime = message.LastReplyPosted;
                    }
                }

                if (lastMessageTime > historyTimeLimit)
                {
                    messagePreview.Unread = GetUnreadLevel(message.Id, lastMessageTime, participation, viewLogs);
                }
            }

            return(messagePreviews);
        }
        public async Task <List <ItemModels.MessagePreview> > GetPreviews(List <int> messageIds)
        {
            var messageQuery = from message in DbContext.Messages
                               where messageIds.Contains(message.Id)
                               select new {
                message.Id,
                message.ShortPreview,
                message.ViewCount,
                message.ReplyCount,
                message.TimePosted,
                message.PostedById,
                message.LastReplyId,
                message.LastReplyById,
                message.LastReplyPosted,
                message.Pinned
            };

            var messages = await messageQuery.ToListAsync();

            var users = await AccountRepository.Records();

            var messagePreviews = new List <ItemModels.MessagePreview>();
            var today           = DateTime.Now.Date;

            var boards = await BoardRepository.Records();

            foreach (var messageId in messageIds)
            {
                var message  = messages.First(item => item.Id == messageId);
                var postedBy = users.First(r => r.Id == message.PostedById);

                var messagePreview = new ItemModels.MessagePreview {
                    Id               = message.Id,
                    ShortPreview     = string.IsNullOrEmpty(message.ShortPreview.Trim()) ? "No subject" : message.ShortPreview,
                    Views            = message.ViewCount,
                    Replies          = message.ReplyCount,
                    Pages            = Convert.ToInt32(Math.Ceiling(1.0 * message.ReplyCount / UserContext.ApplicationUser.MessagesPerPage)),
                    LastReplyId      = message.Id,
                    Popular          = message.ReplyCount > UserContext.ApplicationUser.PopularityLimit,
                    Pinned           = message.Pinned,
                    TimePosted       = message.TimePosted,
                    PostedById       = message.PostedById,
                    PostedByName     = postedBy.DecoratedName,
                    PostedByBirthday = today == new DateTime(today.Year, postedBy.Birthday.Month, postedBy.Birthday.Day).Date
                };

                messagePreviews.Add(messagePreview);

                var lastMessageTime = message.TimePosted;

                if (message.LastReplyId != 0)
                {
                    var lastReply = (from item in DbContext.Messages
                                     where item.Id == message.LastReplyId
                                     select new {
                        item.ShortPreview
                    }).FirstOrDefault();

                    if (lastReply != null)
                    {
                        var lastReplyBy = users.FirstOrDefault(r => r.Id == message.LastReplyById);

                        messagePreview.LastReplyId      = message.LastReplyId;
                        messagePreview.LastReplyPreview = lastReply.ShortPreview;
                        messagePreview.LastReplyById    = message.LastReplyById;
                        messagePreview.LastReplyPosted  = message.LastReplyPosted;
                        lastMessageTime = message.LastReplyPosted;
                        messagePreview.LastReplyByName = lastReplyBy?.DecoratedName ?? "User";

                        if (!(lastReplyBy is null))
                        {
                            messagePreview.LastReplyByBirthday = today.Date == new DateTime(today.Year, lastReplyBy.Birthday.Month, lastReplyBy.Birthday.Day).Date;
                        }
                    }
                }

                var historyTimeLimit = DateTime.Now.AddDays(-14);

                if (lastMessageTime > historyTimeLimit)
                {
                    messagePreview.Unread = GetUnreadLevel(message.Id, lastMessageTime);
                }

                var boardIdQuery = from messageBoard in DbContext.MessageBoards
                                   where messageBoard.MessageId == message.Id
                                   select messageBoard.BoardId;

                var messageBoards = new List <Models.ViewModels.Boards.Items.IndexBoard>();

                foreach (var boardId in boardIdQuery)
                {
                    var boardRecord = boards.Single(r => r.Id == boardId);

                    messageBoards.Add(new Models.ViewModels.Boards.Items.IndexBoard {
                        Id           = boardRecord.Id.ToString(),
                        Name         = boardRecord.Name,
                        Description  = boardRecord.Description,
                        DisplayOrder = boardRecord.DisplayOrder,
                    });
                }

                messagePreview.Boards = messageBoards.OrderBy(r => r.DisplayOrder).ToList();
            }

            return(messagePreviews);
        }