public async Task <Posts> UpdatePost(PostsViewModel model, List <string> fileName)
{
//fetch the old post
var post = postRepo.Get(model.PostId);
//update post properties
post.Content = string.IsNullOrWhiteSpace(model.Content) ? post.Content : model.Content;
post.PostCategory = model.PostCategory;
post.Visibility = model.VisibilityStatus;
post.DatePosted = post.DatePosted;
post.UserId = model.userId;
postRepo.Update(post);
foreach (var item in fileName)
{
MediaFiles media = new MediaFiles()
{
PostId = post.Id,
fileName = item,
};
_context.MediaFiles.Update(media);
}
await _context.SaveChangesAsync();
return(post);
}
public async Task <Posts> AddNewUserPost(PostsViewModel model, List <string> fileName)
{
//create a new instance of the entity post
Posts userPost = new Posts()
{
Id = Guid.NewGuid(),
Visibility = model.VisibilityStatus,
DatePosted = model.DatePosted,
Content = model.Content,
PostCategory = model.PostCategory,
UserId = model.userId
};
var postAdded = await postRepo.AddNewAsync(userPost);
//add each media file to db
foreach (var item in fileName)
{
MediaFiles media = new MediaFiles()
{
PostId = postAdded.Id,
fileName = item
};
_context.MediaFiles.Add(media);
}
if (postAdded != null)
{
await _context.SaveChangesAsync();
return(postAdded);
}
return(null);
}
public IActionResult Search(string name, int page = 1)
{
IQueryable <Post> source;
ViewBag.Name = name;
if (name != null)
{
source = _postService.FilterByPostedDate(_postService.GetAll(name));
}
else
{
source = _postService.FilterByPostedDate(_postService.GetAll());
}
var count = source.Count();
var items = source.Skip((page - 1) * pageSize).Take(pageSize).ToList();
PageViewModel pageViewModel = new PageViewModel(count, page, pageSize);
PostsViewModel viewModel = new PostsViewModel
{
PageViewModel = pageViewModel,
Posts = items
};
return(PartialView(viewModel));
}
public async Task <HttpResponseMessage> GetPosts(int Id, string languageCode)
{
try
{
var result = new PostsViewModel();
List <string> list = new List <string> {
"LanguageCode", "CategoryId", "numTop", "priority", "type"
};
var para = APIProvider.APIDefaultParameter(list, languageCode, (int)CategoryId.Posts, NUM_TOP, POSTSORT_TYPE.NEW);
var paraDetail = APIProvider.APIDefaultParameter(new List <string> {
"id"
}, Id);
var detail = await _iPostRepo.SingleQuery(paraDetail);
detail.Image = detail.Image.Contains(ValueConstants.IMAGE_DEFAULT) == true ? null : LayoutGuide.SPA_ResourcePath(Provider.Common.APIEnums.Application.CMS, detail.Image);
var listPost = await _iPostRepo.Query(para);
result.lstPostListViewModel = Mapper.Map <List <PostListViewModel> >(listPost);
result.PostViewModel = Mapper.Map <PostViewModel>(detail);
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public void GivenAPostsViewModel_WhenIGetACollectionOfPostViewModels_ThenItIsInitialized()
{
var model = new PostsViewModel();
List <PostViewModel> posts = model.Posts;
Assert.That(posts, Is.Not.Null);
}
public async Task <IActionResult> IndexAsync(string name = null, int page = 1)
{
//throw new ArgumentException("Test Error");
IQueryable <Post> source;
ViewBag.Name = name;
if (name != null)
{
source = _postService.FilterByPostedDate(_postService.GetAll(name));
}
else
{
source = _postService.FilterByPostedDate(_postService.GetAll());
}
var count = await source.CountAsync();
var items = await source.Skip((page - 1) *pageSize).Take(pageSize).ToListAsync();
PageViewModel pageViewModel = new PageViewModel(count, page, pageSize);
PostsViewModel viewModel = new PostsViewModel
{
PageViewModel = pageViewModel,
Posts = items
};
return(View(viewModel));
}
public IActionResult Posts()
{
var model = new PostsViewModel(); //sorulacak
model.Posts = _postService.GetPostsWithUserInformation();
return(View(model));
}
public override ActionResult Index(int id)
{
PostsMetrics metrics = this.metricsService.GetPostsMetrics(id);
MetricsViewModel viewModel = new PostsViewModel(metrics);
return(this.MetricsView("Posts", viewModel));
}
// GET: Patients
public ActionResult Index()
{
var viewModel = new PostsViewModel();
var patientId = User.Identity.GetUserId();
var userType = db.Users.FirstOrDefault(x => x.Id == patientId).UserType;
ViewBag.PatientId = patientId;
ViewBag.UserType = userType;
viewModel.Categories = db.Categories.Include(p => p.Posts).Where(x => x.Posts.Any()).ToList();
viewModel.CommentsViewModel = new List <CommentsViewModel>();
foreach (var category in viewModel.Categories)
{
foreach (var post in category.Posts)
{
var postComments = db.Comments.Where(x => x.PostId == post.Id).ToList();
foreach (var comment in postComments)
{
var commentViewModel = new CommentsViewModel()
{
Comment = comment,
OwnerName = db.Users.FirstOrDefault(x => x.Id == comment.DoctorId).UserName,
};
viewModel.CommentsViewModel.Add(commentViewModel);
}
}
}
return(View(viewModel));
}
public async Task <ActionResult <PostsViewModel> > NewPost(PostsViewModel model)
{
List <string> fileName = null;
if (model != null)
{
//handle the upload if the user added an image to the post
if (model.Image != null && model.Image.Count() > 0)
{
foreach (var media in model.Image)
{
//verify file extension
var ext = Path.GetExtension(media.FileName).ToLower();
if (ext == ".jpg" || ext == ".jpeg" || ext == ".png" || ext == ".mp4" || ext == ".3gp")
{
fileName.Add(UploadFile.Upload(media, Folder));
}
else
{
return(BadRequest("file format not supported"));
}
}
}
model.DatePosted = DateTime.Now; //set the timestamp
model.userId = Guid.Parse(GetUser().Result.Id); //set the user id
model.PostCategory = Category.UserStories; //set the post category as UserStories
var addedPost = await postService.AddNewUserPost(model, fileName);
return(CreatedAtRoute(nameof(GetPost), new { addedPost.Id }, addedPost));
}
return(BadRequest());
}
public async Task <IActionResult> GetAllWorksContest(int?contestId, int?nominationId)
{
IQueryable <Post> posts = _context.Posts
.Include(x => x.Author)
.Include(x => x.Likes)
.Include(x => x.Nomination)
.Where(x => x.ContestId == contestId);
if (nominationId != null && nominationId != 0)
{
posts = posts.Where(x => x.NominationId == nominationId);
}
List <Nomination> nominations = await _context.Nominations.Where(x => x.ContestId == contestId).ToListAsync();
nominations.Insert(0, new Nomination {
Id = 0, Name = "Все номинации"
});
PostsViewModel viewModel = new PostsViewModel()
{
Posts = posts.ToList(),
Nominations = new SelectList(nominations, "Id", "Name"),
HelpNamePost = new Post()
};
ViewBag.ContestId = contestId;
return(View(viewModel));
}
public ActionResult Destroy([DataSourceRequest] DataSourceRequest request, PostsViewModel model)
{
this._posts.Delete(model.Id);
this._posts.SaveChanges();
return(this.GetGridOperations(request, model));
}
public PostsViewModel GetPagePosts(int pageSize, int pageIndex)
{
var skipCount = pageSize * (pageIndex - 1);
var validCount = pageSize;
if (skipCount >= _cache.Count)
{
return(new PostsViewModel());
}
if (validCount > _cache.Count - skipCount)
{
validCount = _cache.Count - skipCount;
}
var posts = _cache.OrderByDescending(p => p.Key).Skip(skipCount).Take(validCount).Select(p => p.Value).ToList();
var postsView = new PostsViewModel
{
CurrPageIndex = pageIndex,
HasLastPage = pageIndex > 1 ? true : false,
HasNextPage = _cache.Count > skipCount + validCount ? true : false,
PostEntries = _mapper.Map <List <PostEntryViewModel> >(posts)
};
return(postsView);
}
public ActionResult Search(string query, int page = 1)
{
var take = 10;
var skip = ((page - 1) * take);
var postsVM = new PostsViewModel()
{
Categories = new List <string>(),
PopularPosts = new List <PostViewModel>(),
Posts = new List <PostViewModel>(),
RecentPosts = new List <PostViewModel>(),
Tags = new List <string>()
};
BuildAdditionalInformation(postsVM);
var posts = _postService.Table.Where(p => p.Title.Contains(query) || p.TextBody.Contains(query));
postsVM.TotalPosts = posts.Count();
postsVM.TotalPages = (int)Math.Ceiling(postsVM.TotalPosts * 1.0 / take);
postsVM.CurrentPage = page;
foreach (var post in posts.OrderByDescending(ob => ob.PublishDate).Skip(skip).Take(take))
{
postsVM.Posts.Add(new PostViewModel(post));
}
return(View("~/Views/Post/Index.cshtml", postsVM));
}
public IActionResult Index(
int?page, string searchString, int?postCategoryId, string postTag, PostSortFilterType postSortFilterType = PostSortFilterType.SortByDateDesc)
{
var postSearch = new PostSearch()
{
SearchString = searchString,
PostCategoryId = postCategoryId,
PostTag = postTag,
PostSortFilterType = postSortFilterType,
};
int pageSize = 6;
var posts = GetPosts(postSearch, pageIndex: page - 1 ?? 0, pageSize: pageSize);
var blogViewModel = new PostsViewModel()
{
PostViewModels = _mapper.Map <IEnumerable <Post>, IEnumerable <PostViewModel> >(posts),
Pager = new Pager(posts.TotalCount, posts.TotalPages, page, pageSize),
SearchString = searchString,
PostCategoryId = postCategoryId,
PostTag = postTag,
PostSortFilterType = postSortFilterType
};
return(View(blogViewModel));
}
public async Task <PostsViewModel> GetAllPostsAsync(int id, int page, int size)
{
if (id != 0)
{
var posts = await db.UserPosts
.Where(p => p.User.UserFriends.Any(f => f.Friend.Id == id))
.OrderByDescending(s => s.TimeOfPublication)
.Skip((page - 1) * size)
.Take(size)
.Select(x => new UserPostViewModel(x)).ToListAsync();
var count = db.UserPosts
.Where(p => p.User.UserFriends.Any(f => f.Friend.Id == id)).Count();
var postsViewModel = new PostsViewModel
{
userPostViewModels = posts,
Count = count
};
return(postsViewModel);
}
else
{
return(new PostsViewModel());
}
}
// GET: Posts
public ActionResult Index(int?categoryId)
{
TempData["categoryId"] = categoryId;
List <Post> posts = new List <Post>();
if (categoryId != null)
{
posts = db.Posts.Include(p => p.Category).Include(p => p.Op).Where(p => p.CategoryId == categoryId).ToList();
}
//else TODO: Implement hot page based on likes/views
PostsViewModel postsViewModel = new PostsViewModel {
UserImage = User.Identity.IsAuthenticated ? db.Users.Find(User.Identity.GetUserId()).Image_url : null,
IsAdmin = User.IsInRole(Const.ADMIN),
IsMod = User.IsInRole(Const.MODERATOR),
IsUser = User.Identity.IsAuthenticated,
CategoryID = categoryId,
Posts = posts
};
//TODO: ask how do I deal with partials and ViewModels data aka without using ViewBag
ViewBag.IsAdmin = User.IsInRole(Const.ADMIN);
ViewBag.IsMod = User.IsInRole(Const.MODERATOR);
ViewBag.UserID = User.Identity.GetUserId();
return(View(postsViewModel));
}
public ViewViewComponentResult Invoke(int postId)
{
var model = new PostsViewModel();
model.Posts = _postService.GetPosts().OrderByDescending(x => x.Id).Take(10).ToList();
return(View(model));
}
public async Task <IActionResult> Posts(int?id, int?nomination)
{
IQueryable <Post> posts = _context.Posts
.Include(x => x.Author)
.Include(x => x.Nomination)
.Include(x => x.Cover)
.Where(x => x.ContestId == id)
.Where(x => x.Status == StatusPost.Accept);
if (nomination != null && nomination != 0)
{
posts = posts.Where(x => x.NominationId == nomination);
}
List <Nomination> nominations = await _context.Nominations.Where(x => x.ContestId == id).ToListAsync();
nominations.Insert(0, new Nomination {
Id = 0, Name = "Все"
});
PostsViewModel viewModel = new PostsViewModel()
{
Posts = posts.ToList(),
Nominations = new SelectList(nominations, "Id", "Name"),
HelpNamePost = new Post()
};
ViewData["ContestId"] = id;
ViewData["ContestName"] = _context.Contests.FirstOrDefault(x => x.Id == id).Name;
return(View(viewModel));
}
public ActionResult SinglePost(string id)
{
///Replace with 404 of the future
if (string.IsNullOrEmpty(id))
{
return(RedirectToRoute("~/"));
}
Post post = _postService.Table.FirstOrDefault(p => (p.Meta.Permalink == id || p.Meta.Permalink == "blog/" + id) && p.PublishDate <= DateTime.UtcNow);
if (post == null || post.ID <= 0)
{
return(Redirect("~/Error/404"));
}
var postsVM = new PostsViewModel()
{
Categories = new List <string>(),
PopularPosts = new List <PostViewModel>(),
Posts = new List <PostViewModel>()
{
new PostViewModel(post)
},
RecentPosts = new List <PostViewModel>(),
Tags = new List <string>()
};
BuildAdditionalInformation(postsVM);
HttpContext.Items["Vin_Meta"] = _postService.GetMetaData(post);
return(View(postsVM));
}
public ActionResult Index(int page = 1)
{
var postsVM = new PostsViewModel()
{
Categories = new List <string>(),
PopularPosts = new List <PostViewModel>(),
Posts = new List <PostViewModel>(),
RecentPosts = new List <PostViewModel>(),
Tags = new List <string>()
};
BuildAdditionalInformation(postsVM);
var posts = _postService.Table.Where(p => p.PublishDate <= DateTime.UtcNow);
postsVM.TotalPosts = posts.Count();
postsVM.TotalPages = (int)Math.Ceiling(postsVM.TotalPosts * 1.0 / postsVM.PostsPerPage);
postsVM.CurrentPage = page;
foreach (var post in posts.OrderByDescending(ob => ob.PublishDate).Skip((page - 1) * postsVM.PostsPerPage).Take(postsVM.PostsPerPage))
{
postsVM.Posts.Add(new PostViewModel(post));
}
return(View(postsVM));
}
public IActionResult PostsPage()
{
var posts = _posts.GetAll();
var viewModel = new PostsViewModel(posts);
return(View(viewModel));
}
//
// GET: /Posts/
public ActionResult List(int?page = 1, string tag = null)
{
int skip = Settings.Default.PostsPageSize * (page.Value - 1);
RavenQueryStatistics stats;
IQueryable <Post> posts;
posts = RavenSession.Query <Post>()
.Statistics(out stats)
.Take(Settings.Default.PostsPageSize)
.OrderByDescending(x => x.CreatedAt);
if (!string.IsNullOrWhiteSpace(tag))
{
posts = posts.Where(p => p.Tags.Any(t => t == tag));
}
var viewModel = new PostsViewModel(posts.ToList(), page.Value, stats.TotalResults, tag);
foreach (var post in viewModel.Posts)
{
post.Author = RavenSession.GetPostAuthor(post.Post);
}
return(View(viewModel));
}
// GET: Posts
public async Task <IActionResult> Index(int?nomination)
{
IQueryable <Post> posts = _context.Posts
.Include(x => x.Author)
.Include(x => x.Nomination)
.Include(x => x.Cover)
.Where(x => x.Status == StatusPost.Accept);
if (nomination != null && nomination != 0)
{
posts = posts.Where(x => x.NominationId == nomination);
}
List <Nomination> nominations = await _context.Nominations.ToListAsync();
nominations.Insert(0, new Nomination {
Id = 0, Name = "All"
});
PostsViewModel viewModel = new PostsViewModel()
{
Posts = posts.ToList(),
Nominations = new SelectList(nominations, "Id", "Name"),
HelpNamePost = new Post()
};
return(View(viewModel));
}
public HomePageViewModel Retrive()
{
var data = new HomePageViewModel();
var posts = _context.Post.ToList();
foreach (var post in posts)
{
int commentCount = _context.Comments.Where(c => c.PostID == post.ID).Count();
var temp = new PostsViewModel()
{
ID = post.ID,
Author = post.Author,
Content = post.Content,
Date = post.Date,
PreviewText = post.PreviewText,
Tags = post.Tags.Split(',').ToList(),
Title = post.Title,
TotalComments = commentCount
};
data.Posts.Add(temp);
}
data.Tags = _context.Tags.ToList();
data.Tags.OrderByDescending(t => t.TotalPost);
return(data);
}
public IActionResult PostsPage(int pageNumber = 0, int pageSize = 10)
{
var posts = _posts.GetAll(pageNumber, pageSize);
var viewModel = new PostsViewModel(posts);
return(View(viewModel));
}
// GET: Posts - Laver en liste af posts
public async Task <IActionResult> Index([FromServices] UserManager <User> userManager)
{
//Returnerer brugeren af systemet.
var user = await userManager.GetUserAsync(User);
//Finder brugere brugeren følger.
var userFollow = _context.Users.Where(u => u.Id == user.Id).Include(user => user.Following).First();
//Finder mine posts.
var myPosts = _context.Posts.Where(mp => mp.ApplicationUserId == user.Id).ToList();
//Laver ny liste af posts da man ikke vil have alle posts i systemet, bare de posts fra dem brugeren følger.
IEnumerable <Post> posts = new List <Post>();
//Smider mine posts i den nye liste.
posts = posts.Concat(myPosts);
//Smider followers posts i listen.
foreach (var followersPosts in userFollow.Following)
{
posts = posts.Concat(_context.Posts.Where(p => p.ApplicationUserId == followersPosts.followersId).Include(p => p.ApplicationUser).ToList());
}
//Sørger for at bruge PostsViewModel, så man både kan se og oprette posts på samme vindue.
var pvm = new PostsViewModel();
//Sorterer posts i dato rækkefølge.
pvm.Posts = posts.OrderByDescending(p => p.Date);
//Returnerer mine og follwers posts.
return(View(pvm));
}
/// <summary>
/// Display latest <see cref="Post"/> objects in current space.
/// </summary>
/// <param name="app">The app</param>
/// <param name="query">An object with query parameters for search, paging etc.</param>
public override ActionResult Get(Posts app, Query query)
{
var model = new PostsViewModel();
if (!IsEmbedded)
{
model.Members = SpaceService.GetMembers(WeavyContext.Current.Space.Id, new MemberQuery {
Top = 6, OrderBy = "Random", Count = true
});
model.ExternalMemberCount = SpaceService.GetMembers(WeavyContext.Current.Space.Id, new MemberQuery {
External = true, CountOnly = true
}).TotalCount ?? 0;
model.InviteCount = InviteService.Search(new InviteQuery()
{
Top = 6, OrderBy = "Random", SpaceId = app.SpaceId, CountOnly = true
}).TotalCount ?? 0;
}
query.Top = PageSizes[0] / 5; // NOTE: reduced number of items/page for better perf.
model.Posts = PostService.GetPosts(app.Id, opts: query);
if (Request.IsAjaxRequest())
{
// infinite scroll, return partial view
return(PartialView("_Posts", model.Posts));
}
// REVIEW: can we do this automagically?
return(View(IsEmbedded ? "Get.Embedded": null, model));
}
public ViewViewComponentResult Invoke()
{
var model = new PostsViewModel();
model.Posts = _postService.GetPostByCurrentUser();
return(View(model));
}
public PaginatedList <PostsViewModel> GetPost(string postText, int pageIndex)
{
var pageSize = 10;
var posts = new List <Posts>();
if (!string.IsNullOrEmpty(postText))
{
posts = db.Posts.Where(a => a.Post.ToLower().Contains(postText.ToLower())).ToList();
}
else
{
posts = db.Posts.ToList();
}
var postsViewModelList = new List <PostsViewModel>();
foreach (Posts post in posts)
{
PostsViewModel postsView = new PostsViewModel();
postsView.IsPost = true;
postsView.Post = post.Post;
postsView.DateTime = post.PostTime;
if (db.Users.FirstOrDefault(a => a.UserId == post.UserId) != null)
{
postsView.User = db.Users.FirstOrDefault(a => a.UserId == post.UserId).UserName;
}
var comments = db.Comments.Where(a => a.PostId == post.PostId).ToList();
postsView.CommentCount = comments.Count();
postsViewModelList.Add(postsView);
foreach (Comments comment in comments)
{
postsView = new PostsViewModel();
postsView.Comment = comment.Comment;
postsView.IsPost = false;
postsView.DateTime = comment.CommentTime;
if (db.Users.FirstOrDefault(a => a.UserId == comment.UserId) != null)
{
postsView.User = db.Users.FirstOrDefault(a => a.UserId == comment.UserId).UserName;
}
postsView.Like = db.Likes.Where(a => a.IsLike == true).Count();
postsView.Dislike = db.Likes.Where(a => a.IsLike == false).Count();
postsViewModelList.Add(postsView);
}
}
PaginatedList <PostsViewModel> allpost = new PaginatedList <PostsViewModel>();
allpost.PageIndex = pageIndex;
allpost.TotalPages = (int)Math.Ceiling(postsViewModelList.Count() / (double)pageSize);
allpost.TotalRecords = postsViewModelList.Count();
allpost.Data = postsViewModelList.GetRange(pageIndex - 1 * 10, 10);
allpost.HasNextPage = (allpost.PageIndex > 1);
allpost.HasPreviousPage = (allpost.PageIndex < allpost.TotalPages);
allpost.Data = postsViewModelList;
return(allpost);
}
public OpenPost ()
{
InitializeComponent ();
//NavigationPage.SetHasNavigationBar(this, false);
var postsViewModel = new PostsViewModel ();
BindingContext = postsViewModel.PostsList [0];
outerScrollView.Scrolled += (object sender, ScrolledEventArgs e) => {
var imageHeight = img.Height * 2;
var scrollRegion = layeringGrid.Height - outerScrollView.Height;
var parallexRegion = imageHeight - outerScrollView.Height;
var factor = outerScrollView.ScrollY - parallexRegion * (outerScrollView.ScrollY / scrollRegion);
img.TranslationY = factor;
img.Opacity = 1 - ( factor / imageHeight ) ;
headers.Scale = 1 - ( (factor ) / (imageHeight * 2) ) ;
};
}
public ActionResult Index(int page = 1)
{
var postsVM = new PostsViewModel()
{
Categories = new List<string>(),
PopularPosts = new List<PostViewModel>(),
Posts = new List<PostViewModel>(),
RecentPosts = new List<PostViewModel>(),
Tags = new List<string>()
};
BuildAdditionalInformation(postsVM);
var posts = _postService.Table.Where(p => p.PublishDate <= DateTime.UtcNow);
postsVM.TotalPosts = posts.Count();
postsVM.TotalPages = (int)Math.Ceiling(postsVM.TotalPosts * 1.0 / postsVM.PostsPerPage);
postsVM.CurrentPage = page;
foreach (var post in posts.OrderByDescending(ob => ob.PublishDate).Skip((page - 1) * postsVM.PostsPerPage).Take(postsVM.PostsPerPage))
postsVM.Posts.Add(new PostViewModel(post));
return View(postsVM);
}
public ActionResult SinglePost(string id)
{
///Replace with 404 of the future
if (string.IsNullOrEmpty(id))
return RedirectToRoute("~/");
Post post = _postService.Table.FirstOrDefault(p => (p.Meta.Permalink == id || p.Meta.Permalink == "blog/" + id) && p.PublishDate <= DateTime.UtcNow);
if (post == null || post.ID <= 0)
return Redirect("~/Error/404");
var postsVM = new PostsViewModel()
{
Categories = new List<string>(),
PopularPosts = new List<PostViewModel>(),
Posts = new List<PostViewModel>() { new PostViewModel(post) },
RecentPosts = new List<PostViewModel>(),
Tags = new List<string>()
};
BuildAdditionalInformation(postsVM);
HttpContext.Items["Vin_Meta"] = _postService.GetMetaData(post);
return View(postsVM);
}
private void BuildAdditionalInformation(PostsViewModel postsVM)
{
var postSettings = _settingService.LoadSetting<PostSettings>();
postsVM.CommentsEnabled = postSettings.CommentsEnabled;
postsVM.PostsPerPage = postSettings.PostsPerPage == 0 ? 5 : postSettings.PostsPerPage;
postsVM.ShowPopularPosts = postSettings.ShowPopularPosts;
postsVM.ShowRecentPosts = postSettings.ShowRecentPosts;
var posts = _postService.Table.Where(p => p.PublishDate <= DateTime.UtcNow);
if (postsVM.ShowRecentPosts)
foreach (var post in posts.OrderByDescending(ob => ob.PublishDate).Take(3))
postsVM.RecentPosts.Add(new PostViewModel(post));
if (postsVM.ShowPopularPosts)
foreach (var post in posts.OrderBy(ob => Guid.NewGuid()).Take(3))
postsVM.PopularPosts.Add(new PostViewModel(post));
var tags = posts.SelectMany(s => s.Tags.Distinct());
if (tags.Count() > 0)
tags.GroupBy(gb => gb.Name).ToList().ForEach(t => postsVM.Tags.Add(t.Key));
var cats = posts.SelectMany(s => s.Categories.Distinct());
if (cats.Count() > 0)
cats.GroupBy(gb => gb.Name).ToList().ForEach(c => postsVM.Categories.Add(c.Key));
}
public ActionResult Search(string query, int page = 1)
{
var take = 10;
var skip = ((page - 1) * take);
var postsVM = new PostsViewModel()
{
Categories = new List<string>(),
PopularPosts = new List<PostViewModel>(),
Posts = new List<PostViewModel>(),
RecentPosts = new List<PostViewModel>(),
Tags = new List<string>()
};
BuildAdditionalInformation(postsVM);
var posts = _postService.Table.Where(p => p.Title.Contains(query) || p.TextBody.Contains(query));
postsVM.TotalPosts = posts.Count();
postsVM.TotalPages = (int)Math.Ceiling(postsVM.TotalPosts * 1.0 / take);
postsVM.CurrentPage = page;
foreach (var post in posts.OrderByDescending(ob => ob.PublishDate).Skip(skip).Take(take))
postsVM.Posts.Add(new PostViewModel(post));
return View("~/Views/Post/Index.cshtml", postsVM);
}
public ArticlesListVariant ()
{
InitializeComponent ();
BindingContext = new PostsViewModel ();
}
