public async Task <PagedResultDTO <PostDTO> > GetPageAsync(int id, int page, int pageSize, bool justMyPosts, string srchStr = null) { var pagedResult = await _db.Posts.GetPageAsync(id, page, pageSize, justMyPosts, srchStr); pagedResult.Data.ForEach(p => p.PostFiles = p.PostFiles.Count > 0 ? new List <PostFile>() { p.PostFiles.First() } : new List <PostFile>() ); Func <Post, PostDTO> func = post => { var postDTO = PostMapper.ConvertToPostDTO(post); postDTO.Files = FileMapper.ConvertToFileInfoDTOCollection(post.PostFiles); postDTO.UserDTO = UserMapper.ConvertToUserDTO(post.User); postDTO.CommentsDTO = CommentMapper.ConvertToCommentDTOCollection(post.Comments); var usersDTOLikes = new List <UserDTO>(); post.PostLikes.ToList().ForEach(pl => { var userDTO = UserMapper.ConvertToUserDTO(pl.User); userDTO.RoleDTO = RoleMapper.ConvertToRoleDTO(pl.User.Role); usersDTOLikes.Add(userDTO); }); postDTO.UsersLikes = usersDTOLikes; return(postDTO); }; var pageResultDTO = PagedResultMapper.MapToDTO(pagedResult, func); return(pageResultDTO); }
async Task <Option <ThreadOverViewSet> > IThreadService.GetOrderedThreads(string boardKey, Option <string> filter, int pageSize, int pageNumber, CancellationToken cancellationToken) { var board = await this.boardRepository.GetByKey(boardKey, cancellationToken); return(await board.MapToTask(async some => { var threadIds = this.GetOrderedThreads(some.Id, filter); var latestThreads = threadIds.Skip(pageSize * (pageNumber - 1)).Take(pageSize); var threads = await this.threadRepository.GetAll().Where(a => latestThreads.Contains(a.Id)).ToListAsync(cancellationToken); var l = await Task.WhenAll(threads.Select(async thread => { var posts = this.postRepository.GetAll().Where(p => p.ThreadId == thread.Id); var firstPost = await this.GetFirstPostAsync(posts, cancellationToken); var lastPosts = (await Task.WhenAll(posts.Skip(1).OrderByDescending(a => a.Created).Take(5).ToArray().Select(async p => { var file = await this.fileRepository.GetPostFile(p.Id, cancellationToken); return PostMapper.Map(p, file); }))).OrderBy(a => a.Created).ToList(); var shownPosts = lastPosts.Concat(new[] { firstPost }).ToList(); var stats = await this.GetOverviewStats(thread.Id, posts, shownPosts, cancellationToken); return new ThreadOverView(thread.Id, thread.Subject, firstPost, lastPosts, stats); }).ToArray()); var numberOfPages = (threadIds.Count() / pageSize) + 1; return new ThreadOverViewSet(some, l, new PageData(pageNumber, numberOfPages)); })); }
public async Task <IActionResult> GetPageAsync(InputPageData inputData) { if (!ModelState.IsValid) { return(BadRequest("Count of posts must be less than 100 and more than 0")); } int currentUserId = _userContext.CurrentUser.Id; var pagedResultDto = await _postService.GetPageAsync(currentUserId, inputData.PageNum, inputData.PageSize, inputData.JustMyPosts, inputData.SearchStr); var posts = new List <PostViewModel>(); pagedResultDto.Data.ForEach((p) => { var filesViewModelCollection = p.Files.Select(FileMapper.ConvertToFileInfoViewModel); var usersLikes = p.UsersLikes.Select(UserMapper.ConvertToUserLikeViewModel); var postViewModel = PostMapper.ConvertToPostViewModel(p); postViewModel.Files = filesViewModelCollection.ToList(); postViewModel.UsersLikes = usersLikes.ToList(); posts.Add(postViewModel); }); return(Ok(new { Paging = pagedResultDto.Paging, Data = posts })); }
public async Task <IActionResult> Update(int id, [FromBody] PostEditViewModel postEditModel) { if (postEditModel == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest()); } var post = await _postService.GetAsync(id); if (post == null) { return(NotFound()); } if (!HasCurrentUserEditRights(post)) { return(StatusCode(403)); } var editPostDto = MapToEditPostDTO(postEditModel); var updatedPost = await _postService.Update(id, editPostDto); var postViewModel = PostMapper.ConvertToPostViewModel(updatedPost); return(Ok(postViewModel)); }
public List <PostModel> GetAll() { using (var dbContext = dbContextFactory.CreateDbContext()) { var postMapper = new PostMapper(); return(dbContext.Posts.Include("Comments").Select(e => postMapper.EntityToModel(e)).ToList()); } }
private async Task <PostOverView> GetFirstPostAsync(IQueryable <Domain.Post> posts, CancellationToken cancellationToken) { var firstPost = await posts.OrderBy(a => a.Created).FirstAsync(cancellationToken); var file = await this.fileRepository.GetPostFile(firstPost.Id, cancellationToken); return(PostMapper.Map(firstPost, file)); }
public async Task <IEnumerable <PostDTO> > FindValidAsync(Expression <Func <Post, bool> > predicate) { var posts = await _db.Posts.FindValidAsync(predicate); var postsDTO = PostMapper.ConvertToPostDTOCollection(posts); return(postsDTO); }
public void OnGet() { var mapper = new PostMapper(); Posts = PostService.GetPosts() .ToList() .Select(mapper.ToViewModel) .ToList(); }
public IQuestPostService GetService(IRedditCloneUnitOfWork unitOfWork) { var cookieSerive = new Mock <ICookieService>().Object; var autoMapper = CommonTestMethods.GetAutoMapper(); var postMapper = new PostMapper(autoMapper); var service = new QuestPostService(unitOfWork, cookieSerive, postMapper); return(service); }
public PostModel GetById(int id) { using (var dbContext = dbContextFactory.CreateDbContext()) { var entity = dbContext.Posts.Include("Comments").First(t => t.Id == id); var postMapper = new PostMapper(); return(postMapper.EntityToModel(entity)); } }
public void Create(PostViewModel entity) { PostMapper _postMapper = new PostMapper(); Post post = _postMapper.Map(entity); _blogpostContext.Post.Add(post); _blogpostContext.SaveChanges(); }
static public TopicDisplayViewModel Map(TopicModel topic) { return(new TopicDisplayViewModel { Name = topic.Name, Posts = topic.Posts.OrderByDescending(p => p.PostedAt).Select(p => PostMapper.Map(p)).ToList(), SubscriptionsCount = topic.Subscriptions.Count }); }
public IObservable <Post> GetPost(int storyId) { var mapper = new PostMapper(); return(_apiService .GetHttpClient() .GetPostAsync(storyId) .ToObservable() .Select(x => mapper.ToDomainEntity(x))); }
static public UserTopicViewModel Map(TopicModel topic, string userId, ICollection <PostModel> posts) { return(new UserTopicViewModel { IsSubscribed = topic.Subscriptions.Any(s => s.UserId == userId), Name = topic.Name, Posts = posts.Select(p => PostMapper.Map(p)).ToList(), SubscriptionsCount = topic.Subscriptions.Count }); }
public void Update(PostModel model) { using (var dbContext = dbContextFactory.CreateDbContext()) { var postMapper = new PostMapper(); var entity = postMapper.ModelToEntity(model); dbContext.Posts.Update(entity); dbContext.SaveChanges(); } }
public FullscreenPostPartDTO GetPostWithTitle(PostDTO post) { var postWithTitle = PostMapper.ConvertToFullscreenPostPartWithNoContent(post); postWithTitle.Title = post.Title; postWithTitle.ContentType = ContentType.Title; postWithTitle.DurationInSeconds = _batchOptions.Value.TitlePostPartDurationInSeconds; return(postWithTitle); }
public void Mapper_should_convert_users_too() { var postDTO = new PostDTO(); postDTO.UserDTO = new UserDTO(); var post = PostMapper.ConvertToPost(postDTO); post.User = UserMapper.ConvertToUser(postDTO.UserDTO); Assert.NotNull(post.User); }
public FullscreenPostPartDTO GetPostPartWithVideo(PostDTO post) { var postWithVideo = PostMapper.ConvertToFullscreenPostPartWithNoContent(post); postWithVideo.VideoUrl = post.VideoUrl; postWithVideo.ContentType = ContentType.Video; postWithVideo.DurationInSeconds = post.DurationInSeconds; return(postWithVideo); }
public PostModel Create(PostModel model) { using (var dbContext = dbContextFactory.CreateDbContext()) { var postMapper = new PostMapper(); var entity = postMapper.ModelToEntity(model); dbContext.Posts.Add(entity); dbContext.SaveChanges(); return(postMapper.EntityToModel(entity)); } }
public PostDetailModel GetById(Guid id) { using (var dbContext = _dbContextFactory.CreateTeamChatDbContext()) { return(PostMapper.MapToDetailModel(dbContext.Posts .Include(a => a.Author) .Include(c => c.Comments) .ThenInclude(ca => ca.Author) .First(e => e.Id == id) )); } }
public void MapCommonConditionSuccessTest() { var post = new Post(2, 1, "My test post", "My test Body"); var postMapper = new PostMapper(); Entities.Post result = postMapper.Map(post); Assert.AreEqual(2, result.Id); Assert.AreEqual("My test post", result.Title); Assert.AreEqual("My test Body", result.Body); Assert.AreEqual(1, result.UserId); }
public PostDto CreatePost(PostDto postDto, int userId) { WikiArticle wikiArticle; string articleImageUrl = null; try { articleImageUrl = _wikiMediaApiService.GetWikiThumbnailAsync(postDto.ArticleTitle).Result; } catch (AggregateException e) { e.Handle((x) => { if (x is WikiArticleThumbnailNotFoundException) { articleImageUrl = WIKIARTICLE_DEFAULT_THUMBNAIL; return(true); } return(false); }); } wikiArticle = new WikiArticle() { Url = postDto.ArticleUrl, ArticleDate = _wikiMediaApiService.GetWikiLatestDateAsync(postDto.ArticleTitle).Result, ArticleBody = _wikiMediaApiService.GetWikiContentAsync(postDto.ArticleTitle).Result.Query.Pages.Values.First().Extract, ArticleTitle = postDto.ArticleTitle, ArticleImageUrl = articleImageUrl }; _db.WikiArticle.Add(wikiArticle); _db.SaveChanges(); PostType postType = _db.PostType.First(pt => pt.PostTypeValue == postDto.PostType); Post post = new Post() { UserId = userId, Date = DateTime.Now, WikiArticleId = wikiArticle.WikiArticleId, Title = postDto.Title, Description = postDto.Description, PostTypeId = postType.PostTypeId }; _db.Post.Add(post); _db.SaveChanges(); return(PostMapper.ToDtoPostUrl(post)); }
public PartialViewResult AjaxMorePosts(GetMorePostsViewModel getMorePostsViewModel) { // Get the topic var topic = ServiceFactory.TopicService.Get(getMorePostsViewModel.TopicId); // Get the permissions for the category that this topic is in var permissions = ServiceFactory.PermissionService.GetPermissions(topic.Category, _membersGroups); // If this user doesn't have access to this topic then just return nothing if (permissions[AppConstants.PermissionDenyAccess].IsTicked) { return(null); } var orderBy = !string.IsNullOrEmpty(getMorePostsViewModel.Order) ? AppHelpers.EnumUtils.ReturnEnumValueFromString <PostOrderBy>(getMorePostsViewModel.Order) : PostOrderBy.Standard; var viewModel = new ShowMorePostsViewModel { Topic = topic, Permissions = permissions, User = CurrentMember }; // Map the posts to the posts viewmodel // Get all favourites for this user var favourites = new List <Favourite>(); if (CurrentMember != null) { favourites.AddRange(ServiceFactory.FavouriteService.GetAllByMember(CurrentMember.Id)); } // Get the posts var posts = ServiceFactory.PostService.GetPagedPostsByTopic(getMorePostsViewModel.PageIndex, Settings.PostsPerPage, int.MaxValue, topic.Id, orderBy); // Get all votes for all the posts var postIds = posts.Select(x => x.Id).ToList(); var allPostVotes = ServiceFactory.VoteService.GetAllVotesForPosts(postIds); viewModel.Posts = new List <ViewPostViewModel>(); foreach (var post in posts) { var postViewModel = PostMapper.MapPostViewModel(permissions, post, CurrentMember, Settings, topic, allPostVotes, favourites); viewModel.Posts.Add(postViewModel); } return(PartialView(PathHelper.GetThemePartialViewPath("AjaxMorePosts"), viewModel)); }
public PostDto GetPost(int postId, int?userId) { Post post = _db.Post .Where(p => p.PostId == postId) .Include(p => p.PostType) .Include(p => p.WikiArticle) .Include(p => p.User) .Include(p => p.Favourite) .Include(p => p.PostLike) .FirstOrDefault(p => p.PostId == postId) ?? throw new PostNotFoundException(); return(PostMapper.ToDtoIncludeWikiArticle(post, userId)); }
public async Task <IActionResult> GetPostDetailAsync(int id) { var post = await _postService.GetAsync(id); if (post.IsDeleted || post == null) { return(StatusCode(404)); } var postDetailsViewModel = PostMapper.ConvertToPostDetailsViewModel(post); return(Ok(postDetailsViewModel)); }
private EditPostDTO MapToEditPostDTO(PostEditViewModel postEditModel) { var offset = TimeZoneInfo.Local.GetUtcOffset(DateTime.UtcNow); postEditModel.StartDate = postEditModel.StartDate.AddHours(offset.TotalHours); postEditModel.EndDate = postEditModel.EndDate.AddHours(offset.TotalHours); var editPostDto = PostMapper.ConvertToEditPostDTO(postEditModel); editPostDto.Files = MapFilesToDto(postEditModel.Files); return(editPostDto); }
///////////////INTERFACE METHOD////////////////////// public PostDTO CreatePostDTO(string title, string body, int score, int userId, DateTime creationDate, string PostType) { try { var p = CreatePost(title, body, score, userId, creationDate, PostType); return(PostMapper.MapPostToPostDTO(p)); } catch (Exception ex) { // UnitOfWork.WriteErrorLog(ex); } return(null); }
///convert to list of PostDTO. public IEnumerable <PostDTO> GetPostsAsDTOs() { try { var pList = GetPosts(); return(PostMapper.MapPostToPostDTOs(pList));; } catch (Exception ex) { //UnitOfWork.WriteErrorLog(ex); } return(null); }
public IEnumerable <PostDto> GetLikedPosts(int userId, int?limit, int?afterId) { IQueryable <PostLike> postLikeListQuery = _db.PostLike .Where(f => f.UserId == userId) .OrderByDescending(f => f.Date); // Applies afterId query if present if (afterId.HasValue) { // Check post with after_id as the id value exists PostLike queryInputPost = postLikeListQuery .FirstOrDefault(p => p.PostId == afterId); if (queryInputPost == null) { throw new PostNotFoundException(); } // Gets all posts in the order they were postliked after after_id (newest to oldest) postLikeListQuery = postLikeListQuery .Where(p => p.Date < queryInputPost.Date); } // Adds 1 to limit to efficiently calculate hasMore of last element in list int limitApplied = (limit.HasValue ? limit.Value : _options.GetPostDefaultLimit) + 1; IQueryable <Post> likedPosts = postLikeListQuery .Take(limitApplied) .Include(f => f.Post) .Include(f => f.Post.WikiArticle) .Select(f => f.Post); likedPosts.Select(p => p.PostType).Load(); likedPosts.Select(p => p.User).Load(); likedPosts.Select(p => p.Favourite).Load(); likedPosts.Select(p => p.PostLike).Load(); IEnumerable <PostDto> postDtoList = PostMapper.ToDto(likedPosts, userId).ToList(); if (postDtoList.Count() == limitApplied) { postDtoList = postDtoList.SkipLast(1); } else if (postDtoList.Any()) { PostDto lastPost = postDtoList.Last(); lastPost.HasMore = false; } return(postDtoList); }
private async Task <IEnumerable <Post> > GetCommentsAsync(List <int> commentIds, int offset) { var mapper = new PostMapper(); var ids = commentIds ?? new List <int>(); var tasks = ids.Skip(offset) .Take(PageSize) .Select(id => _apiService.GetHttpClient().GetPostAsync(id)); var acquiredPosts = await Task.WhenAll(tasks); return(new List <Post>(acquiredPosts.Select(x => mapper.ToDomainEntity(x)))); }
public void SetUp() { var dbFactory = new DatabaseFactory(); var personColumnProvider = new PersonColumnProvider(); var columnProvider = new PostColumnProvider(); var personMapper = new PersonMapper(personColumnProvider); var mapper = new PostMapper(columnProvider, personMapper); var helper = new DataParamHelper(); var paramRepository = new PostParamRepository(columnProvider, helper); var collectionRepository = new PostParamCollectionRepository(paramRepository); var personParamRepository = new PersonParamRepository(personColumnProvider, helper); var personCollectionRepository = new PersonParamCollectionRepository(personParamRepository); _repository = new PostRepository(dbFactory, mapper, collectionRepository); _personRepository = new PersonRepository(dbFactory, personMapper, personCollectionRepository); }