0ct0pu5/fess
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

#285

Browse source
This commit is contained in:
Shinsuke Sugaya 2015-07-05 13:04:54 +09:00
parent c7e9305bf5
commit 041fe342fa
7 changed files with 538 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
dbflute_fess/freegen/ControlFreeGen.vm
View file

@ -90,6 +90,18 @@ $manager.makeDirectory($request.generateDirPath)
$generator.parse("./elasticsearch/ExConditionQuery.vm", $path, "", "")
#end
#set ($path = "${request.generateDirPath}/cbean/cf/bs/Bs${table.camelizedName}CF.java")
$manager.makeDirectory($path)
$request.info("parse('${path}')")
$generator.parse("./elasticsearch/BsConditionFilter.vm", $path, "", "")
#set ($path = "${request.generateDirPath}/cbean/cf/${table.camelizedName}CF.java")
$manager.makeDirectory($path)
$request.info("parse('${path}')")
#if (!$files.file(${generator.outputPath},$path).exists())
$generator.parse("./elasticsearch/ExConditionFilter.vm", $path, "", "")
#end
#set ($path = "${request.generateDirPath}/bsbhv/Bs${table.camelizedName}Bhv.java")
$manager.makeDirectory($path)
$request.info("parse('${path}')")
@ -113,6 +125,11 @@ $manager.makeDirectory($request.generateDirPath)
$request.info("parse('${path}')")
$generator.parse("./elasticsearch/AbstractConditionQuery.vm", $path, "", "")
#set ($path = "${request.generateDirPath}/cbean/cf/bs/AbstractConditionFilter.java")
$manager.makeDirectory($path)
$request.info("parse('${path}')")
$generator.parse("./elasticsearch/AbstractConditionFilter.vm", $path, "", "")
#set ($path = "${request.generateDirPath}/bsentity/AbstractEntity.java")
$manager.makeDirectory($path)
$request.info("parse('${path}')")

9
dbflute_fess/freegen/elasticsearch/AbstractConditionBean.vm
View file

