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);
}
