private async Task LoadPosts()
{
var selectedSubcategory = boxSubcategory.SelectedItem as SubcategoryDto;
var selectedCategory = boxCategory.SelectedItem as CategoryDto;
var postSearchRequest = new PostSearchRequest
{
Title = txtTitle.Text,
SubcategoryId = selectedSubcategory != null ? selectedSubcategory.Id : 0,
CategoryId = selectedCategory.Id
};
var data = (await _postService.Get <List <PostDto> >(postSearchRequest, "search"))
.Select(a => new PostDataGrid
{
Id = a.Id,
Title = a.Title,
DateCreated = a.DateCreated,
Subcategory = a.Subcategoryname,
User = a.Username,
UserId = a.UserId
}).ToList();
dataGridView1.DataSource = data;
}
public ActionResult <PostListResponse> Search([FromQuery] PostSearchRequest searchRequest)
{
var posts = _posts.Search(searchRequest);
var postCount = _posts.Count(searchRequest);
return(PostListResponse.Create(searchRequest, posts, postCount));
}
public IList<PostDto> Get(PostSearchRequest search)
{
var query = _context.Posts.Include(a => a.Subcategory)
.ThenInclude(a => a.Category)
.Include(a => a.User)
.AsQueryable();
if (!string.IsNullOrWhiteSpace(search?.Title))
{
query = query.Where(x => x.Title.Contains(search.Title));
}
if (search.CategoryId != null && search.CategoryId != 0)
{
query = query.Where(x => x.Subcategory.CategoryId == search.CategoryId);
}
if (search.SubcategoryId != null && search.SubcategoryId != 0) // search.SubcategoryId.HasValue
{
query = query.Where(x => x.SubcategoryId == search.SubcategoryId);
}
var entities = query.ToList();
var result = _mapper.Map<IList<PostDto>>(entities.Where(x => 1 == 1));
return result;
}
public async Task <IEnumerable <PostSearchResponse> > SearchAsync([FromQuery] PostSearchRequest request,
CancellationToken cancellationToken)
{
var result = await _postQuery.SearchAsync(request, cancellationToken);
return(result);
}
public Task <BaseFindResponse <Post> > SearchPostsAsync(PostSearchRequest request)
{
return(Task.Run(() =>
{
var query = context.PostsAsQueryable.Where(a => a.IsPublished);
if (request.CategoryId.HasValue())
{
query = query.Where(a => a.CategoryId == request.CategoryId);
}
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(a => a.Title.ToLowerInvariant().Contains(request.Keyword.ToLowerInvariant()) ||
a.Description.ToLowerInvariant().Contains(request.Keyword.ToLowerInvariant()));
}
var posts = query.OrderByDescending(a => a.PublishedDate)
.Skip(request.Skip)
.Take(request.PageSize)
.ToList();
return new BaseFindResponse <Post>
{
Results = posts,
TotalRecords = query.Count()
};
}));
}
public PostRelatedOrRecentListViewModel GetForMainPageListForRelated(PostSearchRequest request)
{
var result = _post.Where(q => q.IsActive).Select(q => new PostRelatedOrRecentDetailViewModel
{
Title = q.Title,
Id = q.Id,
CategoryId = q.CategoryId
}).AsQueryable();
if (request.CategoryId != 0)
{
result = result.Where(q => q.CategoryId == request.CategoryId & q.Id != request.PostId);
}
request.Total = result.Count();
var resultsToSkip = (request.PageIndex - 1) * request.PageSize;
var query = result
.OrderByDescending(r => r.Id)
.Skip(() => resultsToSkip)
.Take(() => request.PageSize)
.ToList();
return(new PostRelatedOrRecentListViewModel {
Posts = query, SearchRequest = request
});
}
public IEnumerable <Post> Search(PostSearchRequest search)
{
return(_context.Posts
.OrderByDescending(p => p.PostedAt)
.Where(p => search.PostedBy == null || p.UserId == search.PostedBy)
.Skip((search.Page - 1) * search.PageSize)
.Take(search.PageSize));
}
public async Task <BaseFindResponse <PostModel> > SearchPostsAsync(PostSearchRequest request)
{
var posts = _mapper.Map <BaseFindResponse <PostModel> >(await _blogRepository.SearchPostsAsync(request));
await Populate(posts.Results);
return(posts);
}
public async Task <PostListViewModel> GetPagedListAsync(PostSearchRequest request)
{
request.Categories = _allCategoriesForSearch;
request.Creators = _allCreatorsForSearch;
var result = _post
.ProjectTo <PostDetailViewModel>(_mappingEngine);
if (!string.IsNullOrWhiteSpace(request.Title))
{
result = result.Where(a => a.Title.Contains(request.Title) || a.Body.Contains(request.Title) || a.Summary.Contains(request.Title)).AsQueryable();
}
if (!string.IsNullOrWhiteSpace(request.Keyword))
{
result = result.Where(a => a.Keyword.Contains(request.Keyword)).AsQueryable();
}
if (request.CategoryId != 0)
{
result = result.Where(a => a.CategoryId == request.CategoryId).AsQueryable();
}
if (request.CreatorId != 0)
{
result = result.Where(a => a.CreatorId == request.CreatorId).AsQueryable();
}
switch (request.IsActive)
{
case ActiveStatus.Enable:
result = result.Where(a => a.IsActive).AsQueryable();
break;
case ActiveStatus.Disable:
result = result.Where(a => !a.IsActive).AsQueryable();
break;
case ActiveStatus.All:
break;
}
request.Total = result.Count();
var resultsToSkip = (request.PageIndex - 1) * request.PageSize;
var query = await result
.OrderByDescending(r => r.Id)
.Skip(() => resultsToSkip)
.Take(() => request.PageSize)
.ToListAsync();
return(new PostListViewModel {
Posts = query, SearchRequest = request
});
}
public async Task <ActionResult> ListAjax(PostSearchRequest search)
{
var posts = await _postService.GetPagedListAsync(search);
var viewModel = new PostListViewModel()
{
Posts = posts.Posts,
SearchRequest = search
};
return(PartialView("_ListAjax", viewModel));
}
private PostFilter CreatePostFilter(PostSearchRequest request)
{
return(new PostFilter
{
Text = request.Content,
Authors = request.AccountNames,
Lists = request.Lists,
Network = request.Network,
DateRange = request.DateRange,
Page = request.Page
});
}
public List <MPost> GetAll(PostSearchRequest search)
{
List <MPost> returning = new List <MPost>();
if (search != null)
{
returning = _posts
.Where(i => i.Account.Username == search.Username)
.ToList();
}
returning = _posts.ToList();
return(returning);
}
public async Task <PostMainListViewModel> GetForMainPagePagedListForAsync(PostSearchRequest request)
{
var result = _post.Select(q => new PostMainDetailViewModel
{
Summary = q.Summary,
CategoryTitle = q.Category.Title,
Title = q.Title,
Keywords = q.Keyword,
CreatedOn = q.CreatedOn,
CategoryId = q.CategoryId,
CreatorId = q.CreatorId,
IsActive = q.IsActive,
CreatorName = q.Creator.NameForShow,
Id = q.Id,
CommentsCount = q.Comments.Count(a => a.IsActive)
}).AsQueryable();
//.ProjectTo<PostMainDetailViewModel>(_mappingEngine);
request.PageSize = 5;
if (request.CategoryId != 0)
{
result = result.Where(q => q.CategoryId == request.CategoryId);
}
if (request.Term != null)
{
result = result.Where(q => q.Summary.Contains(request.Term) | q.Title.Contains(request.Term) | q.Keywords.Contains(request.Term));
}
request.Total = result.Count();
var resultsToSkip = (request.PageIndex - 1) * request.PageSize;
var query = await result
.Where(q => q.IsActive)
.OrderByDescending(r => r.Id)
.Skip(() => resultsToSkip)
.Take(() => request.PageSize)
.ToListAsync();
if (request.CategoryId != 0)
{
request.CategoryTitle = _allCategories.FirstOrDefault(q => q.Value == request.CategoryId.ToString())?.Text;
}
return(new PostMainListViewModel {
Posts = query, SearchRequest = request
});
}
public async Task <IEnumerable <PostSearchResponse> > SearchAsync(PostSearchRequest request,
CancellationToken cancellationToken)
{
await _postFilterValidator.ValidateAndThrowAsync(request, cancellationToken);
var filter = CreatePostFilter(request);
var result = await _readPostRepository.SearchAsync(filter, cancellationToken);
return(result.Select(x => new PostSearchResponse
{
Date = x.Date,
Content = x.Content,
Link = x.Link,
Network = x.Network,
Account = x.Author,
Lists = x.Lists,
}));
}
public List <MPost> Get(PostSearchRequest search)
{
var query = _context.AdministratorPosts.AsQueryable();
if (search.Title != null)
{
query = query.Where(x => x.Post.Title.Equals(search.Title));
}
if (search.AdministratorId != 0)
{
query = query.Where(x => x.Administrator.AdministratorId == search.AdministratorId);
}
var list = query.Select(s => new MPost
{
PostId = s.Post.PostId,
Title = s.Post.Title,
PostDate = s.Post.PostDate,
Content = s.Post.Content,
AdministratorId = s.Administrator.AdministratorId,
Author = s.Administrator.FirstName + " " + s.Administrator.LastName
}).ToList();
return(_mapper.Map <List <MPost> >(list));
}
public int Count(PostSearchRequest search)
{
return(_context.Posts
.Count(p => search.PostedBy == null || p.UserId == search.PostedBy));
}
public List <MPost> Get([FromQuery] PostSearchRequest search)
{
return(_service.Get(search));
}
public IActionResult Get([FromQuery] PostSearchRequest request)
{
return(Ok(_postService.Get(request)));
}
public IActionResult SearchPost(PostSearchRequest request) => Ok(_postService.SearchPost(request));
public void given_i_have_a_request_for_searching_posts()
{
_postFilter = new PostSearchRequest();
}
public List <Dal.Models.Post> Get([FromQuery] PostSearchRequest request)
{
return(_post.Get(request));
}
public PagedResults <List <ImageDto> > PagedSearchResults(PostSearchRequest postSearchRequest)
{
if (postSearchRequest == null)
{
return(null);
}
if (postSearchRequest.Page <= 0)
{
postSearchRequest.Page = 1;
}
var noTags = postSearchRequest.Tags.Any(id => id == -1);
var tags = postSearchRequest.Tags.Where(id => id != -1).ToList();
var query = Context.Thumbnails
.Include(t => t.Comments)
.Include(t => t.PhotoBooks)
.Include(t => t.Faces)
.ThenInclude(tt => tt.Tag)
.Include(t => t.TagThumbnails)
.ThenInclude(tt => tt.Tag)
.ThenInclude(tag => tag.TagType)
.Where(t =>
t.FileCreateDateTime >= postSearchRequest.Start &&
(postSearchRequest.End == null || t.FileCreateDateTime <= postSearchRequest.End.Value) &&
t.Hide == postSearchRequest.ShowHidden &&
(postSearchRequest.Tags.Count == 0 || (noTags && !t.TagThumbnails.Any()) || (!noTags && t.TagThumbnails.Any(tt => tags.Contains(tt.Tag.Id)))) &&
((postSearchRequest.States.Count == 0 && postSearchRequest.Cities.Count == 0) || (t.Location.LocationComponents.Any(c =>
(c.Component.TypesString.Contains(((int)GoogleAddressType.AdministrativeAreaLevel1).ToString()) &&
postSearchRequest.States.Any(s => s == c.Component.LongName)) ||
(c.Component.TypesString.Contains(((int)GoogleAddressType.Locality).ToString()) &&
postSearchRequest.Cities.Any(s => s == c.Component.LongName))
))) &&
(postSearchRequest.Locations.Count == 0 || postSearchRequest.Locations.Any(l => l == t.LocationId.Value))
);
IOrderedQueryable <Thumbnail> orderedQuery = null;
if (!postSearchRequest.OrderDetails.Any())
{
postSearchRequest.OrderDetails.Add(new OrderByDto
{
Name = "Date",
Asc = false
});
}
foreach (var orderBy in postSearchRequest.OrderDetails)
{
switch (orderBy.Name.ToLower())
{
case ("date"):
{
orderedQuery = AddOrder(query, orderedQuery, orderBy.Asc, o => o.FileCreateDateTime);
break;
}
case ("tags"):
{
orderedQuery = AddOrder(query, orderedQuery, orderBy.Asc,
o => !o.TagThumbnails.Any(tag => orderBy.Tags.Contains(tag.TagId)));
break;
}
case ("num tags"):
{
orderedQuery = AddOrder(query, orderedQuery, orderBy.Asc, o => o.TagThumbnails.Count());
break;
}
case ("place id"):
{
orderedQuery = AddOrder(query, orderedQuery, orderBy.Asc, o => o.Location.PlaceId);
break;
}
case ("address"):
{
orderedQuery = AddOrder(query, orderedQuery, orderBy.Asc,
o => o.Location.LocationComponents.FirstOrDefault(c =>
c.Component.TypesString.Contains(((int)GoogleAddressType.StreetNumber).ToString())).Component
.LongName + o.Location.LocationComponents.FirstOrDefault(c =>
c.Component.TypesString.Contains(((int)GoogleAddressType.StreetAddress).ToString()) ||
c.Component.TypesString.Contains(((int)GoogleAddressType.Route).ToString())).Component.LongName);
break;
}
case ("city"):
{
orderedQuery = AddOrder(query, orderedQuery, orderBy.Asc,
o => o.Location.LocationComponents.FirstOrDefault(c => c.Component.TypesString.Contains(((int)GoogleAddressType.Locality).ToString())).Component.LongName);
break;
}
case ("state"):
{
orderedQuery = AddOrder(query, orderedQuery, orderBy.Asc,
o => o.Location.LocationComponents.FirstOrDefault(c => c.Component.TypesString.Contains(((int)GoogleAddressType.AdministrativeAreaLevel1).ToString())).Component.LongName);
break;
}
case ("new faces"):
{
if (orderBy.Asc)
{
orderedQuery = AddOrder(query, orderedQuery, orderBy.Asc,
o => o.Faces.Where(f => !f.IsValid && !f.NeedsValidation)
.OrderBy(f => f.Created).FirstOrDefault().Created);
}
else
{
orderedQuery = AddOrder(query, orderedQuery, orderBy.Asc,
o => o.Faces.Where(f => !f.IsValid && !f.NeedsValidation)
.OrderByDescending(f => f.Created).FirstOrDefault().Created);
}
break;
}
}
}
if (orderedQuery != null)
{
query = orderedQuery;
}
var photos = query
.Skip(postSearchRequest.PageSize * (postSearchRequest.Page - 1))
.Take(postSearchRequest.PageSize)
.ToList()
.Select(s => s.ToImageDto()).ToList();
var totalResults = query.Count();
if (postSearchRequest.OutOfOrder)
{
var order = query.Take(postSearchRequest.PageSize * postSearchRequest.Page)
.Select(i => i.Id)
.ToList();
return(new PagedResultsWithOrder <List <ImageDto> >(photos, order, totalResults));
}
return(new PagedResults <List <ImageDto> >(photos, totalResults));
}
public async Task ValidateAndThrowAsync(PostSearchRequest entity, CancellationToken cancellationToken)
{
await _validator.ValidateConvertAndThrowAsync(entity, cancellationToken);
}
public void given_a_search_post_request_to_validate()
{
_postFilter = new PostSearchRequest();
}
public IEnumerable <PostSearchDto> SearchPost(PostSearchRequest request)
{
request.Validate <PostSearchRequestValidator, PostSearchRequest>();
return(_postRepository.SearchPost(request.Search));
}