@ -592,6 +592,8 @@ public abstract class AbstractConditionBean implements ConditionBean {
private Boolean version;
private int terminateAfter = 0;
public void build(SearchRequestBuilder builder) {
if (explain != null) {
builder.setExplain(explain);
@ -614,6 +616,9 @@ public abstract class AbstractConditionBean implements ConditionBean {
if (version != null) {
builder.setVersion(version);
}
if (terminateAfter > 0) {
builder.setTerminateAfter(terminateAfter);
}
}
public void setExplain(boolean explain) {
@ -644,6 +649,10 @@ public abstract class AbstractConditionBean implements ConditionBean {
this.version = version;
}
public void setTerminateAfter(int terminateAfter) {
this.terminateAfter = terminateAfter;
}
}
}

216
dbflute_fess/freegen/elasticsearch/AbstractConditionFilter.vm Normal file
View file

@ -0,0 +1,216 @@
package ${request.package}.cbean.cf.bs;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.dbflute.cbean.ckey.ConditionKey;
import org.elasticsearch.index.query.AndFilterBuilder;
import org.elasticsearch.index.query.BoolFilterBuilder;
import org.elasticsearch.index.query.ExistsFilterBuilder;
import org.elasticsearch.index.query.FilterBuilder;
import org.elasticsearch.index.query.FilterBuilders;
import org.elasticsearch.index.query.IdsFilterBuilder;
import org.elasticsearch.index.query.MatchAllFilterBuilder;
import org.elasticsearch.index.query.MissingFilterBuilder;
import org.elasticsearch.index.query.NotFilterBuilder;
import org.elasticsearch.index.query.OrFilterBuilder;
import org.elasticsearch.index.query.PrefixFilterBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryFilterBuilder;
import org.elasticsearch.index.query.RangeFilterBuilder;
import org.elasticsearch.index.query.ScriptFilterBuilder;
import org.elasticsearch.index.query.TermFilterBuilder;
import org.elasticsearch.index.query.TermsFilterBuilder;
public class AbstractConditionFilter {
protected List<FilterBuilder> filterBuilderList;
public boolean hasFilters() {
return filterBuilderList != null && !filterBuilderList.isEmpty();
}
public FilterBuilder getFilter() {
if (filterBuilderList == null) {
return null;
} else if (filterBuilderList.size() == 1) {
return filterBuilderList.get(0);
}
return FilterBuilders.andFilter(filterBuilderList.toArray(new FilterBuilder[filterBuilderList.size()]));
}
public void addFilter(FilterBuilder filterBuilder) {
regF(filterBuilder);
}
public void setIds_Equal(Collection<String> idList) {
setIds_Equal(idList, null);
}
public void setIds_Equal(Collection<String> idList, ConditionOptionCall<IdsFilterBuilder> opLambda) {
IdsFilterBuilder builder = regIdsF(idList);
if (opLambda != null) {
opLambda.callback(builder);
}
}
public void matchAll() {
matchAll(null);
}
public void matchAll(ConditionOptionCall<MatchAllFilterBuilder> opLambda) {
MatchAllFilterBuilder builder = FilterBuilders.matchAllFilter();
regF(builder);
if (opLambda != null) {
opLambda.callback(builder);
}
}
public void setScript(String script) {
setScript(script, null);
}
public void setScript(String script, ConditionOptionCall<ScriptFilterBuilder> opLambda) {
ScriptFilterBuilder builder = regScriptF(script);
if (opLambda != null) {
opLambda.callback(builder);
}
}
protected void regF(FilterBuilder builder) {
if (filterBuilderList == null) {
filterBuilderList = new ArrayList<>();
}
filterBuilderList.add(builder);
}
protected TermFilterBuilder regTermF(String name, Object value) {
TermFilterBuilder termFilter = FilterBuilders.termFilter(name, value);
regF(termFilter);
return termFilter;
}
protected TermsFilterBuilder regTermsF(String name, Collection<?> value) {
TermsFilterBuilder termsFilter = FilterBuilders.termsFilter(name, value);
regF(termsFilter);
return termsFilter;
}
protected PrefixFilterBuilder regPrefixF(String name, String value) {
PrefixFilterBuilder prefixFilter = FilterBuilders.prefixFilter(name, value);
regF(prefixFilter);
return prefixFilter;
}
protected ExistsFilterBuilder regExistsF(String name) {
ExistsFilterBuilder existsFilter = FilterBuilders.existsFilter(name);
regF(existsFilter);
return existsFilter;
}
protected MissingFilterBuilder regMissingF(String name) {
MissingFilterBuilder missingFilter = FilterBuilders.missingFilter(name);
regF(missingFilter);
return missingFilter;
}
protected RangeFilterBuilder regRangeF(String name, ConditionKey ck, Object value) {
for (FilterBuilder builder : filterBuilderList) {
if (builder instanceof RangeFilterBuilder) {
RangeFilterBuilder rangeFilterBuilder = (RangeFilterBuilder) builder;
if (rangeFilterBuilder.toString().replaceAll("\\s", "").startsWith("{\"range\":{\"" + name + "\"")) {
addRangeC(rangeFilterBuilder, ck, value);
return rangeFilterBuilder;
}
}
}
RangeFilterBuilder rangeFilterBuilder = FilterBuilders.rangeFilter(name);
addRangeC(rangeFilterBuilder, ck, value);
regF(rangeFilterBuilder);
return rangeFilterBuilder;
}
protected void addRangeC(RangeFilterBuilder builder, ConditionKey ck, Object value) {
if (ck.equals(ConditionKey.CK_GREATER_THAN)) {
builder.gt(value);
} else if (ck.equals(ConditionKey.CK_GREATER_EQUAL)) {
builder.gte(value);
} else if (ck.equals(ConditionKey.CK_LESS_THAN)) {
builder.lt(value);
} else if (ck.equals(ConditionKey.CK_LESS_EQUAL)) {
builder.lte(value);
}
}
protected ScriptFilterBuilder regScriptF(String script) {
ScriptFilterBuilder scriptFilter = FilterBuilders.scriptFilter(script);
regF(scriptFilter);
return scriptFilter;
}
protected IdsFilterBuilder regIdsF(Collection<?> value) {
IdsFilterBuilder idsFilter = FilterBuilders.idsFilter(value.toArray(new String[value.size()]));
regF(idsFilter);
return idsFilter;
}
protected BoolFilterBuilder regBoolF(List<FilterBuilder> mustList, List<FilterBuilder> shouldList, List<FilterBuilder> mustNotList) {
BoolFilterBuilder boolFilter = FilterBuilders.boolFilter();
mustList.forEach(query -> {
boolFilter.must(query);
});
shouldList.forEach(query -> {
boolFilter.should(query);
});
mustNotList.forEach(query -> {
boolFilter.mustNot(query);
});
return boolFilter;
}
protected AndFilterBuilder regAndF(List<FilterBuilder> filterList) {
AndFilterBuilder andFilter = FilterBuilders.andFilter(filterList.toArray(new FilterBuilder[filterList.size()]));
regF(andFilter);
return andFilter;
}
protected OrFilterBuilder regOrF(List<FilterBuilder> filterList) {
OrFilterBuilder andFilter = FilterBuilders.orFilter(filterList.toArray(new FilterBuilder[filterList.size()]));
regF(andFilter);
return andFilter;
}
protected NotFilterBuilder regNotF(FilterBuilder filter) {
NotFilterBuilder notFilter = FilterBuilders.notFilter(filter);
regF(notFilter);
return notFilter;
}
protected QueryFilterBuilder regQueryF(QueryBuilder filter) {
QueryFilterBuilder queryFilter = FilterBuilders.queryFilter(filter);
regF(queryFilter);
return queryFilter;
}
@FunctionalInterface
public interface ConditionOptionCall<OP extends FilterBuilder> {
/**
* @param op The option of condition to be set up. (NotNull)
*/
void callback(OP op);
}
@FunctionalInterface
public interface BoolCall<CF extends AbstractConditionFilter> {
void callback(CF must, CF should, CF mustNot);
}
@FunctionalInterface
public interface OperatorCall<CF extends AbstractConditionFilter> {
void callback(CF and);
}
}

51
dbflute_fess/freegen/elasticsearch/AbstractConditionQuery.vm
View file

@ -5,6 +5,7 @@ import java.util.Collection;
import java.util.Collections;
import java.util.List;
import ${request.package}.cbean.cf.bs.AbstractConditionFilter;
import org.dbflute.cbean.ConditionBean;
import org.dbflute.cbean.ConditionQuery;
import org.dbflute.cbean.ckey.ConditionKey;
@ -20,6 +21,7 @@ import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.FilterBuilder;
import org.elasticsearch.index.query.FilteredQueryBuilder;
import org.elasticsearch.index.query.FuzzyQueryBuilder;
import org.elasticsearch.index.query.MatchAllQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.PrefixQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
@ -56,6 +58,10 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
return fieldSortBuilderList == null ? Collections.emptyList() : fieldSortBuilderList;
}
public boolean hasQueries() {
return queryBuilderList != null && !queryBuilderList.isEmpty();
}
public QueryBuilder getQuery() {
if (queryBuilderList == null) {
return null;
@ -70,7 +76,7 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
}
public void addQuery(QueryBuilder queryBuilder) {
queryBuilderList.add(queryBuilder);
regQ(queryBuilder);
}
public void queryString(String queryString) {
@ -85,11 +91,23 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
}
}
protected FilteredQueryBuilder reqFilteredQ(QueryBuilder queryBuilder, FilterBuilder filterBuilder) {
public void matchAll() {
matchAll(null);
}
public void matchAll(ConditionOptionCall<MatchAllQueryBuilder> opLambda) {
MatchAllQueryBuilder builder = QueryBuilders.matchAllQuery();
regQ(builder);
if (opLambda != null) {
opLambda.callback(builder);
}
}
protected FilteredQueryBuilder regFilteredQ(QueryBuilder queryBuilder, FilterBuilder filterBuilder) {
return QueryBuilders.filteredQuery(queryBuilder, filterBuilder);
}
protected BoolQueryBuilder reqBoolCQ(List<QueryBuilder> mustList, List<QueryBuilder> shouldList, List<QueryBuilder> mustNotList) {
protected BoolQueryBuilder regBoolCQ(List<QueryBuilder> mustList, List<QueryBuilder> shouldList, List<QueryBuilder> mustNotList) {
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
mustList.forEach(query -> {
boolQuery.must(query);
@ -103,49 +121,49 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
return boolQuery;
}
protected TermQueryBuilder reqTermQ(String name, Object value) {
protected TermQueryBuilder regTermQ(String name, Object value) {
TermQueryBuilder termQuery = QueryBuilders.termQuery(name, value);
regQ(termQuery);
return termQuery;
}
protected TermsQueryBuilder reqTermsQ(String name, Collection<?> value) {
protected TermsQueryBuilder regTermsQ(String name, Collection<?> value) {
TermsQueryBuilder termsQuery = QueryBuilders.termsQuery(name, value);
regQ(termsQuery);
return termsQuery;
}
protected MatchQueryBuilder reqMatchQ(String name, Object value) {
protected MatchQueryBuilder regMatchQ(String name, Object value) {
MatchQueryBuilder matchQuery = QueryBuilders.matchQuery(name, value);
regQ(matchQuery);
return matchQuery;
}
protected MatchQueryBuilder reqMatchPhraseQ(String name, Object value) {
protected MatchQueryBuilder regMatchPhraseQ(String name, Object value) {
MatchQueryBuilder matchQuery = QueryBuilders.matchPhraseQuery(name, value);
regQ(matchQuery);
return matchQuery;
}
protected MatchQueryBuilder reqMatchPhrasePrefixQ(String name, Object value) {
protected MatchQueryBuilder regMatchPhrasePrefixQ(String name, Object value) {
MatchQueryBuilder matchQuery = QueryBuilders.matchPhrasePrefixQuery(name, value);
regQ(matchQuery);
return matchQuery;
}
protected FuzzyQueryBuilder reqFuzzyQ(String name, Object value) {
protected FuzzyQueryBuilder regFuzzyQ(String name, Object value) {
FuzzyQueryBuilder fuzzyQuery = QueryBuilders.fuzzyQuery(name, value);
regQ(fuzzyQuery);
return fuzzyQuery;
}
protected PrefixQueryBuilder reqPrefixQ(String name, String prefix) {
protected PrefixQueryBuilder regPrefixQ(String name, String prefix) {
PrefixQueryBuilder prefixQuery = QueryBuilders.prefixQuery(name, prefix);
regQ(prefixQuery);
return prefixQuery;
}
protected RangeQueryBuilder reqRangeQ(String name, ConditionKey ck, Object value) {
protected RangeQueryBuilder regRangeQ(String name, ConditionKey ck, Object value) {
for (QueryBuilder builder : queryBuilderList) {
if (builder instanceof RangeQueryBuilder) {
RangeQueryBuilder rangeQueryBuilder = (RangeQueryBuilder) builder;
@ -353,10 +371,15 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
}
@FunctionalInterface
public interface FilteredCall<CQ extends AbstractConditionQuery> {
public interface FilteredCall<CQ extends AbstractConditionQuery, CF extends AbstractConditionFilter> {
void callback(CQ query);
void callback(CQ query, CF filter);
}
@FunctionalInterface
public interface OperatorCall<CQ extends AbstractConditionQuery> {
void callback(CQ and);
}
}

225
dbflute_fess/freegen/elasticsearch/BsConditionFilter.vm Normal file
View file

@ -0,0 +1,225 @@
package ${request.package}.cbean.cf.bs;
import java.util.Collection;
import ${request.package}.cbean.cf.${table.camelizedName}CF;
import ${request.package}.cbean.cq.${table.camelizedName}CQ;
import org.dbflute.exception.IllegalConditionBeanOperationException;
import org.dbflute.cbean.ckey.ConditionKey;
import org.elasticsearch.index.query.AndFilterBuilder;
import org.elasticsearch.index.query.BoolFilterBuilder;
import org.elasticsearch.index.query.ExistsFilterBuilder;
import org.elasticsearch.index.query.MissingFilterBuilder;
import org.elasticsearch.index.query.NotFilterBuilder;
import org.elasticsearch.index.query.OrFilterBuilder;
import org.elasticsearch.index.query.PrefixFilterBuilder;
import org.elasticsearch.index.query.QueryFilterBuilder;
import org.elasticsearch.index.query.RangeFilterBuilder;
import org.elasticsearch.index.query.TermFilterBuilder;
import org.elasticsearch.index.query.TermsFilterBuilder;
/**
* @author FreeGen
*/
public abstract class Bs${table.camelizedName}CF extends AbstractConditionFilter {
public void bool(BoolCall<${table.camelizedName}CF> boolLambda) {
bool(boolLambda, null);
}
public void bool(BoolCall<${table.camelizedName}CF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
${table.camelizedName}CF mustFilter = new ${table.camelizedName}CF();
${table.camelizedName}CF shouldFilter = new ${table.camelizedName}CF();
${table.camelizedName}CF mustNotFilter = new ${table.camelizedName}CF();
boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
BoolFilterBuilder builder =
regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
if (opLambda != null) {
opLambda.callback(builder);
}
}
}
public void and(OperatorCall<${table.camelizedName}CF> andLambda) {
and(andLambda, null);
}
public void and(OperatorCall<${table.camelizedName}CF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
${table.camelizedName}CF andFilter = new ${table.camelizedName}CF();
andLambda.callback(andFilter);
if (andFilter.hasFilters()) {
AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
if (opLambda != null) {
opLambda.callback(builder);
}
}
}
public void or(OperatorCall<${table.camelizedName}CF> orLambda) {
or(orLambda, null);
}
public void or(OperatorCall<${table.camelizedName}CF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
${table.camelizedName}CF orFilter = new ${table.camelizedName}CF();
orLambda.callback(orFilter);
if (orFilter.hasFilters()) {
OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
if (opLambda != null) {
opLambda.callback(builder);
}
}
}
public void not(OperatorCall<${table.camelizedName}CF> notLambda) {
not(notLambda, null);
}
public void not(OperatorCall<${table.camelizedName}CF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
${table.camelizedName}CF notFilter = new ${table.camelizedName}CF();
notLambda.callback(notFilter);
if (notFilter.hasFilters()) {
if (notFilter.filterBuilderList.size() > 1) {
final String msg = "not filter must be one filter.";
throw new IllegalConditionBeanOperationException(msg);
}
NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
if (opLambda != null) {
opLambda.callback(builder);
}
}
}
public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<${table.camelizedName}CQ> queryLambda) {
query(queryLambda, null);
}
public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<${table.camelizedName}CQ> queryLambda,
ConditionOptionCall<QueryFilterBuilder> opLambda) {
${table.camelizedName}CQ query = new ${table.camelizedName}CQ();
queryLambda.callback(query);
if (query.hasQueries()) {
QueryFilterBuilder builder = regQueryF(query.getQuery());
if (opLambda != null) {
opLambda.callback(builder);
}
}
}
#foreach ($column in $table.columnList)
#if ($column.isNormalColumn)
#set ($javaNative = ${column.type})
public void set${column.capCamelName}_Term($javaNative ${column.uncapCamelName}) {
set${column.capCamelName}_Term(${column.uncapCamelName}, null);
}
public void set${column.capCamelName}_Term($javaNative ${column.uncapCamelName}, ConditionOptionCall<TermFilterBuilder> opLambda) {
TermFilterBuilder builder = regTermF("${column.name}", ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
}
public void set${column.capCamelName}_Terms(Collection<$javaNative> ${column.uncapCamelName}List) {
set${column.capCamelName}_Terms(${column.uncapCamelName}List, null);
}
public void set${column.capCamelName}_Terms(Collection<$javaNative> ${column.uncapCamelName}List, ConditionOptionCall<TermsFilterBuilder> opLambda) {
TermsFilterBuilder builder = regTermsF("${column.name}", ${column.uncapCamelName}List);
if (opLambda != null) {
opLambda.callback(builder);
}
}
public void set${column.capCamelName}_InScope(Collection<$javaNative> ${column.uncapCamelName}List) {
set${column.capCamelName}_Terms(${column.uncapCamelName}List, null);
}
public void set${column.capCamelName}_InScope(Collection<$javaNative> ${column.uncapCamelName}List, ConditionOptionCall<TermsFilterBuilder> opLambda) {
set${column.capCamelName}_Terms(${column.uncapCamelName}List, opLambda);
}
#if ($javaNative == "String")
public void set${column.capCamelName}_Prefix($javaNative ${column.uncapCamelName}) {
set${column.capCamelName}_Prefix(${column.uncapCamelName}, null);
}
public void set${column.capCamelName}_Prefix($javaNative ${column.uncapCamelName}, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
PrefixFilterBuilder builder = regPrefixF("${column.name}", ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
}
#end
public void set${column.capCamelName}_Exists() {
set${column.capCamelName}_Exists(null);
}
public void set${column.capCamelName}_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
ExistsFilterBuilder builder = regExistsF("${column.name}");
if (opLambda != null) {
opLambda.callback(builder);
}
}
public void set${column.capCamelName}_Missing() {
set${column.capCamelName}_Missing(null);
}
public void set${column.capCamelName}_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
MissingFilterBuilder builder = regMissingF("${column.name}");
if (opLambda != null) {
opLambda.callback(builder);
}
}
public void set${column.capCamelName}_GreaterThan($javaNative ${column.uncapCamelName}) {
set${column.capCamelName}_GreaterThan(${column.uncapCamelName}, null);
}
public void set${column.capCamelName}_GreaterThan($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeFilterBuilder> opLambda) {
RangeFilterBuilder builder = regRangeF("${column.name}", ConditionKey.CK_GREATER_THAN, ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
}
public void set${column.capCamelName}_LessThan($javaNative ${column.uncapCamelName}) {
set${column.capCamelName}_LessThan(${column.uncapCamelName}, null);
}
public void set${column.capCamelName}_LessThan($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeFilterBuilder> opLambda) {
RangeFilterBuilder builder = regRangeF("${column.name}", ConditionKey.CK_LESS_THAN, ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
}
public void set${column.capCamelName}_GreaterEqual($javaNative ${column.uncapCamelName}) {
set${column.capCamelName}_GreaterEqual(${column.uncapCamelName}, null);
}
public void set${column.capCamelName}_GreaterEqual($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeFilterBuilder> opLambda) {
RangeFilterBuilder builder = regRangeF("${column.name}", ConditionKey.CK_GREATER_EQUAL, ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
}
public void set${column.capCamelName}_LessEqual($javaNative ${column.uncapCamelName}) {
set${column.capCamelName}_LessEqual(${column.uncapCamelName}, null);
}
public void set${column.capCamelName}_LessEqual($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeFilterBuilder> opLambda) {
RangeFilterBuilder builder = regRangeF("${column.name}", ConditionKey.CK_LESS_EQUAL, ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
}
#end
#end
}

48
dbflute_fess/freegen/elasticsearch/BsConditionQuery.vm
View file

@ -3,6 +3,7 @@ package ${request.package}.cbean.cq.bs;
import java.util.Collection;
import ${request.package}.cbean.cq.${table.camelizedName}CQ;
import ${request.package}.cbean.cf.${table.camelizedName}CF;
import org.dbflute.cbean.ckey.ConditionKey;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.FilteredQueryBuilder;
@ -28,16 +29,17 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
return "${table.name}";
}
public void filtered(FilteredCall<${table.camelizedName}CQ> filteredLambda) {
public void filtered(FilteredCall<${table.camelizedName}CQ, ${table.camelizedName}CF> filteredLambda) {
filtered(filteredLambda, null);
}
public void filtered(FilteredCall<${table.camelizedName}CQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
public void filtered(FilteredCall<${table.camelizedName}CQ, ${table.camelizedName}CF> filteredLambda,
ConditionOptionCall<FilteredQueryBuilder> opLambda) {
${table.camelizedName}CQ query = new ${table.camelizedName}CQ();
filteredLambda.callback(query);
if (!query.queryBuilderList.isEmpty()) {
// TODO filter
FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
${table.camelizedName}CF filter = new ${table.camelizedName}CF();
filteredLambda.callback(query, filter);
if (query.hasQueries()) {
FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
if (opLambda != null) {
opLambda.callback(builder);
}
@ -53,8 +55,8 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
${table.camelizedName}CQ shouldQuery = new ${table.camelizedName}CQ();
${table.camelizedName}CQ mustNotQuery = new ${table.camelizedName}CQ();
boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
if (opLambda != null) {
opLambda.callback(builder);
}
@ -69,29 +71,29 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
}
public void set${column.capCamelName}_Term($javaNative ${column.uncapCamelName}, ConditionOptionCall<TermQueryBuilder> opLambda) {
TermQueryBuilder builder = reqTermQ("${column.name}", ${column.uncapCamelName});
TermQueryBuilder builder = regTermQ("${column.name}", ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
}
public void set${column.capCamelName}_Terms(Collection<$javaNative> ${column.uncapCamelName}List) {
set${column.capCamelName}_MatchPhrasePrefix(${column.uncapCamelName}List, null);
set${column.capCamelName}_Terms(${column.uncapCamelName}List, null);
}
public void set${column.capCamelName}_MatchPhrasePrefix(Collection<$javaNative> ${column.uncapCamelName}List, ConditionOptionCall<TermsQueryBuilder> opLambda) {
TermsQueryBuilder builder = reqTermsQ("${column.name}", ${column.uncapCamelName}List);
public void set${column.capCamelName}_Terms(Collection<$javaNative> ${column.uncapCamelName}List, ConditionOptionCall<TermsQueryBuilder> opLambda) {
TermsQueryBuilder builder = regTermsQ("${column.name}", ${column.uncapCamelName}List);
if (opLambda != null) {
opLambda.callback(builder);
}
}
public void set${column.capCamelName}_InScope(Collection<$javaNative> ${column.uncapCamelName}List) {
set${column.capCamelName}_MatchPhrasePrefix(${column.uncapCamelName}List, null);
set${column.capCamelName}_Terms(${column.uncapCamelName}List, null);
}
public void set${column.capCamelName}_InScope(Collection<$javaNative> ${column.uncapCamelName}List, ConditionOptionCall<TermsQueryBuilder> opLambda) {
set${column.capCamelName}_MatchPhrasePrefix(${column.uncapCamelName}List, opLambda);
set${column.capCamelName}_Terms(${column.uncapCamelName}List, opLambda);
}
public void set${column.capCamelName}_Match($javaNative ${column.uncapCamelName}) {
@ -99,7 +101,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
}
public void set${column.capCamelName}_Match($javaNative ${column.uncapCamelName}, ConditionOptionCall<MatchQueryBuilder> opLambda) {
MatchQueryBuilder builder = reqMatchQ("${column.name}", ${column.uncapCamelName});
MatchQueryBuilder builder = regMatchQ("${column.name}", ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
@ -110,7 +112,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
}
public void set${column.capCamelName}_MatchPhrase($javaNative ${column.uncapCamelName}, ConditionOptionCall<MatchQueryBuilder> opLambda) {
MatchQueryBuilder builder = reqMatchPhraseQ("${column.name}", ${column.uncapCamelName});
MatchQueryBuilder builder = regMatchPhraseQ("${column.name}", ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
@ -121,7 +123,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
}
public void set${column.capCamelName}_MatchPhrasePrefix($javaNative ${column.uncapCamelName}, ConditionOptionCall<MatchQueryBuilder> opLambda) {
MatchQueryBuilder builder = reqMatchPhrasePrefixQ("${column.name}", ${column.uncapCamelName});
MatchQueryBuilder builder = regMatchPhrasePrefixQ("${column.name}", ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
@ -132,7 +134,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
}
public void set${column.capCamelName}_Fuzzy($javaNative ${column.uncapCamelName}, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
FuzzyQueryBuilder builder = reqFuzzyQ("${column.name}", ${column.uncapCamelName});
FuzzyQueryBuilder builder = regFuzzyQ("${column.name}", ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
@ -144,7 +146,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
}
public void set${column.capCamelName}_Prefix($javaNative ${column.uncapCamelName}, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
PrefixQueryBuilder builder = reqPrefixQ("${column.name}", ${column.uncapCamelName});
PrefixQueryBuilder builder = regPrefixQ("${column.name}", ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
@ -156,7 +158,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
}
public void set${column.capCamelName}_GreaterThan($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeQueryBuilder> opLambda) {
RangeQueryBuilder builder = reqRangeQ("${column.name}", ConditionKey.CK_GREATER_THAN, ${column.uncapCamelName});
RangeQueryBuilder builder = regRangeQ("${column.name}", ConditionKey.CK_GREATER_THAN, ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
@ -167,7 +169,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
}
public void set${column.capCamelName}_LessThan($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeQueryBuilder> opLambda) {
RangeQueryBuilder builder = reqRangeQ("${column.name}", ConditionKey.CK_LESS_THAN, ${column.uncapCamelName});
RangeQueryBuilder builder = regRangeQ("${column.name}", ConditionKey.CK_LESS_THAN, ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
@ -178,7 +180,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
}
public void set${column.capCamelName}_GreaterEqual($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeQueryBuilder> opLambda) {
RangeQueryBuilder builder = reqRangeQ("${column.name}", ConditionKey.CK_GREATER_EQUAL, ${column.uncapCamelName});
RangeQueryBuilder builder = regRangeQ("${column.name}", ConditionKey.CK_GREATER_EQUAL, ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}
@ -189,7 +191,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
}
public void set${column.capCamelName}_LessEqual($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeQueryBuilder> opLambda) {
RangeQueryBuilder builder = reqRangeQ("${column.name}", ConditionKey.CK_LESS_EQUAL, ${column.uncapCamelName});
RangeQueryBuilder builder = regRangeQ("${column.name}", ConditionKey.CK_LESS_EQUAL, ${column.uncapCamelName});
if (opLambda != null) {
opLambda.callback(builder);
}

9
dbflute_fess/freegen/elasticsearch/ExConditionFilter.vm Normal file
View file

@ -0,0 +1,9 @@
package ${request.package}.cbean.cf;
import ${request.package}.cbean.cf.bs.Bs${table.camelizedName}CF;
/**
* @author FreeGen
*/
public class ${table.camelizedName}CF extends Bs${table.camelizedName}CF {
}