Beispiel #1
0
        private async Task AddGiftTransactionsToFeedAsync(string currentUserId, List <DashboardItemViewModel> dashboardItems, FeedItemQueryType queryType)
        {
            var giftTransactions = await DashboardService.GetFollowerGiftTransactionsAsync(currentUserId, queryType);

            var giftTransactionsConsolidated = giftTransactions.GetConsolidatedGiftTransactions();

            foreach (var giftTransactionViewModel in giftTransactionsConsolidated)
            {
                dashboardItems.Add(new DashboardItemViewModel()
                {
                    ItemType             = DashboardFeedItemType.GiftTransaction,
                    DateOccurred         = giftTransactionViewModel.DateSent,
                    GiftReceivedFeedItem = giftTransactionViewModel
                });
            }
        }
        public async Task <IReadOnlyCollection <GiftReceivedFeedViewModel> > GetFollowerGiftTransactionsAsync(string userId, FeedItemQueryType queryType)
        {
            List <GiftReceivedFeedViewModel> results = new List <GiftReceivedFeedViewModel>();

            if (queryType == FeedItemQueryType.All)
            {
                var giftsSent = (from gifts in db.GiftTransactions
                                 from favoritedProfiles in db.FavoriteProfiles
                                 where gifts.FromUser.Profile.Id == favoritedProfiles.ProfileId ||
                                 gifts.ToUser.Profile.Id == favoritedProfiles.ProfileId
                                 where favoritedProfiles.UserId == userId
                                 where gifts.FromUser.IsActive
                                 where gifts.ToUser.IsActive
                                 select new GiftReceivedFeedViewModel()
                {
                    DateSent = gifts.DateTransactionOccurred,
                    ReceiverUserName = gifts.ToUser.UserName,
                    ReceiverProfileImagePath = gifts.ToUser.Profile.UserImage.FileName,
                    ReceiverProfileId = gifts.ToUser.Profile.Id,
                    SenderProfileId = gifts.FromUser.Profile.Id,
                    SenderProfileImagePath = gifts.FromUser.Profile.UserImage.FileName,
                    SenderUserId = gifts.FromUser.Id,
                    SenderUserName = gifts.FromUser.UserName,
                    StoreItemId = gifts.StoreItemId,
                    ItemCount = gifts.ItemCount,
                    StoreItemIconPath = gifts.StoreItem.IconFileName
                })
                                .Distinct();

                results = await giftsSent.ToListAsync();
            }
            else
            {
                var giftsToSelf = from gifts in db.GiftTransactions
                                  .Include(g => g.StoreItem)
                                  .Include(g => g.FromUser)
                                  where gifts.ToUserId == userId
                                  where gifts.FromUser.IsActive
                                  where gifts.ToUser.IsActive
                                  select new GiftReceivedFeedViewModel()
                {
                    DateSent                 = gifts.DateTransactionOccurred,
                    ReceiverUserName         = gifts.ToUser.UserName,
                    ReceiverProfileImagePath = gifts.ToUser.Profile.UserImage.FileName,
                    ReceiverProfileId        = gifts.ToUser.Profile.Id,
                    SenderProfileId          = gifts.FromUser.Profile.Id,
                    SenderProfileImagePath   = gifts.FromUser.Profile.UserImage.FileName,
                    SenderUserId             = gifts.FromUser.Id,
                    SenderUserName           = gifts.FromUser.UserName,
                    StoreItemId              = gifts.StoreItemId,
                    ItemCount                = gifts.ItemCount,
                    StoreItemIconPath        = gifts.StoreItem.IconFileName
                };

                results = await giftsToSelf.ToListAsync();
            }

            foreach (var result in results)
            {
                result.ReceiverProfileImagePath = ProfileExtensions.GetThumbnailImagePath(result.ReceiverProfileImagePath);
                result.SenderProfileImagePath   = ProfileExtensions.GetThumbnailImagePath(result.SenderProfileImagePath);
                result.StoreItemIconPath        = StoreItemExtensions.GetImagePath(result.StoreItemIconPath);
                result.Gifts = new Dictionary <int, GiftReceivedFeedItemViewModel>();
            }

            return(results.AsReadOnly());
        }
