public void Test_LambdaBuilderWhereClause_CombineCondition_QueryValueWithPropertyWithCallMethod()
{
Database db = new Database(EApp.Data.DbProviderFactory.Default);
WhereClauseBuilder <Post> builder = db.DBProvider.CreateWhereClauseBuilder <Post>();
PostQueryRequest request = new PostQueryRequest();
request.TopicId = 1000;
request.MiscParams.TopicId = 2000;
request.Content = "足球";
request.MiscParams.Content = "篮球";
request.CreationDateTimeParam.CreationDateTime = DateTimeUtils.ToDateTime("2015-1-22").Value;
WhereClauseBuildResult result = builder.BuildWhereClause(p => (p.TopicId <request.TopicId || p.TopicId> request.MiscParams.TopicId) &&
(p.Content.Contains(request.Content) || p.Content.Contains(request.MiscParams.Content)) ||
(p.CreationDateTime < request.CreationDateTimeParam.CreationDateTime ||
p.CreationDateTime.Equals(request.CreationDateTimeParam.CreationDateTime)));
string orderBy = builder.BuildOrderByClause(p => p.CreationDateTime);
Assert.AreEqual(true, !string.IsNullOrEmpty(result.WhereClause));
Assert.AreEqual(1000, result.ParameterValues.Values.ToList()[0]);
Assert.AreEqual(2000, result.ParameterValues.Values.ToList()[1]);
Assert.AreEqual("%足球%", result.ParameterValues.Values.ToList()[2]);
Assert.AreEqual("%篮球%", result.ParameterValues.Values.ToList()[3]);
Assert.AreEqual(request.CreationDateTimeParam.CreationDateTime, result.ParameterValues.Values.ToList()[4]);
Assert.AreEqual(request.CreationDateTimeParam.CreationDateTime, result.ParameterValues.Values.ToList()[5]);
}
public void Test_LambdaBuilderWhereClause_QueryValueWithPropertyWithCallMethod()
{
Database db = new Database(EApp.Data.DbProviderFactory.Default);
WhereClauseBuilder <Post> builder = db.DBProvider.CreateWhereClauseBuilder <Post>();
PostQueryRequest request = new PostQueryRequest();
request.TopicId = 1000;
request.Content = "足球";
request.CreationDateTimeParam.CreationDateTime = DateTimeUtils.ToDateTime("2015-1-22").Value;
List <int> topicIds = new List <int>();
topicIds.Add(1000);
topicIds.Add(2000);
topicIds.Add(3000);
WhereClauseBuildResult result = builder.BuildWhereClause(p => p.TopicId.Equals(request.TopicId) &&
p.Content.Contains(request.Content) &&
p.CreationDateTime < request.CreationDateTimeParam.CreationDateTime);
string orderBy = builder.BuildOrderByClause(p => p.CreationDateTime);
Assert.AreEqual(true, !string.IsNullOrEmpty(result.WhereClause));
Assert.AreEqual(1000, result.ParameterValues.Values.ToList()[0]);
Assert.AreEqual("%足球%", result.ParameterValues.Values.ToList()[1]);
Assert.AreEqual(request.CreationDateTimeParam.CreationDateTime, result.ParameterValues.Values.ToList()[2]);
}
public async Task <ActionResult <QueryResponse <string> > > Query([FromBody] PostQueryRequest query)
{
if (!await Provider.CanRead())
{
return(BadRequest());
}
return(Ok(await Provider.Query(query)));
}
public async Task <QueryResponse <string> > Query(PostQueryRequest query, CancellationToken cancellationToken = default)
{
var qr = Data.Posts.AsQueryable();
if (query.Type != null)
{
qr = qr.Where(x => x.Type == query.Type);
}
if (!string.IsNullOrWhiteSpace(query.AuthorId))
{
qr = qr.Where(x => x.AuthorId == query.AuthorId);
}
if (query.Category != null)
{
qr = qr.Where(x => x.Category.StartsWith(query.Category.ToString()));
}
if (query.Keywords != null)
{
qr = qr.Where(x => x.Keywords.StartsWith(query.Keywords.ToString()));
}
if (!string.IsNullOrWhiteSpace(query.Title))
{
qr = qr.Where(x => x.Title.Contains(query.Title));
}
if (!string.IsNullOrWhiteSpace(query.Content))
{
string jsonContent = JsonSerializer.Serialize(query.Content);
qr = qr.Where(x => x.Content.Contains(jsonContent));
}
qr = query.Order switch
{
PostResponseOrder.None => qr,
PostResponseOrder.CreationTimeAscending => qr.OrderBy(x => x.CreationTime),
PostResponseOrder.CreationTimeDescending => qr.OrderByDescending(x => x.CreationTime),
PostResponseOrder.ModificationTimeAscending => qr.OrderBy(x => x.ModificationTime),
PostResponseOrder.ModificationTimeDescending => qr.OrderByDescending(x => x.ModificationTime),
_ => throw new NotImplementedException(),
};
Pagination pagination = new Pagination
{
TotalCount = await qr.CountAsync(cancellationToken).ConfigureAwait(false),
};
if (query.Pagination != null)
{
qr = qr.Skip(query.Pagination.Offset).Take(query.Pagination.PageSize);
pagination.CurrentPage = query.Pagination.CurrentPage;
pagination.PageSize = query.Pagination.PageSize;
}
else
{
pagination.CurrentPage = 0;
pagination.PageSize = pagination.TotalCount;
}
return(new QueryResponse <string>(await qr.Select(x => x.Id).ToArrayAsync(cancellationToken).ConfigureAwait(false), pagination));
}
public void Test_PostRepository_FindAllOrderByWithoutPaging()
{
PostQueryRequest request = new PostQueryRequest();
request.TopicId = 1000;
request.CreationDateTimeParam.CreationDateTimeOperator = Operator.LessThanEqual;
request.CreationDateTimeParam.CreationDateTime = DateTimeUtils.ToDateTime("2015-1-22").Value;
using (IRepositoryContext repositoryContext = ServiceLocator.Instance.GetService <IRepositoryContext>())
{
IRepository <Post> postRepository = repositoryContext.GetRepository <Post>();
Expression <Func <Post, bool> > dateTimeExpression = (p) => true;
//DateTime dt = request.CreationDateTimeParam.CreationDateTime;
switch (request.CreationDateTimeParam.CreationDateTimeOperator)
{
case Operator.LessThanEqual:
dateTimeExpression = p => p.CreationDateTime <= request.CreationDateTimeParam.CreationDateTime;
break;
case Operator.GreaterThanEqual:
dateTimeExpression = p => p.CreationDateTime >= request.CreationDateTimeParam.CreationDateTime;
break;
case Operator.Equal:
dateTimeExpression = p => p.CreationDateTime.Equals(request.CreationDateTimeParam.CreationDateTime);
break;
}
QueryBuilder <Post> postQueryBuilder = new QueryBuilder <Post>();
//int topicId = request.TopicId;
postQueryBuilder.And(p => p.TopicId == request.TopicId).And(dateTimeExpression);
IEnumerable <Post> posts = postRepository.FindAll(postQueryBuilder.QueryPredicate);
IList <PostDataObject> postDataObjects = new List <PostDataObject>();
foreach (Post post in posts)
{
var postDataObject = new PostDataObject();
postDataObject.MapFrom(post);
postDataObjects.Add(postDataObject);
}
Assert.AreEqual(5, postDataObjects.Count);
}
}
public object Get(PostQueryRequest req)
{
GhostPosts posts = null;
posts = GhostPostRequest(req);
return(new QueryResponse <Post>()
{
Results = posts.Posts,
Offset = req.Skip.Value * req.Take.Value,
Total = posts.Meta.Pagination.Total
});
}
public IAsyncEnumerable <string> Search(IPostRepository repository, PostQueryRequest query, CancellationToken cancellationToken = default)
{
var qr = repository.GetAllItems(cancellationToken).IgnoreNull();
if (query.Type is not null)
{
qr = qr.Where(x => x.Type == query.Type);
}
if (!string.IsNullOrWhiteSpace(query.Author))
{
qr = qr.Where(x => x.Author == query.Author);
}
if (query.Category is not null)
{
qr = qr.Where(x => x.Category.ToString().StartsWith(query.Category.ToString()));
}
if (query.Keywords is not null)
{
qr = qr.Where(x => query.Keywords.Items.All(k => x.Keywords.Items.Contains(k)));
}
if (!string.IsNullOrWhiteSpace(query.Title))
{
qr = qr.Where(x => x.Title.Contains(query.Title));
}
if (!string.IsNullOrWhiteSpace(query.Content))
{
qr = qr.Where(x => x.Content.Raw.Contains(query.Content));
}
if (!string.IsNullOrWhiteSpace(query.Term))
{
qr = qr.Where(x =>
x.Author.Contains(query.Term) ||
x.Category.ToString().Contains(query.Term) ||
x.Keywords.ToString().Contains(query.Term) ||
x.Title.ToString().Contains(query.Term) ||
x.Content.Raw.ToString().Contains(query.Term)
);
}
qr = query.Order switch
{
QueryTimeOrder.None => qr,
QueryTimeOrder.CreationTimeAscending => qr.OrderBy(x => x.CreationTime),
QueryTimeOrder.CreationTimeDescending => qr.OrderByDescending(x => x.CreationTime),
QueryTimeOrder.ModificationTimeAscending => qr.OrderBy(x => x.ModificationTime),
QueryTimeOrder.ModificationTimeDescending => qr.OrderByDescending(x => x.ModificationTime),
_ => throw new NotImplementedException(),
};
return(qr.Select(item => item.Id).IgnoreNull().Paging(query.Pagination));
}
private GhostPosts GhostPostRequest(PostQueryRequest req)
{
req.Skip = req.Skip ?? 0;
req.Take = req.Take ?? 15;
var page = Math.Ceiling((double)(req.Skip.Value / req.Take.Value)) + 1; // 10 / 5 = 2, 10 / 6 = 2
var url = $"{AppSettings.Get<string>("GhostApi:BaseUrl")}/posts/?key={AppSettings.Get<string>("GhostApi:ContentKey")}&include=authors,tags";
url = url.AddQueryParam("page", page).AddQueryParam("limit", req.Take);
url = !String.IsNullOrEmpty(req.Filter) ? url.AddQueryParam("filter", req.Filter) : url;
url = !String.IsNullOrEmpty(req.OrderBy) && req.OrderBy.StartsWith("-") ? url.AddQueryParam("order", $"{req.OrderByDesc} desc") : url;
var json = url.GetJsonFromUrl();
using (GhostJsConfig.With())
{
return(json.FromJson <GhostPosts>());
}
}
public virtual async Task <QueryResponse <string> > Query(PostQueryRequest query, CancellationToken cancellationToken = default)
{
query.Pagination ??= new Pagination();
PagingPath?paging = null;
if (query.Type != null)
{
switch (query.Type)
{
case PostType.Article:
paging = new PagingPath(Path.Join(RootPath, "articles"));
break;
case PostType.Slides:
paging = new PagingPath(Path.Join(RootPath, "slides"));
break;
case PostType.Note:
paging = new PagingPath(Path.Join(RootPath, "notes"));
break;
}
}
else if (!string.IsNullOrWhiteSpace(query.CategoryId))
{
var catRoot = Path.Join(RootPath, "categories");
paging = new PagingPath(Path.Join(catRoot, query.CategoryId));
}
else if (!string.IsNullOrWhiteSpace(query.KeywordId))
{
var catRoot = Path.Join(RootPath, "keywords");
paging = new PagingPath(Path.Join(catRoot, query.KeywordId));
}
paging ??= new PagingPath(Path.Join(RootPath, "pages"));
await EnsurePagingConfig(paging);
paging.FillPagination(query.Pagination);
var res = new QueryResponse <string>(await GetPagingResult(paging, query.Pagination, cancellationToken), query.Pagination);
return(res);
}
public IEnumerable <DataObjects.PostDataObject> GetPostsByQueryRequest(PostQueryRequest request)
{
using (IRepositoryContext repositoryContext = ServiceLocator.Instance.GetService <IRepositoryContext>())
{
IRepository <Post> postRepository = repositoryContext.GetRepository <Post>();
Expression <Func <Post, bool> > dateTimeExpression = (p) => true;
switch (request.CreationDateTimeParam.CreationDateTimeOperator)
{
case Operator.LessThanEqual:
dateTimeExpression = p => p.CreationDateTime <= request.CreationDateTimeParam.CreationDateTime;
break;
case Operator.GreaterThanEqual:
dateTimeExpression = p => p.CreationDateTime >= request.CreationDateTimeParam.CreationDateTime;
break;
case Operator.Equal:
default:
dateTimeExpression = p => p.CreationDateTime.Equals(request.CreationDateTimeParam.CreationDateTime);
break;
}
QueryBuilder <Post> postQueryBuilder = new QueryBuilder <Post>();
postQueryBuilder.And(p => p.TopicId == request.TopicId).And(dateTimeExpression);
IEnumerable <Post> posts = postRepository.FindAll(postQueryBuilder.QueryPredicate);
IList <PostDataObject> postDataObjects = new List <PostDataObject>();
foreach (Post post in posts)
{
var postDataObject = new PostDataObject();
postDataObject.MapFrom(post);
postDataObjects.Add(postDataObject);
}
return(postDataObjects);
}
}
public override async Task <IEnumerable <string> > All(CancellationToken cancellationToken = default)
{
List <string> result = new List <string>();
PostQueryRequest pq = new PostQueryRequest();
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
var req = await Query(pq, cancellationToken);
result.AddRange(req.Results);
if (!req.CurrentPage.HasNextPage)
{
break;
}
pq.Pagination = req.CurrentPage.NextPage();
}
return(result);
}