Beispiel #3
0
        /// <summary>
        /// Queries the database for recent reviews written by the current user's followers and adds them to the view model.
        /// </summary>
        /// <param name="currentUserId"></param>
        /// <param name="dashboardItems"></param>
        /// <returns></returns>
        private async Task AddReviewsToFeedAsync(string currentUserId, List <DashboardItemViewModel> dashboardItems, FeedItemQueryType queryType)
        {
            var reviews = await DashboardService.GetReviewsForFeedAsync(currentUserId, queryType);

            foreach (var reviewFeed in reviews)
            {
                dashboardItems.Add(new DashboardItemViewModel()
                {
                    ItemType              = DashboardFeedItemType.ReviewWritten,
                    DateOccurred          = reviewFeed.DateOccurred,
                    ReviewWrittenFeedItem = reviewFeed
                });
            }
        }
        /// <summary>
        /// Returns all reviews written by and for users marked as favorites for the passed user id
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task <IReadOnlyCollection <ReviewWrittenFeedViewModel> > GetReviewsForFeedAsync(string userId, FeedItemQueryType queryType)
        {
            Debug.Assert(!String.IsNullOrEmpty(userId));

            List <ReviewWrittenFeedViewModel> results = new List <ReviewWrittenFeedViewModel>();

            // get all reviews written by or for anyone that we are following
            if (queryType == FeedItemQueryType.All)
            {
                // get the reviews that were written for the favorited users
                var reviewsWritten = (from reviews in db.Reviews
                                      from favoritedProfiles in db.FavoriteProfiles
                                      where reviews.TargetUser.Profile.Id == favoritedProfiles.ProfileId ||
                                      reviews.AuthorUser.Profile.Id == favoritedProfiles.ProfileId
                                      where favoritedProfiles.UserId == userId
                                      where reviews.TargetUser.IsActive
                                      where reviews.AuthorUser.IsActive
                                      select new ReviewWrittenFeedViewModel()
                {
                    AuthorProfileId = reviews.AuthorUser.Profile.Id,
                    AuthorProfileImagePath = reviews.AuthorUser.Profile.UserImage.FileName,
                    AuthorUserName = reviews.AuthorUser.UserName,
                    DateOccurred = reviews.DateCreated,
                    ReviewContent = reviews.Content,
                    ReviewId = reviews.Id,
                    ReviewRatingValue = reviews.RatingValue,
                    TargetProfileId = reviews.TargetUser.Profile.Id,
                    TargetProfileImagePath = reviews.TargetUser.Profile.UserImage.FileName,
                    TargetUserName = reviews.TargetUser.UserName
                })
                                     .Distinct();

                results = await reviewsWritten.ToListAsync();
            }
            // get only reviews that were written about our self
            else
            {
                var reviewsWrittenForSelf = from reviews in db.Reviews
                                            where reviews.TargetUserId == userId
                                            where reviews.TargetUser.IsActive
                                            where reviews.AuthorUser.IsActive
                                            select new ReviewWrittenFeedViewModel()
                {
                    AuthorProfileId        = reviews.AuthorUser.Profile.Id,
                    AuthorProfileImagePath = reviews.AuthorUser.Profile.UserImage.FileName,
                    AuthorUserName         = reviews.AuthorUser.UserName,
                    DateOccurred           = reviews.DateCreated,
                    ReviewContent          = reviews.Content,
                    ReviewId               = reviews.Id,
                    ReviewRatingValue      = reviews.RatingValue,
                    TargetProfileId        = reviews.TargetUser.Profile.Id,
                    TargetProfileImagePath = reviews.TargetUser.Profile.UserImage.FileName,
                    TargetUserName         = reviews.TargetUser.UserName
                };

                results = await reviewsWrittenForSelf.ToListAsync();
            }

            foreach (var result in results)
            {
                result.AuthorProfileImagePath = ProfileExtensions.GetThumbnailImagePath(result.AuthorProfileImagePath);
                result.TargetProfileImagePath = ProfileExtensions.GetThumbnailImagePath(result.TargetProfileImagePath);
            }

            return(results.AsReadOnly());
        }