diff --git a/src/main/java/org/codelibs/fess/es/cbean/bs/AbstractConditionBean.java b/src/main/java/org/codelibs/fess/es/cbean/bs/AbstractConditionBean.java index 7eb6434c8..6381bd8c8 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/bs/AbstractConditionBean.java +++ b/src/main/java/org/codelibs/fess/es/cbean/bs/AbstractConditionBean.java @@ -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; + } + } } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/BoostDocumentRuleCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/BoostDocumentRuleCF.java new file mode 100644 index 000000000..681db09eb --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/BoostDocumentRuleCF.java @@ -0,0 +1,7 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsBoostDocumentRuleCF; + +public class BoostDocumentRuleCF extends BsBoostDocumentRuleCF { + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/ClickLogCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/ClickLogCF.java new file mode 100644 index 000000000..f18172b6c --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/ClickLogCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsClickLogCF; + +/** + * @author FreeGen + */ +public class ClickLogCF extends BsClickLogCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/CrawlingSessionCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/CrawlingSessionCF.java new file mode 100644 index 000000000..d20a12bd0 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/CrawlingSessionCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsCrawlingSessionCF; + +/** + * @author FreeGen + */ +public class CrawlingSessionCF extends BsCrawlingSessionCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/CrawlingSessionInfoCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/CrawlingSessionInfoCF.java new file mode 100644 index 000000000..6d17fa1ea --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/CrawlingSessionInfoCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsCrawlingSessionInfoCF; + +/** + * @author FreeGen + */ +public class CrawlingSessionInfoCF extends BsCrawlingSessionInfoCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigCF.java new file mode 100644 index 000000000..2e46ad614 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsDataConfigCF; + +/** + * @author FreeGen + */ +public class DataConfigCF extends BsDataConfigCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigToLabelCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigToLabelCF.java new file mode 100644 index 000000000..d23564d00 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigToLabelCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsDataConfigToLabelCF; + +/** + * @author FreeGen + */ +public class DataConfigToLabelCF extends BsDataConfigToLabelCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigToRoleCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigToRoleCF.java new file mode 100644 index 000000000..db253031f --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/DataConfigToRoleCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsDataConfigToRoleCF; + +/** + * @author FreeGen + */ +public class DataConfigToRoleCF extends BsDataConfigToRoleCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/FailureUrlCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/FailureUrlCF.java new file mode 100644 index 000000000..074dffc9f --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/FailureUrlCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsFailureUrlCF; + +/** + * @author FreeGen + */ +public class FailureUrlCF extends BsFailureUrlCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/FavoriteLogCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/FavoriteLogCF.java new file mode 100644 index 000000000..8e969c02b --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/FavoriteLogCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsFavoriteLogCF; + +/** + * @author FreeGen + */ +public class FavoriteLogCF extends BsFavoriteLogCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/FileAuthenticationCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/FileAuthenticationCF.java new file mode 100644 index 000000000..dd0209652 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/FileAuthenticationCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsFileAuthenticationCF; + +/** + * @author FreeGen + */ +public class FileAuthenticationCF extends BsFileAuthenticationCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigCF.java new file mode 100644 index 000000000..47054b97e --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsFileConfigCF; + +/** + * @author FreeGen + */ +public class FileConfigCF extends BsFileConfigCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigToLabelCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigToLabelCF.java new file mode 100644 index 000000000..99d8c612b --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigToLabelCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsFileConfigToLabelCF; + +/** + * @author FreeGen + */ +public class FileConfigToLabelCF extends BsFileConfigToLabelCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigToRoleCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigToRoleCF.java new file mode 100644 index 000000000..2edbe3445 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/FileConfigToRoleCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsFileConfigToRoleCF; + +/** + * @author FreeGen + */ +public class FileConfigToRoleCF extends BsFileConfigToRoleCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/JobLogCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/JobLogCF.java new file mode 100644 index 000000000..62eae9d61 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/JobLogCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsJobLogCF; + +/** + * @author FreeGen + */ +public class JobLogCF extends BsJobLogCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/KeyMatchCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/KeyMatchCF.java new file mode 100644 index 000000000..9bc24ffe2 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/KeyMatchCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsKeyMatchCF; + +/** + * @author FreeGen + */ +public class KeyMatchCF extends BsKeyMatchCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/LabelToRoleCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/LabelToRoleCF.java new file mode 100644 index 000000000..7f84b3bea --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/LabelToRoleCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsLabelToRoleCF; + +/** + * @author FreeGen + */ +public class LabelToRoleCF extends BsLabelToRoleCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/LabelTypeCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/LabelTypeCF.java new file mode 100644 index 000000000..f40eb1c78 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/LabelTypeCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsLabelTypeCF; + +/** + * @author FreeGen + */ +public class LabelTypeCF extends BsLabelTypeCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/OverlappingHostCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/OverlappingHostCF.java new file mode 100644 index 000000000..6da787e7d --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/OverlappingHostCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsOverlappingHostCF; + +/** + * @author FreeGen + */ +public class OverlappingHostCF extends BsOverlappingHostCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/PathMappingCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/PathMappingCF.java new file mode 100644 index 000000000..37384afad --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/PathMappingCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsPathMappingCF; + +/** + * @author FreeGen + */ +public class PathMappingCF extends BsPathMappingCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/RequestHeaderCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/RequestHeaderCF.java new file mode 100644 index 000000000..81b2fd950 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/RequestHeaderCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsRequestHeaderCF; + +/** + * @author FreeGen + */ +public class RequestHeaderCF extends BsRequestHeaderCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/RoleTypeCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/RoleTypeCF.java new file mode 100644 index 000000000..0c0187c1c --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/RoleTypeCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsRoleTypeCF; + +/** + * @author FreeGen + */ +public class RoleTypeCF extends BsRoleTypeCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/ScheduledJobCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/ScheduledJobCF.java new file mode 100644 index 000000000..05f1e6d6b --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/ScheduledJobCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsScheduledJobCF; + +/** + * @author FreeGen + */ +public class ScheduledJobCF extends BsScheduledJobCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/SearchFieldLogCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/SearchFieldLogCF.java new file mode 100644 index 000000000..c83b999d3 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/SearchFieldLogCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsSearchFieldLogCF; + +/** + * @author FreeGen + */ +public class SearchFieldLogCF extends BsSearchFieldLogCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/SearchLogCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/SearchLogCF.java new file mode 100644 index 000000000..a04d3d0c3 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/SearchLogCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsSearchLogCF; + +/** + * @author FreeGen + */ +public class SearchLogCF extends BsSearchLogCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/SuggestBadWordCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/SuggestBadWordCF.java new file mode 100644 index 000000000..40ebdec4a --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/SuggestBadWordCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsSuggestBadWordCF; + +/** + * @author FreeGen + */ +public class SuggestBadWordCF extends BsSuggestBadWordCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/SuggestElevateWordCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/SuggestElevateWordCF.java new file mode 100644 index 000000000..6ba595991 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/SuggestElevateWordCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsSuggestElevateWordCF; + +/** + * @author FreeGen + */ +public class SuggestElevateWordCF extends BsSuggestElevateWordCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/UserInfoCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/UserInfoCF.java new file mode 100644 index 000000000..8b27cb42c --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/UserInfoCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsUserInfoCF; + +/** + * @author FreeGen + */ +public class UserInfoCF extends BsUserInfoCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/WebAuthenticationCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/WebAuthenticationCF.java new file mode 100644 index 000000000..dc33b433a --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/WebAuthenticationCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsWebAuthenticationCF; + +/** + * @author FreeGen + */ +public class WebAuthenticationCF extends BsWebAuthenticationCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigCF.java new file mode 100644 index 000000000..7eee57e7a --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsWebConfigCF; + +/** + * @author FreeGen + */ +public class WebConfigCF extends BsWebConfigCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigToLabelCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigToLabelCF.java new file mode 100644 index 000000000..0a04ab832 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigToLabelCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsWebConfigToLabelCF; + +/** + * @author FreeGen + */ +public class WebConfigToLabelCF extends BsWebConfigToLabelCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigToRoleCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigToRoleCF.java new file mode 100644 index 000000000..8bbff3cf2 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/WebConfigToRoleCF.java @@ -0,0 +1,9 @@ +package org.codelibs.fess.es.cbean.cf; + +import org.codelibs.fess.es.cbean.cf.bs.BsWebConfigToRoleCF; + +/** + * @author FreeGen + */ +public class WebConfigToRoleCF extends BsWebConfigToRoleCF { +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/AbstractConditionFilter.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/AbstractConditionFilter.java new file mode 100644 index 000000000..730a93995 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/AbstractConditionFilter.java @@ -0,0 +1,215 @@ +package org.codelibs.fess.es.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 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 idList) { + setIds_Equal(idList, null); + } + + public void setIds_Equal(Collection idList, ConditionOptionCall opLambda) { + IdsFilterBuilder builder = regIdsF(idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void matchAll() { + matchAll(null); + } + + public void matchAll(ConditionOptionCall 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 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 mustList, List shouldList, List 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 filterList) { + AndFilterBuilder andFilter = FilterBuilders.andFilter(filterList.toArray(new FilterBuilder[filterList.size()])); + regF(andFilter); + return andFilter; + } + + protected OrFilterBuilder regOrF(List 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 { + + /** + * @param op The option of condition to be set up. (NotNull) + */ + void callback(OP op); + } + + @FunctionalInterface + public interface BoolCall { + + void callback(CF must, CF should, CF mustNot); + } + + @FunctionalInterface + public interface OperatorCall { + + void callback(CF and); + } +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsBoostDocumentRuleCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsBoostDocumentRuleCF.java new file mode 100644 index 000000000..4aa0f1753 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsBoostDocumentRuleCF.java @@ -0,0 +1,932 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.BoostDocumentRuleCF; +import org.codelibs.fess.es.cbean.cq.BoostDocumentRuleCQ; +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 BsBoostDocumentRuleCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + BoostDocumentRuleCF mustFilter = new BoostDocumentRuleCF(); + BoostDocumentRuleCF shouldFilter = new BoostDocumentRuleCF(); + BoostDocumentRuleCF mustNotFilter = new BoostDocumentRuleCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + BoostDocumentRuleCF andFilter = new BoostDocumentRuleCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + BoostDocumentRuleCF orFilter = new BoostDocumentRuleCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + BoostDocumentRuleCF notFilter = new BoostDocumentRuleCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + BoostDocumentRuleCQ query = new BoostDocumentRuleCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setBoostExpr_Term(String boostExpr) { + setBoostExpr_Term(boostExpr, null); + } + + public void setBoostExpr_Term(String boostExpr, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("boostExpr", boostExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoostExpr_Terms(Collection boostExprList) { + setBoostExpr_Terms(boostExprList, null); + } + + public void setBoostExpr_Terms(Collection boostExprList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("boostExpr", boostExprList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoostExpr_InScope(Collection boostExprList) { + setBoostExpr_Terms(boostExprList, null); + } + + public void setBoostExpr_InScope(Collection boostExprList, ConditionOptionCall opLambda) { + setBoostExpr_Terms(boostExprList, opLambda); + } + + public void setBoostExpr_Prefix(String boostExpr) { + setBoostExpr_Prefix(boostExpr, null); + } + + public void setBoostExpr_Prefix(String boostExpr, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("boostExpr", boostExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoostExpr_Exists() { + setBoostExpr_Exists(null); + } + + public void setBoostExpr_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("boostExpr"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoostExpr_Missing() { + setBoostExpr_Missing(null); + } + + public void setBoostExpr_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("boostExpr"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoostExpr_GreaterThan(String boostExpr) { + setBoostExpr_GreaterThan(boostExpr, null); + } + + public void setBoostExpr_GreaterThan(String boostExpr, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boostExpr", ConditionKey.CK_GREATER_THAN, boostExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoostExpr_LessThan(String boostExpr) { + setBoostExpr_LessThan(boostExpr, null); + } + + public void setBoostExpr_LessThan(String boostExpr, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boostExpr", ConditionKey.CK_LESS_THAN, boostExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoostExpr_GreaterEqual(String boostExpr) { + setBoostExpr_GreaterEqual(boostExpr, null); + } + + public void setBoostExpr_GreaterEqual(String boostExpr, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boostExpr", ConditionKey.CK_GREATER_EQUAL, boostExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoostExpr_LessEqual(String boostExpr) { + setBoostExpr_LessEqual(boostExpr, null); + } + + public void setBoostExpr_LessEqual(String boostExpr, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boostExpr", ConditionKey.CK_LESS_EQUAL, boostExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Term(Integer sortOrder) { + setSortOrder_Term(sortOrder, null); + } + + public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("sortOrder", sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Terms(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_InScope(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { + setSortOrder_Terms(sortOrderList, opLambda); + } + + public void setSortOrder_Exists() { + setSortOrder_Exists(null); + } + + public void setSortOrder_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Missing() { + setSortOrder_Missing(null); + } + + public void setSortOrder_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterThan(Integer sortOrder) { + setSortOrder_GreaterThan(sortOrder, null); + } + + public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessThan(Integer sortOrder) { + setSortOrder_LessThan(sortOrder, null); + } + + public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterEqual(Integer sortOrder) { + setSortOrder_GreaterEqual(sortOrder, null); + } + + public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessEqual(Integer sortOrder) { + setSortOrder_LessEqual(sortOrder, null); + } + + public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrlExpr_Term(String urlExpr) { + setUrlExpr_Term(urlExpr, null); + } + + public void setUrlExpr_Term(String urlExpr, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("urlExpr", urlExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrlExpr_Terms(Collection urlExprList) { + setUrlExpr_Terms(urlExprList, null); + } + + public void setUrlExpr_Terms(Collection urlExprList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("urlExpr", urlExprList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrlExpr_InScope(Collection urlExprList) { + setUrlExpr_Terms(urlExprList, null); + } + + public void setUrlExpr_InScope(Collection urlExprList, ConditionOptionCall opLambda) { + setUrlExpr_Terms(urlExprList, opLambda); + } + + public void setUrlExpr_Prefix(String urlExpr) { + setUrlExpr_Prefix(urlExpr, null); + } + + public void setUrlExpr_Prefix(String urlExpr, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("urlExpr", urlExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrlExpr_Exists() { + setUrlExpr_Exists(null); + } + + public void setUrlExpr_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("urlExpr"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrlExpr_Missing() { + setUrlExpr_Missing(null); + } + + public void setUrlExpr_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("urlExpr"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrlExpr_GreaterThan(String urlExpr) { + setUrlExpr_GreaterThan(urlExpr, null); + } + + public void setUrlExpr_GreaterThan(String urlExpr, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("urlExpr", ConditionKey.CK_GREATER_THAN, urlExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrlExpr_LessThan(String urlExpr) { + setUrlExpr_LessThan(urlExpr, null); + } + + public void setUrlExpr_LessThan(String urlExpr, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("urlExpr", ConditionKey.CK_LESS_THAN, urlExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrlExpr_GreaterEqual(String urlExpr) { + setUrlExpr_GreaterEqual(urlExpr, null); + } + + public void setUrlExpr_GreaterEqual(String urlExpr, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("urlExpr", ConditionKey.CK_GREATER_EQUAL, urlExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrlExpr_LessEqual(String urlExpr) { + setUrlExpr_LessEqual(urlExpr, null); + } + + public void setUrlExpr_LessEqual(String urlExpr, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("urlExpr", ConditionKey.CK_LESS_EQUAL, urlExpr); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsClickLogCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsClickLogCF.java new file mode 100644 index 000000000..8002f47dd --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsClickLogCF.java @@ -0,0 +1,526 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.ClickLogCF; +import org.codelibs.fess.es.cbean.cq.ClickLogCQ; +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 BsClickLogCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + ClickLogCF mustFilter = new ClickLogCF(); + ClickLogCF shouldFilter = new ClickLogCF(); + ClickLogCF mustNotFilter = new ClickLogCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + ClickLogCF andFilter = new ClickLogCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + ClickLogCF orFilter = new ClickLogCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + ClickLogCF notFilter = new ClickLogCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + ClickLogCQ query = new ClickLogCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_Term(Long requestedTime) { + setRequestedTime_Term(requestedTime, null); + } + + public void setRequestedTime_Term(Long requestedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("requestedTime", requestedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_Terms(Collection requestedTimeList) { + setRequestedTime_Terms(requestedTimeList, null); + } + + public void setRequestedTime_Terms(Collection requestedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("requestedTime", requestedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_InScope(Collection requestedTimeList) { + setRequestedTime_Terms(requestedTimeList, null); + } + + public void setRequestedTime_InScope(Collection requestedTimeList, ConditionOptionCall opLambda) { + setRequestedTime_Terms(requestedTimeList, opLambda); + } + + public void setRequestedTime_Exists() { + setRequestedTime_Exists(null); + } + + public void setRequestedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("requestedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_Missing() { + setRequestedTime_Missing(null); + } + + public void setRequestedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("requestedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_GreaterThan(Long requestedTime) { + setRequestedTime_GreaterThan(requestedTime, null); + } + + public void setRequestedTime_GreaterThan(Long requestedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_GREATER_THAN, requestedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_LessThan(Long requestedTime) { + setRequestedTime_LessThan(requestedTime, null); + } + + public void setRequestedTime_LessThan(Long requestedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_LESS_THAN, requestedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_GreaterEqual(Long requestedTime) { + setRequestedTime_GreaterEqual(requestedTime, null); + } + + public void setRequestedTime_GreaterEqual(Long requestedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_GREATER_EQUAL, requestedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_LessEqual(Long requestedTime) { + setRequestedTime_LessEqual(requestedTime, null); + } + + public void setRequestedTime_LessEqual(Long requestedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_LESS_EQUAL, requestedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_Term(String searchLogId) { + setSearchLogId_Term(searchLogId, null); + } + + public void setSearchLogId_Term(String searchLogId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("searchLogId", searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_Terms(Collection searchLogIdList) { + setSearchLogId_Terms(searchLogIdList, null); + } + + public void setSearchLogId_Terms(Collection searchLogIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("searchLogId", searchLogIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_InScope(Collection searchLogIdList) { + setSearchLogId_Terms(searchLogIdList, null); + } + + public void setSearchLogId_InScope(Collection searchLogIdList, ConditionOptionCall opLambda) { + setSearchLogId_Terms(searchLogIdList, opLambda); + } + + public void setSearchLogId_Prefix(String searchLogId) { + setSearchLogId_Prefix(searchLogId, null); + } + + public void setSearchLogId_Prefix(String searchLogId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("searchLogId", searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_Exists() { + setSearchLogId_Exists(null); + } + + public void setSearchLogId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("searchLogId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_Missing() { + setSearchLogId_Missing(null); + } + + public void setSearchLogId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("searchLogId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_GreaterThan(String searchLogId) { + setSearchLogId_GreaterThan(searchLogId, null); + } + + public void setSearchLogId_GreaterThan(String searchLogId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_LessThan(String searchLogId) { + setSearchLogId_LessThan(searchLogId, null); + } + + public void setSearchLogId_LessThan(String searchLogId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_GreaterEqual(String searchLogId) { + setSearchLogId_GreaterEqual(searchLogId, null); + } + + public void setSearchLogId_GreaterEqual(String searchLogId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_LessEqual(String searchLogId) { + setSearchLogId_LessEqual(searchLogId, null); + } + + public void setSearchLogId_LessEqual(String searchLogId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Term(String url) { + setUrl_Term(url, null); + } + + public void setUrl_Term(String url, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("url", url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Terms(Collection urlList) { + setUrl_Terms(urlList, null); + } + + public void setUrl_Terms(Collection urlList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("url", urlList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_InScope(Collection urlList) { + setUrl_Terms(urlList, null); + } + + public void setUrl_InScope(Collection urlList, ConditionOptionCall opLambda) { + setUrl_Terms(urlList, opLambda); + } + + public void setUrl_Prefix(String url) { + setUrl_Prefix(url, null); + } + + public void setUrl_Prefix(String url, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("url", url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Exists() { + setUrl_Exists(null); + } + + public void setUrl_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("url"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Missing() { + setUrl_Missing(null); + } + + public void setUrl_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("url"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_GreaterThan(String url) { + setUrl_GreaterThan(url, null); + } + + public void setUrl_GreaterThan(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_THAN, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_LessThan(String url) { + setUrl_LessThan(url, null); + } + + public void setUrl_LessThan(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_THAN, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_GreaterEqual(String url) { + setUrl_GreaterEqual(url, null); + } + + public void setUrl_GreaterEqual(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_EQUAL, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_LessEqual(String url) { + setUrl_LessEqual(url, null); + } + + public void setUrl_LessEqual(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_EQUAL, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsCrawlingSessionCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsCrawlingSessionCF.java new file mode 100644 index 000000000..c559b768e --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsCrawlingSessionCF.java @@ -0,0 +1,622 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.CrawlingSessionCF; +import org.codelibs.fess.es.cbean.cq.CrawlingSessionCQ; +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 BsCrawlingSessionCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + CrawlingSessionCF mustFilter = new CrawlingSessionCF(); + CrawlingSessionCF shouldFilter = new CrawlingSessionCF(); + CrawlingSessionCF mustNotFilter = new CrawlingSessionCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + CrawlingSessionCF andFilter = new CrawlingSessionCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + CrawlingSessionCF orFilter = new CrawlingSessionCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + CrawlingSessionCF notFilter = new CrawlingSessionCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + CrawlingSessionCQ query = new CrawlingSessionCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExpiredTime_Term(Long expiredTime) { + setExpiredTime_Term(expiredTime, null); + } + + public void setExpiredTime_Term(Long expiredTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("expiredTime", expiredTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExpiredTime_Terms(Collection expiredTimeList) { + setExpiredTime_Terms(expiredTimeList, null); + } + + public void setExpiredTime_Terms(Collection expiredTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("expiredTime", expiredTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExpiredTime_InScope(Collection expiredTimeList) { + setExpiredTime_Terms(expiredTimeList, null); + } + + public void setExpiredTime_InScope(Collection expiredTimeList, ConditionOptionCall opLambda) { + setExpiredTime_Terms(expiredTimeList, opLambda); + } + + public void setExpiredTime_Exists() { + setExpiredTime_Exists(null); + } + + public void setExpiredTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("expiredTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExpiredTime_Missing() { + setExpiredTime_Missing(null); + } + + public void setExpiredTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("expiredTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExpiredTime_GreaterThan(Long expiredTime) { + setExpiredTime_GreaterThan(expiredTime, null); + } + + public void setExpiredTime_GreaterThan(Long expiredTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("expiredTime", ConditionKey.CK_GREATER_THAN, expiredTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExpiredTime_LessThan(Long expiredTime) { + setExpiredTime_LessThan(expiredTime, null); + } + + public void setExpiredTime_LessThan(Long expiredTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("expiredTime", ConditionKey.CK_LESS_THAN, expiredTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExpiredTime_GreaterEqual(Long expiredTime) { + setExpiredTime_GreaterEqual(expiredTime, null); + } + + public void setExpiredTime_GreaterEqual(Long expiredTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("expiredTime", ConditionKey.CK_GREATER_EQUAL, expiredTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExpiredTime_LessEqual(Long expiredTime) { + setExpiredTime_LessEqual(expiredTime, null); + } + + public void setExpiredTime_LessEqual(Long expiredTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("expiredTime", ConditionKey.CK_LESS_EQUAL, expiredTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Term(String name) { + setName_Term(name, null); + } + + public void setName_Term(String name, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Terms(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("name", nameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_InScope(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { + setName_Terms(nameList, opLambda); + } + + public void setName_Prefix(String name) { + setName_Prefix(name, null); + } + + public void setName_Prefix(String name, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Exists() { + setName_Exists(null); + } + + public void setName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Missing() { + setName_Missing(null); + } + + public void setName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterThan(String name) { + setName_GreaterThan(name, null); + } + + public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessThan(String name) { + setName_LessThan(name, null); + } + + public void setName_LessThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterEqual(String name) { + setName_GreaterEqual(name, null); + } + + public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessEqual(String name) { + setName_LessEqual(name, null); + } + + public void setName_LessEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSessionId_Term(String sessionId) { + setSessionId_Term(sessionId, null); + } + + public void setSessionId_Term(String sessionId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("sessionId", sessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSessionId_Terms(Collection sessionIdList) { + setSessionId_Terms(sessionIdList, null); + } + + public void setSessionId_Terms(Collection sessionIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("sessionId", sessionIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSessionId_InScope(Collection sessionIdList) { + setSessionId_Terms(sessionIdList, null); + } + + public void setSessionId_InScope(Collection sessionIdList, ConditionOptionCall opLambda) { + setSessionId_Terms(sessionIdList, opLambda); + } + + public void setSessionId_Prefix(String sessionId) { + setSessionId_Prefix(sessionId, null); + } + + public void setSessionId_Prefix(String sessionId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("sessionId", sessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSessionId_Exists() { + setSessionId_Exists(null); + } + + public void setSessionId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("sessionId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSessionId_Missing() { + setSessionId_Missing(null); + } + + public void setSessionId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("sessionId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSessionId_GreaterThan(String sessionId) { + setSessionId_GreaterThan(sessionId, null); + } + + public void setSessionId_GreaterThan(String sessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sessionId", ConditionKey.CK_GREATER_THAN, sessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSessionId_LessThan(String sessionId) { + setSessionId_LessThan(sessionId, null); + } + + public void setSessionId_LessThan(String sessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sessionId", ConditionKey.CK_LESS_THAN, sessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSessionId_GreaterEqual(String sessionId) { + setSessionId_GreaterEqual(sessionId, null); + } + + public void setSessionId_GreaterEqual(String sessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sessionId", ConditionKey.CK_GREATER_EQUAL, sessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSessionId_LessEqual(String sessionId) { + setSessionId_LessEqual(sessionId, null); + } + + public void setSessionId_LessEqual(String sessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sessionId", ConditionKey.CK_LESS_EQUAL, sessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsCrawlingSessionInfoCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsCrawlingSessionInfoCF.java new file mode 100644 index 000000000..df4f1a0b9 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsCrawlingSessionInfoCF.java @@ -0,0 +1,633 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.CrawlingSessionInfoCF; +import org.codelibs.fess.es.cbean.cq.CrawlingSessionInfoCQ; +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 BsCrawlingSessionInfoCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + CrawlingSessionInfoCF mustFilter = new CrawlingSessionInfoCF(); + CrawlingSessionInfoCF shouldFilter = new CrawlingSessionInfoCF(); + CrawlingSessionInfoCF mustNotFilter = new CrawlingSessionInfoCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + CrawlingSessionInfoCF andFilter = new CrawlingSessionInfoCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + CrawlingSessionInfoCF orFilter = new CrawlingSessionInfoCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + CrawlingSessionInfoCF notFilter = new CrawlingSessionInfoCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + CrawlingSessionInfoCQ query = new CrawlingSessionInfoCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setCrawlingSessionId_Term(String crawlingSessionId) { + setCrawlingSessionId_Term(crawlingSessionId, null); + } + + public void setCrawlingSessionId_Term(String crawlingSessionId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("crawlingSessionId", crawlingSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawlingSessionId_Terms(Collection crawlingSessionIdList) { + setCrawlingSessionId_Terms(crawlingSessionIdList, null); + } + + public void setCrawlingSessionId_Terms(Collection crawlingSessionIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("crawlingSessionId", crawlingSessionIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawlingSessionId_InScope(Collection crawlingSessionIdList) { + setCrawlingSessionId_Terms(crawlingSessionIdList, null); + } + + public void setCrawlingSessionId_InScope(Collection crawlingSessionIdList, ConditionOptionCall opLambda) { + setCrawlingSessionId_Terms(crawlingSessionIdList, opLambda); + } + + public void setCrawlingSessionId_Prefix(String crawlingSessionId) { + setCrawlingSessionId_Prefix(crawlingSessionId, null); + } + + public void setCrawlingSessionId_Prefix(String crawlingSessionId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("crawlingSessionId", crawlingSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawlingSessionId_Exists() { + setCrawlingSessionId_Exists(null); + } + + public void setCrawlingSessionId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("crawlingSessionId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawlingSessionId_Missing() { + setCrawlingSessionId_Missing(null); + } + + public void setCrawlingSessionId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("crawlingSessionId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawlingSessionId_GreaterThan(String crawlingSessionId) { + setCrawlingSessionId_GreaterThan(crawlingSessionId, null); + } + + public void setCrawlingSessionId_GreaterThan(String crawlingSessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("crawlingSessionId", ConditionKey.CK_GREATER_THAN, crawlingSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawlingSessionId_LessThan(String crawlingSessionId) { + setCrawlingSessionId_LessThan(crawlingSessionId, null); + } + + public void setCrawlingSessionId_LessThan(String crawlingSessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("crawlingSessionId", ConditionKey.CK_LESS_THAN, crawlingSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawlingSessionId_GreaterEqual(String crawlingSessionId) { + setCrawlingSessionId_GreaterEqual(crawlingSessionId, null); + } + + public void setCrawlingSessionId_GreaterEqual(String crawlingSessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("crawlingSessionId", ConditionKey.CK_GREATER_EQUAL, crawlingSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawlingSessionId_LessEqual(String crawlingSessionId) { + setCrawlingSessionId_LessEqual(crawlingSessionId, null); + } + + public void setCrawlingSessionId_LessEqual(String crawlingSessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("crawlingSessionId", ConditionKey.CK_LESS_EQUAL, crawlingSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setKey_Term(String key) { + setKey_Term(key, null); + } + + public void setKey_Term(String key, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("key", key); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setKey_Terms(Collection keyList) { + setKey_Terms(keyList, null); + } + + public void setKey_Terms(Collection keyList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("key", keyList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setKey_InScope(Collection keyList) { + setKey_Terms(keyList, null); + } + + public void setKey_InScope(Collection keyList, ConditionOptionCall opLambda) { + setKey_Terms(keyList, opLambda); + } + + public void setKey_Prefix(String key) { + setKey_Prefix(key, null); + } + + public void setKey_Prefix(String key, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("key", key); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setKey_Exists() { + setKey_Exists(null); + } + + public void setKey_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("key"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setKey_Missing() { + setKey_Missing(null); + } + + public void setKey_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("key"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setKey_GreaterThan(String key) { + setKey_GreaterThan(key, null); + } + + public void setKey_GreaterThan(String key, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("key", ConditionKey.CK_GREATER_THAN, key); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setKey_LessThan(String key) { + setKey_LessThan(key, null); + } + + public void setKey_LessThan(String key, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("key", ConditionKey.CK_LESS_THAN, key); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setKey_GreaterEqual(String key) { + setKey_GreaterEqual(key, null); + } + + public void setKey_GreaterEqual(String key, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("key", ConditionKey.CK_GREATER_EQUAL, key); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setKey_LessEqual(String key) { + setKey_LessEqual(key, null); + } + + public void setKey_LessEqual(String key, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("key", ConditionKey.CK_LESS_EQUAL, key); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Term(String value) { + setValue_Term(value, null); + } + + public void setValue_Term(String value, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("value", value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Terms(Collection valueList) { + setValue_Terms(valueList, null); + } + + public void setValue_Terms(Collection valueList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("value", valueList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_InScope(Collection valueList) { + setValue_Terms(valueList, null); + } + + public void setValue_InScope(Collection valueList, ConditionOptionCall opLambda) { + setValue_Terms(valueList, opLambda); + } + + public void setValue_Prefix(String value) { + setValue_Prefix(value, null); + } + + public void setValue_Prefix(String value, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("value", value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Exists() { + setValue_Exists(null); + } + + public void setValue_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("value"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Missing() { + setValue_Missing(null); + } + + public void setValue_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("value"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_GreaterThan(String value) { + setValue_GreaterThan(value, null); + } + + public void setValue_GreaterThan(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_THAN, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_LessThan(String value) { + setValue_LessThan(value, null); + } + + public void setValue_LessThan(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_THAN, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_GreaterEqual(String value) { + setValue_GreaterEqual(value, null); + } + + public void setValue_GreaterEqual(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_EQUAL, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_LessEqual(String value) { + setValue_LessEqual(value, null); + } + + public void setValue_LessEqual(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_EQUAL, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigCF.java new file mode 100644 index 000000000..8787a69a3 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigCF.java @@ -0,0 +1,1338 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.DataConfigCF; +import org.codelibs.fess.es.cbean.cq.DataConfigCQ; +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 BsDataConfigCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + DataConfigCF mustFilter = new DataConfigCF(); + DataConfigCF shouldFilter = new DataConfigCF(); + DataConfigCF mustNotFilter = new DataConfigCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + DataConfigCF andFilter = new DataConfigCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + DataConfigCF orFilter = new DataConfigCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + DataConfigCF notFilter = new DataConfigCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + DataConfigCQ query = new DataConfigCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setAvailable_Term(Boolean available) { + setAvailable_Term(available, null); + } + + public void setAvailable_Term(Boolean available, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("available", available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_Terms(Collection availableList) { + setAvailable_Terms(availableList, null); + } + + public void setAvailable_Terms(Collection availableList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("available", availableList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_InScope(Collection availableList) { + setAvailable_Terms(availableList, null); + } + + public void setAvailable_InScope(Collection availableList, ConditionOptionCall opLambda) { + setAvailable_Terms(availableList, opLambda); + } + + public void setAvailable_Exists() { + setAvailable_Exists(null); + } + + public void setAvailable_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("available"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_Missing() { + setAvailable_Missing(null); + } + + public void setAvailable_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("available"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_GreaterThan(Boolean available) { + setAvailable_GreaterThan(available, null); + } + + public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_THAN, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_LessThan(Boolean available) { + setAvailable_LessThan(available, null); + } + + public void setAvailable_LessThan(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_THAN, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_GreaterEqual(Boolean available) { + setAvailable_GreaterEqual(available, null); + } + + public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_EQUAL, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_LessEqual(Boolean available) { + setAvailable_LessEqual(available, null); + } + + public void setAvailable_LessEqual(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_EQUAL, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Term(Float boost) { + setBoost_Term(boost, null); + } + + public void setBoost_Term(Float boost, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("boost", boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Terms(Collection boostList) { + setBoost_Terms(boostList, null); + } + + public void setBoost_Terms(Collection boostList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("boost", boostList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_InScope(Collection boostList) { + setBoost_Terms(boostList, null); + } + + public void setBoost_InScope(Collection boostList, ConditionOptionCall opLambda) { + setBoost_Terms(boostList, opLambda); + } + + public void setBoost_Exists() { + setBoost_Exists(null); + } + + public void setBoost_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("boost"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Missing() { + setBoost_Missing(null); + } + + public void setBoost_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("boost"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_GreaterThan(Float boost) { + setBoost_GreaterThan(boost, null); + } + + public void setBoost_GreaterThan(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_THAN, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_LessThan(Float boost) { + setBoost_LessThan(boost, null); + } + + public void setBoost_LessThan(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_THAN, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_GreaterEqual(Float boost) { + setBoost_GreaterEqual(boost, null); + } + + public void setBoost_GreaterEqual(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_EQUAL, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_LessEqual(Float boost) { + setBoost_LessEqual(boost, null); + } + + public void setBoost_LessEqual(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_EQUAL, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerName_Term(String handlerName) { + setHandlerName_Term(handlerName, null); + } + + public void setHandlerName_Term(String handlerName, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("handlerName", handlerName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerName_Terms(Collection handlerNameList) { + setHandlerName_Terms(handlerNameList, null); + } + + public void setHandlerName_Terms(Collection handlerNameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("handlerName", handlerNameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerName_InScope(Collection handlerNameList) { + setHandlerName_Terms(handlerNameList, null); + } + + public void setHandlerName_InScope(Collection handlerNameList, ConditionOptionCall opLambda) { + setHandlerName_Terms(handlerNameList, opLambda); + } + + public void setHandlerName_Prefix(String handlerName) { + setHandlerName_Prefix(handlerName, null); + } + + public void setHandlerName_Prefix(String handlerName, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("handlerName", handlerName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerName_Exists() { + setHandlerName_Exists(null); + } + + public void setHandlerName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("handlerName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerName_Missing() { + setHandlerName_Missing(null); + } + + public void setHandlerName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("handlerName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerName_GreaterThan(String handlerName) { + setHandlerName_GreaterThan(handlerName, null); + } + + public void setHandlerName_GreaterThan(String handlerName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerName", ConditionKey.CK_GREATER_THAN, handlerName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerName_LessThan(String handlerName) { + setHandlerName_LessThan(handlerName, null); + } + + public void setHandlerName_LessThan(String handlerName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerName", ConditionKey.CK_LESS_THAN, handlerName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerName_GreaterEqual(String handlerName) { + setHandlerName_GreaterEqual(handlerName, null); + } + + public void setHandlerName_GreaterEqual(String handlerName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerName", ConditionKey.CK_GREATER_EQUAL, handlerName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerName_LessEqual(String handlerName) { + setHandlerName_LessEqual(handlerName, null); + } + + public void setHandlerName_LessEqual(String handlerName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerName", ConditionKey.CK_LESS_EQUAL, handlerName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerParameter_Term(String handlerParameter) { + setHandlerParameter_Term(handlerParameter, null); + } + + public void setHandlerParameter_Term(String handlerParameter, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("handlerParameter", handlerParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerParameter_Terms(Collection handlerParameterList) { + setHandlerParameter_Terms(handlerParameterList, null); + } + + public void setHandlerParameter_Terms(Collection handlerParameterList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("handlerParameter", handlerParameterList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerParameter_InScope(Collection handlerParameterList) { + setHandlerParameter_Terms(handlerParameterList, null); + } + + public void setHandlerParameter_InScope(Collection handlerParameterList, ConditionOptionCall opLambda) { + setHandlerParameter_Terms(handlerParameterList, opLambda); + } + + public void setHandlerParameter_Prefix(String handlerParameter) { + setHandlerParameter_Prefix(handlerParameter, null); + } + + public void setHandlerParameter_Prefix(String handlerParameter, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("handlerParameter", handlerParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerParameter_Exists() { + setHandlerParameter_Exists(null); + } + + public void setHandlerParameter_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("handlerParameter"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerParameter_Missing() { + setHandlerParameter_Missing(null); + } + + public void setHandlerParameter_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("handlerParameter"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerParameter_GreaterThan(String handlerParameter) { + setHandlerParameter_GreaterThan(handlerParameter, null); + } + + public void setHandlerParameter_GreaterThan(String handlerParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerParameter", ConditionKey.CK_GREATER_THAN, handlerParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerParameter_LessThan(String handlerParameter) { + setHandlerParameter_LessThan(handlerParameter, null); + } + + public void setHandlerParameter_LessThan(String handlerParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerParameter", ConditionKey.CK_LESS_THAN, handlerParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerParameter_GreaterEqual(String handlerParameter) { + setHandlerParameter_GreaterEqual(handlerParameter, null); + } + + public void setHandlerParameter_GreaterEqual(String handlerParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerParameter", ConditionKey.CK_GREATER_EQUAL, handlerParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerParameter_LessEqual(String handlerParameter) { + setHandlerParameter_LessEqual(handlerParameter, null); + } + + public void setHandlerParameter_LessEqual(String handlerParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerParameter", ConditionKey.CK_LESS_EQUAL, handlerParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerScript_Term(String handlerScript) { + setHandlerScript_Term(handlerScript, null); + } + + public void setHandlerScript_Term(String handlerScript, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("handlerScript", handlerScript); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerScript_Terms(Collection handlerScriptList) { + setHandlerScript_Terms(handlerScriptList, null); + } + + public void setHandlerScript_Terms(Collection handlerScriptList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("handlerScript", handlerScriptList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerScript_InScope(Collection handlerScriptList) { + setHandlerScript_Terms(handlerScriptList, null); + } + + public void setHandlerScript_InScope(Collection handlerScriptList, ConditionOptionCall opLambda) { + setHandlerScript_Terms(handlerScriptList, opLambda); + } + + public void setHandlerScript_Prefix(String handlerScript) { + setHandlerScript_Prefix(handlerScript, null); + } + + public void setHandlerScript_Prefix(String handlerScript, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("handlerScript", handlerScript); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerScript_Exists() { + setHandlerScript_Exists(null); + } + + public void setHandlerScript_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("handlerScript"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerScript_Missing() { + setHandlerScript_Missing(null); + } + + public void setHandlerScript_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("handlerScript"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerScript_GreaterThan(String handlerScript) { + setHandlerScript_GreaterThan(handlerScript, null); + } + + public void setHandlerScript_GreaterThan(String handlerScript, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerScript", ConditionKey.CK_GREATER_THAN, handlerScript); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerScript_LessThan(String handlerScript) { + setHandlerScript_LessThan(handlerScript, null); + } + + public void setHandlerScript_LessThan(String handlerScript, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerScript", ConditionKey.CK_LESS_THAN, handlerScript); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerScript_GreaterEqual(String handlerScript) { + setHandlerScript_GreaterEqual(handlerScript, null); + } + + public void setHandlerScript_GreaterEqual(String handlerScript, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerScript", ConditionKey.CK_GREATER_EQUAL, handlerScript); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHandlerScript_LessEqual(String handlerScript) { + setHandlerScript_LessEqual(handlerScript, null); + } + + public void setHandlerScript_LessEqual(String handlerScript, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("handlerScript", ConditionKey.CK_LESS_EQUAL, handlerScript); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Term(String name) { + setName_Term(name, null); + } + + public void setName_Term(String name, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Terms(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("name", nameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_InScope(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { + setName_Terms(nameList, opLambda); + } + + public void setName_Prefix(String name) { + setName_Prefix(name, null); + } + + public void setName_Prefix(String name, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Exists() { + setName_Exists(null); + } + + public void setName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Missing() { + setName_Missing(null); + } + + public void setName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterThan(String name) { + setName_GreaterThan(name, null); + } + + public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessThan(String name) { + setName_LessThan(name, null); + } + + public void setName_LessThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterEqual(String name) { + setName_GreaterEqual(name, null); + } + + public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessEqual(String name) { + setName_LessEqual(name, null); + } + + public void setName_LessEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Term(Integer sortOrder) { + setSortOrder_Term(sortOrder, null); + } + + public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("sortOrder", sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Terms(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_InScope(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { + setSortOrder_Terms(sortOrderList, opLambda); + } + + public void setSortOrder_Exists() { + setSortOrder_Exists(null); + } + + public void setSortOrder_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Missing() { + setSortOrder_Missing(null); + } + + public void setSortOrder_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterThan(Integer sortOrder) { + setSortOrder_GreaterThan(sortOrder, null); + } + + public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessThan(Integer sortOrder) { + setSortOrder_LessThan(sortOrder, null); + } + + public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterEqual(Integer sortOrder) { + setSortOrder_GreaterEqual(sortOrder, null); + } + + public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessEqual(Integer sortOrder) { + setSortOrder_LessEqual(sortOrder, null); + } + + public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigToLabelCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigToLabelCF.java new file mode 100644 index 000000000..34501c728 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigToLabelCF.java @@ -0,0 +1,430 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.DataConfigToLabelCF; +import org.codelibs.fess.es.cbean.cq.DataConfigToLabelCQ; +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 BsDataConfigToLabelCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + DataConfigToLabelCF mustFilter = new DataConfigToLabelCF(); + DataConfigToLabelCF shouldFilter = new DataConfigToLabelCF(); + DataConfigToLabelCF mustNotFilter = new DataConfigToLabelCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + DataConfigToLabelCF andFilter = new DataConfigToLabelCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + DataConfigToLabelCF orFilter = new DataConfigToLabelCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + DataConfigToLabelCF notFilter = new DataConfigToLabelCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + DataConfigToLabelCQ query = new DataConfigToLabelCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setDataConfigId_Term(String dataConfigId) { + setDataConfigId_Term(dataConfigId, null); + } + + public void setDataConfigId_Term(String dataConfigId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("dataConfigId", dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_Terms(Collection dataConfigIdList) { + setDataConfigId_Terms(dataConfigIdList, null); + } + + public void setDataConfigId_Terms(Collection dataConfigIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("dataConfigId", dataConfigIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_InScope(Collection dataConfigIdList) { + setDataConfigId_Terms(dataConfigIdList, null); + } + + public void setDataConfigId_InScope(Collection dataConfigIdList, ConditionOptionCall opLambda) { + setDataConfigId_Terms(dataConfigIdList, opLambda); + } + + public void setDataConfigId_Prefix(String dataConfigId) { + setDataConfigId_Prefix(dataConfigId, null); + } + + public void setDataConfigId_Prefix(String dataConfigId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("dataConfigId", dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_Exists() { + setDataConfigId_Exists(null); + } + + public void setDataConfigId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("dataConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_Missing() { + setDataConfigId_Missing(null); + } + + public void setDataConfigId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("dataConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_GreaterThan(String dataConfigId) { + setDataConfigId_GreaterThan(dataConfigId, null); + } + + public void setDataConfigId_GreaterThan(String dataConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_LessThan(String dataConfigId) { + setDataConfigId_LessThan(dataConfigId, null); + } + + public void setDataConfigId_LessThan(String dataConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_GreaterEqual(String dataConfigId) { + setDataConfigId_GreaterEqual(dataConfigId, null); + } + + public void setDataConfigId_GreaterEqual(String dataConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_LessEqual(String dataConfigId) { + setDataConfigId_LessEqual(dataConfigId, null); + } + + public void setDataConfigId_LessEqual(String dataConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Term(String labelTypeId) { + setLabelTypeId_Term(labelTypeId, null); + } + + public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("labelTypeId", labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Terms(Collection labelTypeIdList) { + setLabelTypeId_Terms(labelTypeIdList, null); + } + + public void setLabelTypeId_Terms(Collection labelTypeIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("labelTypeId", labelTypeIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_InScope(Collection labelTypeIdList) { + setLabelTypeId_Terms(labelTypeIdList, null); + } + + public void setLabelTypeId_InScope(Collection labelTypeIdList, ConditionOptionCall opLambda) { + setLabelTypeId_Terms(labelTypeIdList, opLambda); + } + + public void setLabelTypeId_Prefix(String labelTypeId) { + setLabelTypeId_Prefix(labelTypeId, null); + } + + public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("labelTypeId", labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Exists() { + setLabelTypeId_Exists(null); + } + + public void setLabelTypeId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("labelTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Missing() { + setLabelTypeId_Missing(null); + } + + public void setLabelTypeId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("labelTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_GreaterThan(String labelTypeId) { + setLabelTypeId_GreaterThan(labelTypeId, null); + } + + public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_LessThan(String labelTypeId) { + setLabelTypeId_LessThan(labelTypeId, null); + } + + public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_GreaterEqual(String labelTypeId) { + setLabelTypeId_GreaterEqual(labelTypeId, null); + } + + public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_LessEqual(String labelTypeId) { + setLabelTypeId_LessEqual(labelTypeId, null); + } + + public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigToRoleCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigToRoleCF.java new file mode 100644 index 000000000..d2e2863cc --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsDataConfigToRoleCF.java @@ -0,0 +1,430 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.DataConfigToRoleCF; +import org.codelibs.fess.es.cbean.cq.DataConfigToRoleCQ; +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 BsDataConfigToRoleCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + DataConfigToRoleCF mustFilter = new DataConfigToRoleCF(); + DataConfigToRoleCF shouldFilter = new DataConfigToRoleCF(); + DataConfigToRoleCF mustNotFilter = new DataConfigToRoleCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + DataConfigToRoleCF andFilter = new DataConfigToRoleCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + DataConfigToRoleCF orFilter = new DataConfigToRoleCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + DataConfigToRoleCF notFilter = new DataConfigToRoleCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + DataConfigToRoleCQ query = new DataConfigToRoleCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setDataConfigId_Term(String dataConfigId) { + setDataConfigId_Term(dataConfigId, null); + } + + public void setDataConfigId_Term(String dataConfigId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("dataConfigId", dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_Terms(Collection dataConfigIdList) { + setDataConfigId_Terms(dataConfigIdList, null); + } + + public void setDataConfigId_Terms(Collection dataConfigIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("dataConfigId", dataConfigIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_InScope(Collection dataConfigIdList) { + setDataConfigId_Terms(dataConfigIdList, null); + } + + public void setDataConfigId_InScope(Collection dataConfigIdList, ConditionOptionCall opLambda) { + setDataConfigId_Terms(dataConfigIdList, opLambda); + } + + public void setDataConfigId_Prefix(String dataConfigId) { + setDataConfigId_Prefix(dataConfigId, null); + } + + public void setDataConfigId_Prefix(String dataConfigId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("dataConfigId", dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_Exists() { + setDataConfigId_Exists(null); + } + + public void setDataConfigId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("dataConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_Missing() { + setDataConfigId_Missing(null); + } + + public void setDataConfigId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("dataConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_GreaterThan(String dataConfigId) { + setDataConfigId_GreaterThan(dataConfigId, null); + } + + public void setDataConfigId_GreaterThan(String dataConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_LessThan(String dataConfigId) { + setDataConfigId_LessThan(dataConfigId, null); + } + + public void setDataConfigId_LessThan(String dataConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_GreaterEqual(String dataConfigId) { + setDataConfigId_GreaterEqual(dataConfigId, null); + } + + public void setDataConfigId_GreaterEqual(String dataConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDataConfigId_LessEqual(String dataConfigId) { + setDataConfigId_LessEqual(dataConfigId, null); + } + + public void setDataConfigId_LessEqual(String dataConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Term(String roleTypeId) { + setRoleTypeId_Term(roleTypeId, null); + } + + public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("roleTypeId", roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Terms(Collection roleTypeIdList) { + setRoleTypeId_Terms(roleTypeIdList, null); + } + + public void setRoleTypeId_Terms(Collection roleTypeIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("roleTypeId", roleTypeIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_InScope(Collection roleTypeIdList) { + setRoleTypeId_Terms(roleTypeIdList, null); + } + + public void setRoleTypeId_InScope(Collection roleTypeIdList, ConditionOptionCall opLambda) { + setRoleTypeId_Terms(roleTypeIdList, opLambda); + } + + public void setRoleTypeId_Prefix(String roleTypeId) { + setRoleTypeId_Prefix(roleTypeId, null); + } + + public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("roleTypeId", roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Exists() { + setRoleTypeId_Exists(null); + } + + public void setRoleTypeId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("roleTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Missing() { + setRoleTypeId_Missing(null); + } + + public void setRoleTypeId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("roleTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_GreaterThan(String roleTypeId) { + setRoleTypeId_GreaterThan(roleTypeId, null); + } + + public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_LessThan(String roleTypeId) { + setRoleTypeId_LessThan(roleTypeId, null); + } + + public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_GreaterEqual(String roleTypeId) { + setRoleTypeId_GreaterEqual(roleTypeId, null); + } + + public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_LessEqual(String roleTypeId) { + setRoleTypeId_LessEqual(roleTypeId, null); + } + + public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFailureUrlCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFailureUrlCF.java new file mode 100644 index 000000000..25d8ed628 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFailureUrlCF.java @@ -0,0 +1,943 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.FailureUrlCF; +import org.codelibs.fess.es.cbean.cq.FailureUrlCQ; +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 BsFailureUrlCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + FailureUrlCF mustFilter = new FailureUrlCF(); + FailureUrlCF shouldFilter = new FailureUrlCF(); + FailureUrlCF mustNotFilter = new FailureUrlCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + FailureUrlCF andFilter = new FailureUrlCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + FailureUrlCF orFilter = new FailureUrlCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + FailureUrlCF notFilter = new FailureUrlCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + FailureUrlCQ query = new FailureUrlCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setConfigId_Term(String configId) { + setConfigId_Term(configId, null); + } + + public void setConfigId_Term(String configId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("configId", configId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigId_Terms(Collection configIdList) { + setConfigId_Terms(configIdList, null); + } + + public void setConfigId_Terms(Collection configIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("configId", configIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigId_InScope(Collection configIdList) { + setConfigId_Terms(configIdList, null); + } + + public void setConfigId_InScope(Collection configIdList, ConditionOptionCall opLambda) { + setConfigId_Terms(configIdList, opLambda); + } + + public void setConfigId_Prefix(String configId) { + setConfigId_Prefix(configId, null); + } + + public void setConfigId_Prefix(String configId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("configId", configId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigId_Exists() { + setConfigId_Exists(null); + } + + public void setConfigId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("configId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigId_Missing() { + setConfigId_Missing(null); + } + + public void setConfigId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("configId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigId_GreaterThan(String configId) { + setConfigId_GreaterThan(configId, null); + } + + public void setConfigId_GreaterThan(String configId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configId", ConditionKey.CK_GREATER_THAN, configId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigId_LessThan(String configId) { + setConfigId_LessThan(configId, null); + } + + public void setConfigId_LessThan(String configId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configId", ConditionKey.CK_LESS_THAN, configId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigId_GreaterEqual(String configId) { + setConfigId_GreaterEqual(configId, null); + } + + public void setConfigId_GreaterEqual(String configId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configId", ConditionKey.CK_GREATER_EQUAL, configId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigId_LessEqual(String configId) { + setConfigId_LessEqual(configId, null); + } + + public void setConfigId_LessEqual(String configId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configId", ConditionKey.CK_LESS_EQUAL, configId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorCount_Term(Integer errorCount) { + setErrorCount_Term(errorCount, null); + } + + public void setErrorCount_Term(Integer errorCount, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("errorCount", errorCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorCount_Terms(Collection errorCountList) { + setErrorCount_Terms(errorCountList, null); + } + + public void setErrorCount_Terms(Collection errorCountList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("errorCount", errorCountList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorCount_InScope(Collection errorCountList) { + setErrorCount_Terms(errorCountList, null); + } + + public void setErrorCount_InScope(Collection errorCountList, ConditionOptionCall opLambda) { + setErrorCount_Terms(errorCountList, opLambda); + } + + public void setErrorCount_Exists() { + setErrorCount_Exists(null); + } + + public void setErrorCount_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("errorCount"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorCount_Missing() { + setErrorCount_Missing(null); + } + + public void setErrorCount_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("errorCount"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorCount_GreaterThan(Integer errorCount) { + setErrorCount_GreaterThan(errorCount, null); + } + + public void setErrorCount_GreaterThan(Integer errorCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorCount", ConditionKey.CK_GREATER_THAN, errorCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorCount_LessThan(Integer errorCount) { + setErrorCount_LessThan(errorCount, null); + } + + public void setErrorCount_LessThan(Integer errorCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorCount", ConditionKey.CK_LESS_THAN, errorCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorCount_GreaterEqual(Integer errorCount) { + setErrorCount_GreaterEqual(errorCount, null); + } + + public void setErrorCount_GreaterEqual(Integer errorCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorCount", ConditionKey.CK_GREATER_EQUAL, errorCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorCount_LessEqual(Integer errorCount) { + setErrorCount_LessEqual(errorCount, null); + } + + public void setErrorCount_LessEqual(Integer errorCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorCount", ConditionKey.CK_LESS_EQUAL, errorCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorLog_Term(String errorLog) { + setErrorLog_Term(errorLog, null); + } + + public void setErrorLog_Term(String errorLog, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("errorLog", errorLog); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorLog_Terms(Collection errorLogList) { + setErrorLog_Terms(errorLogList, null); + } + + public void setErrorLog_Terms(Collection errorLogList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("errorLog", errorLogList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorLog_InScope(Collection errorLogList) { + setErrorLog_Terms(errorLogList, null); + } + + public void setErrorLog_InScope(Collection errorLogList, ConditionOptionCall opLambda) { + setErrorLog_Terms(errorLogList, opLambda); + } + + public void setErrorLog_Prefix(String errorLog) { + setErrorLog_Prefix(errorLog, null); + } + + public void setErrorLog_Prefix(String errorLog, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("errorLog", errorLog); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorLog_Exists() { + setErrorLog_Exists(null); + } + + public void setErrorLog_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("errorLog"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorLog_Missing() { + setErrorLog_Missing(null); + } + + public void setErrorLog_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("errorLog"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorLog_GreaterThan(String errorLog) { + setErrorLog_GreaterThan(errorLog, null); + } + + public void setErrorLog_GreaterThan(String errorLog, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorLog", ConditionKey.CK_GREATER_THAN, errorLog); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorLog_LessThan(String errorLog) { + setErrorLog_LessThan(errorLog, null); + } + + public void setErrorLog_LessThan(String errorLog, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorLog", ConditionKey.CK_LESS_THAN, errorLog); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorLog_GreaterEqual(String errorLog) { + setErrorLog_GreaterEqual(errorLog, null); + } + + public void setErrorLog_GreaterEqual(String errorLog, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorLog", ConditionKey.CK_GREATER_EQUAL, errorLog); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorLog_LessEqual(String errorLog) { + setErrorLog_LessEqual(errorLog, null); + } + + public void setErrorLog_LessEqual(String errorLog, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorLog", ConditionKey.CK_LESS_EQUAL, errorLog); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorName_Term(String errorName) { + setErrorName_Term(errorName, null); + } + + public void setErrorName_Term(String errorName, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("errorName", errorName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorName_Terms(Collection errorNameList) { + setErrorName_Terms(errorNameList, null); + } + + public void setErrorName_Terms(Collection errorNameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("errorName", errorNameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorName_InScope(Collection errorNameList) { + setErrorName_Terms(errorNameList, null); + } + + public void setErrorName_InScope(Collection errorNameList, ConditionOptionCall opLambda) { + setErrorName_Terms(errorNameList, opLambda); + } + + public void setErrorName_Prefix(String errorName) { + setErrorName_Prefix(errorName, null); + } + + public void setErrorName_Prefix(String errorName, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("errorName", errorName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorName_Exists() { + setErrorName_Exists(null); + } + + public void setErrorName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("errorName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorName_Missing() { + setErrorName_Missing(null); + } + + public void setErrorName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("errorName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorName_GreaterThan(String errorName) { + setErrorName_GreaterThan(errorName, null); + } + + public void setErrorName_GreaterThan(String errorName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorName", ConditionKey.CK_GREATER_THAN, errorName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorName_LessThan(String errorName) { + setErrorName_LessThan(errorName, null); + } + + public void setErrorName_LessThan(String errorName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorName", ConditionKey.CK_LESS_THAN, errorName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorName_GreaterEqual(String errorName) { + setErrorName_GreaterEqual(errorName, null); + } + + public void setErrorName_GreaterEqual(String errorName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorName", ConditionKey.CK_GREATER_EQUAL, errorName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setErrorName_LessEqual(String errorName) { + setErrorName_LessEqual(errorName, null); + } + + public void setErrorName_LessEqual(String errorName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("errorName", ConditionKey.CK_LESS_EQUAL, errorName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLastAccessTime_Term(Long lastAccessTime) { + setLastAccessTime_Term(lastAccessTime, null); + } + + public void setLastAccessTime_Term(Long lastAccessTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("lastAccessTime", lastAccessTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLastAccessTime_Terms(Collection lastAccessTimeList) { + setLastAccessTime_Terms(lastAccessTimeList, null); + } + + public void setLastAccessTime_Terms(Collection lastAccessTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("lastAccessTime", lastAccessTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLastAccessTime_InScope(Collection lastAccessTimeList) { + setLastAccessTime_Terms(lastAccessTimeList, null); + } + + public void setLastAccessTime_InScope(Collection lastAccessTimeList, ConditionOptionCall opLambda) { + setLastAccessTime_Terms(lastAccessTimeList, opLambda); + } + + public void setLastAccessTime_Exists() { + setLastAccessTime_Exists(null); + } + + public void setLastAccessTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("lastAccessTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLastAccessTime_Missing() { + setLastAccessTime_Missing(null); + } + + public void setLastAccessTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("lastAccessTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLastAccessTime_GreaterThan(Long lastAccessTime) { + setLastAccessTime_GreaterThan(lastAccessTime, null); + } + + public void setLastAccessTime_GreaterThan(Long lastAccessTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("lastAccessTime", ConditionKey.CK_GREATER_THAN, lastAccessTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLastAccessTime_LessThan(Long lastAccessTime) { + setLastAccessTime_LessThan(lastAccessTime, null); + } + + public void setLastAccessTime_LessThan(Long lastAccessTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("lastAccessTime", ConditionKey.CK_LESS_THAN, lastAccessTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLastAccessTime_GreaterEqual(Long lastAccessTime) { + setLastAccessTime_GreaterEqual(lastAccessTime, null); + } + + public void setLastAccessTime_GreaterEqual(Long lastAccessTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("lastAccessTime", ConditionKey.CK_GREATER_EQUAL, lastAccessTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLastAccessTime_LessEqual(Long lastAccessTime) { + setLastAccessTime_LessEqual(lastAccessTime, null); + } + + public void setLastAccessTime_LessEqual(Long lastAccessTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("lastAccessTime", ConditionKey.CK_LESS_EQUAL, lastAccessTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setThreadName_Term(String threadName) { + setThreadName_Term(threadName, null); + } + + public void setThreadName_Term(String threadName, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("threadName", threadName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setThreadName_Terms(Collection threadNameList) { + setThreadName_Terms(threadNameList, null); + } + + public void setThreadName_Terms(Collection threadNameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("threadName", threadNameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setThreadName_InScope(Collection threadNameList) { + setThreadName_Terms(threadNameList, null); + } + + public void setThreadName_InScope(Collection threadNameList, ConditionOptionCall opLambda) { + setThreadName_Terms(threadNameList, opLambda); + } + + public void setThreadName_Prefix(String threadName) { + setThreadName_Prefix(threadName, null); + } + + public void setThreadName_Prefix(String threadName, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("threadName", threadName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setThreadName_Exists() { + setThreadName_Exists(null); + } + + public void setThreadName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("threadName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setThreadName_Missing() { + setThreadName_Missing(null); + } + + public void setThreadName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("threadName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setThreadName_GreaterThan(String threadName) { + setThreadName_GreaterThan(threadName, null); + } + + public void setThreadName_GreaterThan(String threadName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("threadName", ConditionKey.CK_GREATER_THAN, threadName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setThreadName_LessThan(String threadName) { + setThreadName_LessThan(threadName, null); + } + + public void setThreadName_LessThan(String threadName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("threadName", ConditionKey.CK_LESS_THAN, threadName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setThreadName_GreaterEqual(String threadName) { + setThreadName_GreaterEqual(threadName, null); + } + + public void setThreadName_GreaterEqual(String threadName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("threadName", ConditionKey.CK_GREATER_EQUAL, threadName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setThreadName_LessEqual(String threadName) { + setThreadName_LessEqual(threadName, null); + } + + public void setThreadName_LessEqual(String threadName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("threadName", ConditionKey.CK_LESS_EQUAL, threadName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Term(String url) { + setUrl_Term(url, null); + } + + public void setUrl_Term(String url, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("url", url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Terms(Collection urlList) { + setUrl_Terms(urlList, null); + } + + public void setUrl_Terms(Collection urlList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("url", urlList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_InScope(Collection urlList) { + setUrl_Terms(urlList, null); + } + + public void setUrl_InScope(Collection urlList, ConditionOptionCall opLambda) { + setUrl_Terms(urlList, opLambda); + } + + public void setUrl_Prefix(String url) { + setUrl_Prefix(url, null); + } + + public void setUrl_Prefix(String url, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("url", url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Exists() { + setUrl_Exists(null); + } + + public void setUrl_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("url"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Missing() { + setUrl_Missing(null); + } + + public void setUrl_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("url"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_GreaterThan(String url) { + setUrl_GreaterThan(url, null); + } + + public void setUrl_GreaterThan(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_THAN, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_LessThan(String url) { + setUrl_LessThan(url, null); + } + + public void setUrl_LessThan(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_THAN, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_GreaterEqual(String url) { + setUrl_GreaterEqual(url, null); + } + + public void setUrl_GreaterEqual(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_EQUAL, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_LessEqual(String url) { + setUrl_LessEqual(url, null); + } + + public void setUrl_LessEqual(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_EQUAL, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFavoriteLogCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFavoriteLogCF.java new file mode 100644 index 000000000..af4f0098d --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFavoriteLogCF.java @@ -0,0 +1,526 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.FavoriteLogCF; +import org.codelibs.fess.es.cbean.cq.FavoriteLogCQ; +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 BsFavoriteLogCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + FavoriteLogCF mustFilter = new FavoriteLogCF(); + FavoriteLogCF shouldFilter = new FavoriteLogCF(); + FavoriteLogCF mustNotFilter = new FavoriteLogCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + FavoriteLogCF andFilter = new FavoriteLogCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + FavoriteLogCF orFilter = new FavoriteLogCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + FavoriteLogCF notFilter = new FavoriteLogCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + FavoriteLogCQ query = new FavoriteLogCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Term(String url) { + setUrl_Term(url, null); + } + + public void setUrl_Term(String url, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("url", url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Terms(Collection urlList) { + setUrl_Terms(urlList, null); + } + + public void setUrl_Terms(Collection urlList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("url", urlList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_InScope(Collection urlList) { + setUrl_Terms(urlList, null); + } + + public void setUrl_InScope(Collection urlList, ConditionOptionCall opLambda) { + setUrl_Terms(urlList, opLambda); + } + + public void setUrl_Prefix(String url) { + setUrl_Prefix(url, null); + } + + public void setUrl_Prefix(String url, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("url", url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Exists() { + setUrl_Exists(null); + } + + public void setUrl_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("url"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_Missing() { + setUrl_Missing(null); + } + + public void setUrl_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("url"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_GreaterThan(String url) { + setUrl_GreaterThan(url, null); + } + + public void setUrl_GreaterThan(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_THAN, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_LessThan(String url) { + setUrl_LessThan(url, null); + } + + public void setUrl_LessThan(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_THAN, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_GreaterEqual(String url) { + setUrl_GreaterEqual(url, null); + } + + public void setUrl_GreaterEqual(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_GREATER_EQUAL, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrl_LessEqual(String url) { + setUrl_LessEqual(url, null); + } + + public void setUrl_LessEqual(String url, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("url", ConditionKey.CK_LESS_EQUAL, url); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserInfoId_Term(String userInfoId) { + setUserInfoId_Term(userInfoId, null); + } + + public void setUserInfoId_Term(String userInfoId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("userInfoId", userInfoId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserInfoId_Terms(Collection userInfoIdList) { + setUserInfoId_Terms(userInfoIdList, null); + } + + public void setUserInfoId_Terms(Collection userInfoIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("userInfoId", userInfoIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserInfoId_InScope(Collection userInfoIdList) { + setUserInfoId_Terms(userInfoIdList, null); + } + + public void setUserInfoId_InScope(Collection userInfoIdList, ConditionOptionCall opLambda) { + setUserInfoId_Terms(userInfoIdList, opLambda); + } + + public void setUserInfoId_Prefix(String userInfoId) { + setUserInfoId_Prefix(userInfoId, null); + } + + public void setUserInfoId_Prefix(String userInfoId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("userInfoId", userInfoId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserInfoId_Exists() { + setUserInfoId_Exists(null); + } + + public void setUserInfoId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("userInfoId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserInfoId_Missing() { + setUserInfoId_Missing(null); + } + + public void setUserInfoId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("userInfoId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserInfoId_GreaterThan(String userInfoId) { + setUserInfoId_GreaterThan(userInfoId, null); + } + + public void setUserInfoId_GreaterThan(String userInfoId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userInfoId", ConditionKey.CK_GREATER_THAN, userInfoId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserInfoId_LessThan(String userInfoId) { + setUserInfoId_LessThan(userInfoId, null); + } + + public void setUserInfoId_LessThan(String userInfoId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userInfoId", ConditionKey.CK_LESS_THAN, userInfoId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserInfoId_GreaterEqual(String userInfoId) { + setUserInfoId_GreaterEqual(userInfoId, null); + } + + public void setUserInfoId_GreaterEqual(String userInfoId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userInfoId", ConditionKey.CK_GREATER_EQUAL, userInfoId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserInfoId_LessEqual(String userInfoId) { + setUserInfoId_LessEqual(userInfoId, null); + } + + public void setUserInfoId_LessEqual(String userInfoId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userInfoId", ConditionKey.CK_LESS_EQUAL, userInfoId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileAuthenticationCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileAuthenticationCF.java new file mode 100644 index 000000000..f55f94779 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileAuthenticationCF.java @@ -0,0 +1,1360 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.FileAuthenticationCF; +import org.codelibs.fess.es.cbean.cq.FileAuthenticationCQ; +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 BsFileAuthenticationCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + FileAuthenticationCF mustFilter = new FileAuthenticationCF(); + FileAuthenticationCF shouldFilter = new FileAuthenticationCF(); + FileAuthenticationCF mustNotFilter = new FileAuthenticationCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + FileAuthenticationCF andFilter = new FileAuthenticationCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + FileAuthenticationCF orFilter = new FileAuthenticationCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + FileAuthenticationCF notFilter = new FileAuthenticationCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + FileAuthenticationCQ query = new FileAuthenticationCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_Term(String fileConfigId) { + setFileConfigId_Term(fileConfigId, null); + } + + public void setFileConfigId_Term(String fileConfigId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("fileConfigId", fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_Terms(Collection fileConfigIdList) { + setFileConfigId_Terms(fileConfigIdList, null); + } + + public void setFileConfigId_Terms(Collection fileConfigIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("fileConfigId", fileConfigIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_InScope(Collection fileConfigIdList) { + setFileConfigId_Terms(fileConfigIdList, null); + } + + public void setFileConfigId_InScope(Collection fileConfigIdList, ConditionOptionCall opLambda) { + setFileConfigId_Terms(fileConfigIdList, opLambda); + } + + public void setFileConfigId_Prefix(String fileConfigId) { + setFileConfigId_Prefix(fileConfigId, null); + } + + public void setFileConfigId_Prefix(String fileConfigId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("fileConfigId", fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_Exists() { + setFileConfigId_Exists(null); + } + + public void setFileConfigId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("fileConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_Missing() { + setFileConfigId_Missing(null); + } + + public void setFileConfigId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("fileConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_GreaterThan(String fileConfigId) { + setFileConfigId_GreaterThan(fileConfigId, null); + } + + public void setFileConfigId_GreaterThan(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_LessThan(String fileConfigId) { + setFileConfigId_LessThan(fileConfigId, null); + } + + public void setFileConfigId_LessThan(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_GreaterEqual(String fileConfigId) { + setFileConfigId_GreaterEqual(fileConfigId, null); + } + + public void setFileConfigId_GreaterEqual(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_LessEqual(String fileConfigId) { + setFileConfigId_LessEqual(fileConfigId, null); + } + + public void setFileConfigId_LessEqual(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_Term(String hostname) { + setHostname_Term(hostname, null); + } + + public void setHostname_Term(String hostname, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("hostname", hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_Terms(Collection hostnameList) { + setHostname_Terms(hostnameList, null); + } + + public void setHostname_Terms(Collection hostnameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("hostname", hostnameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_InScope(Collection hostnameList) { + setHostname_Terms(hostnameList, null); + } + + public void setHostname_InScope(Collection hostnameList, ConditionOptionCall opLambda) { + setHostname_Terms(hostnameList, opLambda); + } + + public void setHostname_Prefix(String hostname) { + setHostname_Prefix(hostname, null); + } + + public void setHostname_Prefix(String hostname, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("hostname", hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_Exists() { + setHostname_Exists(null); + } + + public void setHostname_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("hostname"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_Missing() { + setHostname_Missing(null); + } + + public void setHostname_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("hostname"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_GreaterThan(String hostname) { + setHostname_GreaterThan(hostname, null); + } + + public void setHostname_GreaterThan(String hostname, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_GREATER_THAN, hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_LessThan(String hostname) { + setHostname_LessThan(hostname, null); + } + + public void setHostname_LessThan(String hostname, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_LESS_THAN, hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_GreaterEqual(String hostname) { + setHostname_GreaterEqual(hostname, null); + } + + public void setHostname_GreaterEqual(String hostname, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_GREATER_EQUAL, hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_LessEqual(String hostname) { + setHostname_LessEqual(hostname, null); + } + + public void setHostname_LessEqual(String hostname, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_LESS_EQUAL, hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_Term(String parameters) { + setParameters_Term(parameters, null); + } + + public void setParameters_Term(String parameters, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("parameters", parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_Terms(Collection parametersList) { + setParameters_Terms(parametersList, null); + } + + public void setParameters_Terms(Collection parametersList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("parameters", parametersList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_InScope(Collection parametersList) { + setParameters_Terms(parametersList, null); + } + + public void setParameters_InScope(Collection parametersList, ConditionOptionCall opLambda) { + setParameters_Terms(parametersList, opLambda); + } + + public void setParameters_Prefix(String parameters) { + setParameters_Prefix(parameters, null); + } + + public void setParameters_Prefix(String parameters, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("parameters", parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_Exists() { + setParameters_Exists(null); + } + + public void setParameters_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("parameters"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_Missing() { + setParameters_Missing(null); + } + + public void setParameters_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("parameters"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_GreaterThan(String parameters) { + setParameters_GreaterThan(parameters, null); + } + + public void setParameters_GreaterThan(String parameters, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_GREATER_THAN, parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_LessThan(String parameters) { + setParameters_LessThan(parameters, null); + } + + public void setParameters_LessThan(String parameters, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_LESS_THAN, parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_GreaterEqual(String parameters) { + setParameters_GreaterEqual(parameters, null); + } + + public void setParameters_GreaterEqual(String parameters, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_GREATER_EQUAL, parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_LessEqual(String parameters) { + setParameters_LessEqual(parameters, null); + } + + public void setParameters_LessEqual(String parameters, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_LESS_EQUAL, parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_Term(String password) { + setPassword_Term(password, null); + } + + public void setPassword_Term(String password, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("password", password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_Terms(Collection passwordList) { + setPassword_Terms(passwordList, null); + } + + public void setPassword_Terms(Collection passwordList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("password", passwordList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_InScope(Collection passwordList) { + setPassword_Terms(passwordList, null); + } + + public void setPassword_InScope(Collection passwordList, ConditionOptionCall opLambda) { + setPassword_Terms(passwordList, opLambda); + } + + public void setPassword_Prefix(String password) { + setPassword_Prefix(password, null); + } + + public void setPassword_Prefix(String password, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("password", password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_Exists() { + setPassword_Exists(null); + } + + public void setPassword_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("password"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_Missing() { + setPassword_Missing(null); + } + + public void setPassword_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("password"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_GreaterThan(String password) { + setPassword_GreaterThan(password, null); + } + + public void setPassword_GreaterThan(String password, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_GREATER_THAN, password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_LessThan(String password) { + setPassword_LessThan(password, null); + } + + public void setPassword_LessThan(String password, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_LESS_THAN, password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_GreaterEqual(String password) { + setPassword_GreaterEqual(password, null); + } + + public void setPassword_GreaterEqual(String password, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_GREATER_EQUAL, password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_LessEqual(String password) { + setPassword_LessEqual(password, null); + } + + public void setPassword_LessEqual(String password, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_LESS_EQUAL, password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_Term(Integer port) { + setPort_Term(port, null); + } + + public void setPort_Term(Integer port, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("port", port); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_Terms(Collection portList) { + setPort_Terms(portList, null); + } + + public void setPort_Terms(Collection portList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("port", portList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_InScope(Collection portList) { + setPort_Terms(portList, null); + } + + public void setPort_InScope(Collection portList, ConditionOptionCall opLambda) { + setPort_Terms(portList, opLambda); + } + + public void setPort_Exists() { + setPort_Exists(null); + } + + public void setPort_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("port"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_Missing() { + setPort_Missing(null); + } + + public void setPort_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("port"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_GreaterThan(Integer port) { + setPort_GreaterThan(port, null); + } + + public void setPort_GreaterThan(Integer port, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_GREATER_THAN, port); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_LessThan(Integer port) { + setPort_LessThan(port, null); + } + + public void setPort_LessThan(Integer port, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_LESS_THAN, port); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_GreaterEqual(Integer port) { + setPort_GreaterEqual(port, null); + } + + public void setPort_GreaterEqual(Integer port, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_GREATER_EQUAL, port); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_LessEqual(Integer port) { + setPort_LessEqual(port, null); + } + + public void setPort_LessEqual(Integer port, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_LESS_EQUAL, port); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_Term(String protocolScheme) { + setProtocolScheme_Term(protocolScheme, null); + } + + public void setProtocolScheme_Term(String protocolScheme, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("protocolScheme", protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_Terms(Collection protocolSchemeList) { + setProtocolScheme_Terms(protocolSchemeList, null); + } + + public void setProtocolScheme_Terms(Collection protocolSchemeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("protocolScheme", protocolSchemeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_InScope(Collection protocolSchemeList) { + setProtocolScheme_Terms(protocolSchemeList, null); + } + + public void setProtocolScheme_InScope(Collection protocolSchemeList, ConditionOptionCall opLambda) { + setProtocolScheme_Terms(protocolSchemeList, opLambda); + } + + public void setProtocolScheme_Prefix(String protocolScheme) { + setProtocolScheme_Prefix(protocolScheme, null); + } + + public void setProtocolScheme_Prefix(String protocolScheme, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("protocolScheme", protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_Exists() { + setProtocolScheme_Exists(null); + } + + public void setProtocolScheme_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("protocolScheme"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_Missing() { + setProtocolScheme_Missing(null); + } + + public void setProtocolScheme_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("protocolScheme"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_GreaterThan(String protocolScheme) { + setProtocolScheme_GreaterThan(protocolScheme, null); + } + + public void setProtocolScheme_GreaterThan(String protocolScheme, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_GREATER_THAN, protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_LessThan(String protocolScheme) { + setProtocolScheme_LessThan(protocolScheme, null); + } + + public void setProtocolScheme_LessThan(String protocolScheme, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_LESS_THAN, protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_GreaterEqual(String protocolScheme) { + setProtocolScheme_GreaterEqual(protocolScheme, null); + } + + public void setProtocolScheme_GreaterEqual(String protocolScheme, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_GREATER_EQUAL, protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_LessEqual(String protocolScheme) { + setProtocolScheme_LessEqual(protocolScheme, null); + } + + public void setProtocolScheme_LessEqual(String protocolScheme, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_LESS_EQUAL, protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_Term(String username) { + setUsername_Term(username, null); + } + + public void setUsername_Term(String username, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("username", username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_Terms(Collection usernameList) { + setUsername_Terms(usernameList, null); + } + + public void setUsername_Terms(Collection usernameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("username", usernameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_InScope(Collection usernameList) { + setUsername_Terms(usernameList, null); + } + + public void setUsername_InScope(Collection usernameList, ConditionOptionCall opLambda) { + setUsername_Terms(usernameList, opLambda); + } + + public void setUsername_Prefix(String username) { + setUsername_Prefix(username, null); + } + + public void setUsername_Prefix(String username, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("username", username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_Exists() { + setUsername_Exists(null); + } + + public void setUsername_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("username"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_Missing() { + setUsername_Missing(null); + } + + public void setUsername_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("username"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_GreaterThan(String username) { + setUsername_GreaterThan(username, null); + } + + public void setUsername_GreaterThan(String username, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_GREATER_THAN, username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_LessThan(String username) { + setUsername_LessThan(username, null); + } + + public void setUsername_LessThan(String username, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_LESS_THAN, username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_GreaterEqual(String username) { + setUsername_GreaterEqual(username, null); + } + + public void setUsername_GreaterEqual(String username, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_GREATER_EQUAL, username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_LessEqual(String username) { + setUsername_LessEqual(username, null); + } + + public void setUsername_LessEqual(String username, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_LESS_EQUAL, username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigCF.java new file mode 100644 index 000000000..681cac876 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigCF.java @@ -0,0 +1,2043 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.FileConfigCF; +import org.codelibs.fess.es.cbean.cq.FileConfigCQ; +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 BsFileConfigCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + FileConfigCF mustFilter = new FileConfigCF(); + FileConfigCF shouldFilter = new FileConfigCF(); + FileConfigCF mustNotFilter = new FileConfigCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + FileConfigCF andFilter = new FileConfigCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + FileConfigCF orFilter = new FileConfigCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + FileConfigCF notFilter = new FileConfigCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + FileConfigCQ query = new FileConfigCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setAvailable_Term(Boolean available) { + setAvailable_Term(available, null); + } + + public void setAvailable_Term(Boolean available, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("available", available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_Terms(Collection availableList) { + setAvailable_Terms(availableList, null); + } + + public void setAvailable_Terms(Collection availableList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("available", availableList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_InScope(Collection availableList) { + setAvailable_Terms(availableList, null); + } + + public void setAvailable_InScope(Collection availableList, ConditionOptionCall opLambda) { + setAvailable_Terms(availableList, opLambda); + } + + public void setAvailable_Exists() { + setAvailable_Exists(null); + } + + public void setAvailable_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("available"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_Missing() { + setAvailable_Missing(null); + } + + public void setAvailable_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("available"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_GreaterThan(Boolean available) { + setAvailable_GreaterThan(available, null); + } + + public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_THAN, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_LessThan(Boolean available) { + setAvailable_LessThan(available, null); + } + + public void setAvailable_LessThan(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_THAN, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_GreaterEqual(Boolean available) { + setAvailable_GreaterEqual(available, null); + } + + public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_EQUAL, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_LessEqual(Boolean available) { + setAvailable_LessEqual(available, null); + } + + public void setAvailable_LessEqual(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_EQUAL, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Term(Float boost) { + setBoost_Term(boost, null); + } + + public void setBoost_Term(Float boost, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("boost", boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Terms(Collection boostList) { + setBoost_Terms(boostList, null); + } + + public void setBoost_Terms(Collection boostList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("boost", boostList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_InScope(Collection boostList) { + setBoost_Terms(boostList, null); + } + + public void setBoost_InScope(Collection boostList, ConditionOptionCall opLambda) { + setBoost_Terms(boostList, opLambda); + } + + public void setBoost_Exists() { + setBoost_Exists(null); + } + + public void setBoost_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("boost"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Missing() { + setBoost_Missing(null); + } + + public void setBoost_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("boost"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_GreaterThan(Float boost) { + setBoost_GreaterThan(boost, null); + } + + public void setBoost_GreaterThan(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_THAN, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_LessThan(Float boost) { + setBoost_LessThan(boost, null); + } + + public void setBoost_LessThan(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_THAN, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_GreaterEqual(Float boost) { + setBoost_GreaterEqual(boost, null); + } + + public void setBoost_GreaterEqual(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_EQUAL, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_LessEqual(Float boost) { + setBoost_LessEqual(boost, null); + } + + public void setBoost_LessEqual(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_EQUAL, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_Term(String configParameter) { + setConfigParameter_Term(configParameter, null); + } + + public void setConfigParameter_Term(String configParameter, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("configParameter", configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_Terms(Collection configParameterList) { + setConfigParameter_Terms(configParameterList, null); + } + + public void setConfigParameter_Terms(Collection configParameterList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("configParameter", configParameterList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_InScope(Collection configParameterList) { + setConfigParameter_Terms(configParameterList, null); + } + + public void setConfigParameter_InScope(Collection configParameterList, ConditionOptionCall opLambda) { + setConfigParameter_Terms(configParameterList, opLambda); + } + + public void setConfigParameter_Prefix(String configParameter) { + setConfigParameter_Prefix(configParameter, null); + } + + public void setConfigParameter_Prefix(String configParameter, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("configParameter", configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_Exists() { + setConfigParameter_Exists(null); + } + + public void setConfigParameter_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("configParameter"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_Missing() { + setConfigParameter_Missing(null); + } + + public void setConfigParameter_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("configParameter"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_GreaterThan(String configParameter) { + setConfigParameter_GreaterThan(configParameter, null); + } + + public void setConfigParameter_GreaterThan(String configParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_GREATER_THAN, configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_LessThan(String configParameter) { + setConfigParameter_LessThan(configParameter, null); + } + + public void setConfigParameter_LessThan(String configParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_LESS_THAN, configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_GreaterEqual(String configParameter) { + setConfigParameter_GreaterEqual(configParameter, null); + } + + public void setConfigParameter_GreaterEqual(String configParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_GREATER_EQUAL, configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_LessEqual(String configParameter) { + setConfigParameter_LessEqual(configParameter, null); + } + + public void setConfigParameter_LessEqual(String configParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_LESS_EQUAL, configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_Term(Integer depth) { + setDepth_Term(depth, null); + } + + public void setDepth_Term(Integer depth, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("depth", depth); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_Terms(Collection depthList) { + setDepth_Terms(depthList, null); + } + + public void setDepth_Terms(Collection depthList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("depth", depthList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_InScope(Collection depthList) { + setDepth_Terms(depthList, null); + } + + public void setDepth_InScope(Collection depthList, ConditionOptionCall opLambda) { + setDepth_Terms(depthList, opLambda); + } + + public void setDepth_Exists() { + setDepth_Exists(null); + } + + public void setDepth_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("depth"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_Missing() { + setDepth_Missing(null); + } + + public void setDepth_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("depth"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_GreaterThan(Integer depth) { + setDepth_GreaterThan(depth, null); + } + + public void setDepth_GreaterThan(Integer depth, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_GREATER_THAN, depth); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_LessThan(Integer depth) { + setDepth_LessThan(depth, null); + } + + public void setDepth_LessThan(Integer depth, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_LESS_THAN, depth); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_GreaterEqual(Integer depth) { + setDepth_GreaterEqual(depth, null); + } + + public void setDepth_GreaterEqual(Integer depth, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_GREATER_EQUAL, depth); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_LessEqual(Integer depth) { + setDepth_LessEqual(depth, null); + } + + public void setDepth_LessEqual(Integer depth, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_LESS_EQUAL, depth); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocPaths_Term(String excludedDocPaths) { + setExcludedDocPaths_Term(excludedDocPaths, null); + } + + public void setExcludedDocPaths_Term(String excludedDocPaths, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("excludedDocPaths", excludedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocPaths_Terms(Collection excludedDocPathsList) { + setExcludedDocPaths_Terms(excludedDocPathsList, null); + } + + public void setExcludedDocPaths_Terms(Collection excludedDocPathsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("excludedDocPaths", excludedDocPathsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocPaths_InScope(Collection excludedDocPathsList) { + setExcludedDocPaths_Terms(excludedDocPathsList, null); + } + + public void setExcludedDocPaths_InScope(Collection excludedDocPathsList, ConditionOptionCall opLambda) { + setExcludedDocPaths_Terms(excludedDocPathsList, opLambda); + } + + public void setExcludedDocPaths_Prefix(String excludedDocPaths) { + setExcludedDocPaths_Prefix(excludedDocPaths, null); + } + + public void setExcludedDocPaths_Prefix(String excludedDocPaths, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("excludedDocPaths", excludedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocPaths_Exists() { + setExcludedDocPaths_Exists(null); + } + + public void setExcludedDocPaths_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("excludedDocPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocPaths_Missing() { + setExcludedDocPaths_Missing(null); + } + + public void setExcludedDocPaths_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("excludedDocPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocPaths_GreaterThan(String excludedDocPaths) { + setExcludedDocPaths_GreaterThan(excludedDocPaths, null); + } + + public void setExcludedDocPaths_GreaterThan(String excludedDocPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedDocPaths", ConditionKey.CK_GREATER_THAN, excludedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocPaths_LessThan(String excludedDocPaths) { + setExcludedDocPaths_LessThan(excludedDocPaths, null); + } + + public void setExcludedDocPaths_LessThan(String excludedDocPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedDocPaths", ConditionKey.CK_LESS_THAN, excludedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocPaths_GreaterEqual(String excludedDocPaths) { + setExcludedDocPaths_GreaterEqual(excludedDocPaths, null); + } + + public void setExcludedDocPaths_GreaterEqual(String excludedDocPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedDocPaths", ConditionKey.CK_GREATER_EQUAL, excludedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocPaths_LessEqual(String excludedDocPaths) { + setExcludedDocPaths_LessEqual(excludedDocPaths, null); + } + + public void setExcludedDocPaths_LessEqual(String excludedDocPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedDocPaths", ConditionKey.CK_LESS_EQUAL, excludedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_Term(String excludedPaths) { + setExcludedPaths_Term(excludedPaths, null); + } + + public void setExcludedPaths_Term(String excludedPaths, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("excludedPaths", excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_Terms(Collection excludedPathsList) { + setExcludedPaths_Terms(excludedPathsList, null); + } + + public void setExcludedPaths_Terms(Collection excludedPathsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("excludedPaths", excludedPathsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_InScope(Collection excludedPathsList) { + setExcludedPaths_Terms(excludedPathsList, null); + } + + public void setExcludedPaths_InScope(Collection excludedPathsList, ConditionOptionCall opLambda) { + setExcludedPaths_Terms(excludedPathsList, opLambda); + } + + public void setExcludedPaths_Prefix(String excludedPaths) { + setExcludedPaths_Prefix(excludedPaths, null); + } + + public void setExcludedPaths_Prefix(String excludedPaths, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("excludedPaths", excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_Exists() { + setExcludedPaths_Exists(null); + } + + public void setExcludedPaths_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("excludedPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_Missing() { + setExcludedPaths_Missing(null); + } + + public void setExcludedPaths_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("excludedPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_GreaterThan(String excludedPaths) { + setExcludedPaths_GreaterThan(excludedPaths, null); + } + + public void setExcludedPaths_GreaterThan(String excludedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_GREATER_THAN, excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_LessThan(String excludedPaths) { + setExcludedPaths_LessThan(excludedPaths, null); + } + + public void setExcludedPaths_LessThan(String excludedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_LESS_THAN, excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_GreaterEqual(String excludedPaths) { + setExcludedPaths_GreaterEqual(excludedPaths, null); + } + + public void setExcludedPaths_GreaterEqual(String excludedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_GREATER_EQUAL, excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_LessEqual(String excludedPaths) { + setExcludedPaths_LessEqual(excludedPaths, null); + } + + public void setExcludedPaths_LessEqual(String excludedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_LESS_EQUAL, excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocPaths_Term(String includedDocPaths) { + setIncludedDocPaths_Term(includedDocPaths, null); + } + + public void setIncludedDocPaths_Term(String includedDocPaths, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("includedDocPaths", includedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocPaths_Terms(Collection includedDocPathsList) { + setIncludedDocPaths_Terms(includedDocPathsList, null); + } + + public void setIncludedDocPaths_Terms(Collection includedDocPathsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("includedDocPaths", includedDocPathsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocPaths_InScope(Collection includedDocPathsList) { + setIncludedDocPaths_Terms(includedDocPathsList, null); + } + + public void setIncludedDocPaths_InScope(Collection includedDocPathsList, ConditionOptionCall opLambda) { + setIncludedDocPaths_Terms(includedDocPathsList, opLambda); + } + + public void setIncludedDocPaths_Prefix(String includedDocPaths) { + setIncludedDocPaths_Prefix(includedDocPaths, null); + } + + public void setIncludedDocPaths_Prefix(String includedDocPaths, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("includedDocPaths", includedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocPaths_Exists() { + setIncludedDocPaths_Exists(null); + } + + public void setIncludedDocPaths_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("includedDocPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocPaths_Missing() { + setIncludedDocPaths_Missing(null); + } + + public void setIncludedDocPaths_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("includedDocPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocPaths_GreaterThan(String includedDocPaths) { + setIncludedDocPaths_GreaterThan(includedDocPaths, null); + } + + public void setIncludedDocPaths_GreaterThan(String includedDocPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedDocPaths", ConditionKey.CK_GREATER_THAN, includedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocPaths_LessThan(String includedDocPaths) { + setIncludedDocPaths_LessThan(includedDocPaths, null); + } + + public void setIncludedDocPaths_LessThan(String includedDocPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedDocPaths", ConditionKey.CK_LESS_THAN, includedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocPaths_GreaterEqual(String includedDocPaths) { + setIncludedDocPaths_GreaterEqual(includedDocPaths, null); + } + + public void setIncludedDocPaths_GreaterEqual(String includedDocPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedDocPaths", ConditionKey.CK_GREATER_EQUAL, includedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocPaths_LessEqual(String includedDocPaths) { + setIncludedDocPaths_LessEqual(includedDocPaths, null); + } + + public void setIncludedDocPaths_LessEqual(String includedDocPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedDocPaths", ConditionKey.CK_LESS_EQUAL, includedDocPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_Term(String includedPaths) { + setIncludedPaths_Term(includedPaths, null); + } + + public void setIncludedPaths_Term(String includedPaths, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("includedPaths", includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_Terms(Collection includedPathsList) { + setIncludedPaths_Terms(includedPathsList, null); + } + + public void setIncludedPaths_Terms(Collection includedPathsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("includedPaths", includedPathsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_InScope(Collection includedPathsList) { + setIncludedPaths_Terms(includedPathsList, null); + } + + public void setIncludedPaths_InScope(Collection includedPathsList, ConditionOptionCall opLambda) { + setIncludedPaths_Terms(includedPathsList, opLambda); + } + + public void setIncludedPaths_Prefix(String includedPaths) { + setIncludedPaths_Prefix(includedPaths, null); + } + + public void setIncludedPaths_Prefix(String includedPaths, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("includedPaths", includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_Exists() { + setIncludedPaths_Exists(null); + } + + public void setIncludedPaths_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("includedPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_Missing() { + setIncludedPaths_Missing(null); + } + + public void setIncludedPaths_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("includedPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_GreaterThan(String includedPaths) { + setIncludedPaths_GreaterThan(includedPaths, null); + } + + public void setIncludedPaths_GreaterThan(String includedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_GREATER_THAN, includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_LessThan(String includedPaths) { + setIncludedPaths_LessThan(includedPaths, null); + } + + public void setIncludedPaths_LessThan(String includedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_LESS_THAN, includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_GreaterEqual(String includedPaths) { + setIncludedPaths_GreaterEqual(includedPaths, null); + } + + public void setIncludedPaths_GreaterEqual(String includedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_GREATER_EQUAL, includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_LessEqual(String includedPaths) { + setIncludedPaths_LessEqual(includedPaths, null); + } + + public void setIncludedPaths_LessEqual(String includedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_LESS_EQUAL, includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_Term(Integer intervalTime) { + setIntervalTime_Term(intervalTime, null); + } + + public void setIntervalTime_Term(Integer intervalTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("intervalTime", intervalTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_Terms(Collection intervalTimeList) { + setIntervalTime_Terms(intervalTimeList, null); + } + + public void setIntervalTime_Terms(Collection intervalTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("intervalTime", intervalTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_InScope(Collection intervalTimeList) { + setIntervalTime_Terms(intervalTimeList, null); + } + + public void setIntervalTime_InScope(Collection intervalTimeList, ConditionOptionCall opLambda) { + setIntervalTime_Terms(intervalTimeList, opLambda); + } + + public void setIntervalTime_Exists() { + setIntervalTime_Exists(null); + } + + public void setIntervalTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("intervalTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_Missing() { + setIntervalTime_Missing(null); + } + + public void setIntervalTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("intervalTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_GreaterThan(Integer intervalTime) { + setIntervalTime_GreaterThan(intervalTime, null); + } + + public void setIntervalTime_GreaterThan(Integer intervalTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_GREATER_THAN, intervalTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_LessThan(Integer intervalTime) { + setIntervalTime_LessThan(intervalTime, null); + } + + public void setIntervalTime_LessThan(Integer intervalTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_LESS_THAN, intervalTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_GreaterEqual(Integer intervalTime) { + setIntervalTime_GreaterEqual(intervalTime, null); + } + + public void setIntervalTime_GreaterEqual(Integer intervalTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_GREATER_EQUAL, intervalTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_LessEqual(Integer intervalTime) { + setIntervalTime_LessEqual(intervalTime, null); + } + + public void setIntervalTime_LessEqual(Integer intervalTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_LESS_EQUAL, intervalTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_Term(Long maxAccessCount) { + setMaxAccessCount_Term(maxAccessCount, null); + } + + public void setMaxAccessCount_Term(Long maxAccessCount, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("maxAccessCount", maxAccessCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_Terms(Collection maxAccessCountList) { + setMaxAccessCount_Terms(maxAccessCountList, null); + } + + public void setMaxAccessCount_Terms(Collection maxAccessCountList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("maxAccessCount", maxAccessCountList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_InScope(Collection maxAccessCountList) { + setMaxAccessCount_Terms(maxAccessCountList, null); + } + + public void setMaxAccessCount_InScope(Collection maxAccessCountList, ConditionOptionCall opLambda) { + setMaxAccessCount_Terms(maxAccessCountList, opLambda); + } + + public void setMaxAccessCount_Exists() { + setMaxAccessCount_Exists(null); + } + + public void setMaxAccessCount_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("maxAccessCount"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_Missing() { + setMaxAccessCount_Missing(null); + } + + public void setMaxAccessCount_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("maxAccessCount"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_GreaterThan(Long maxAccessCount) { + setMaxAccessCount_GreaterThan(maxAccessCount, null); + } + + public void setMaxAccessCount_GreaterThan(Long maxAccessCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_GREATER_THAN, maxAccessCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_LessThan(Long maxAccessCount) { + setMaxAccessCount_LessThan(maxAccessCount, null); + } + + public void setMaxAccessCount_LessThan(Long maxAccessCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_LESS_THAN, maxAccessCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_GreaterEqual(Long maxAccessCount) { + setMaxAccessCount_GreaterEqual(maxAccessCount, null); + } + + public void setMaxAccessCount_GreaterEqual(Long maxAccessCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_GREATER_EQUAL, maxAccessCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_LessEqual(Long maxAccessCount) { + setMaxAccessCount_LessEqual(maxAccessCount, null); + } + + public void setMaxAccessCount_LessEqual(Long maxAccessCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_LESS_EQUAL, maxAccessCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Term(String name) { + setName_Term(name, null); + } + + public void setName_Term(String name, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Terms(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("name", nameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_InScope(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { + setName_Terms(nameList, opLambda); + } + + public void setName_Prefix(String name) { + setName_Prefix(name, null); + } + + public void setName_Prefix(String name, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Exists() { + setName_Exists(null); + } + + public void setName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Missing() { + setName_Missing(null); + } + + public void setName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterThan(String name) { + setName_GreaterThan(name, null); + } + + public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessThan(String name) { + setName_LessThan(name, null); + } + + public void setName_LessThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterEqual(String name) { + setName_GreaterEqual(name, null); + } + + public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessEqual(String name) { + setName_LessEqual(name, null); + } + + public void setName_LessEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_Term(Integer numOfThread) { + setNumOfThread_Term(numOfThread, null); + } + + public void setNumOfThread_Term(Integer numOfThread, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("numOfThread", numOfThread); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_Terms(Collection numOfThreadList) { + setNumOfThread_Terms(numOfThreadList, null); + } + + public void setNumOfThread_Terms(Collection numOfThreadList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("numOfThread", numOfThreadList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_InScope(Collection numOfThreadList) { + setNumOfThread_Terms(numOfThreadList, null); + } + + public void setNumOfThread_InScope(Collection numOfThreadList, ConditionOptionCall opLambda) { + setNumOfThread_Terms(numOfThreadList, opLambda); + } + + public void setNumOfThread_Exists() { + setNumOfThread_Exists(null); + } + + public void setNumOfThread_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("numOfThread"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_Missing() { + setNumOfThread_Missing(null); + } + + public void setNumOfThread_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("numOfThread"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_GreaterThan(Integer numOfThread) { + setNumOfThread_GreaterThan(numOfThread, null); + } + + public void setNumOfThread_GreaterThan(Integer numOfThread, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_GREATER_THAN, numOfThread); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_LessThan(Integer numOfThread) { + setNumOfThread_LessThan(numOfThread, null); + } + + public void setNumOfThread_LessThan(Integer numOfThread, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_LESS_THAN, numOfThread); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_GreaterEqual(Integer numOfThread) { + setNumOfThread_GreaterEqual(numOfThread, null); + } + + public void setNumOfThread_GreaterEqual(Integer numOfThread, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_GREATER_EQUAL, numOfThread); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_LessEqual(Integer numOfThread) { + setNumOfThread_LessEqual(numOfThread, null); + } + + public void setNumOfThread_LessEqual(Integer numOfThread, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_LESS_EQUAL, numOfThread); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPaths_Term(String paths) { + setPaths_Term(paths, null); + } + + public void setPaths_Term(String paths, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("paths", paths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPaths_Terms(Collection pathsList) { + setPaths_Terms(pathsList, null); + } + + public void setPaths_Terms(Collection pathsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("paths", pathsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPaths_InScope(Collection pathsList) { + setPaths_Terms(pathsList, null); + } + + public void setPaths_InScope(Collection pathsList, ConditionOptionCall opLambda) { + setPaths_Terms(pathsList, opLambda); + } + + public void setPaths_Prefix(String paths) { + setPaths_Prefix(paths, null); + } + + public void setPaths_Prefix(String paths, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("paths", paths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPaths_Exists() { + setPaths_Exists(null); + } + + public void setPaths_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("paths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPaths_Missing() { + setPaths_Missing(null); + } + + public void setPaths_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("paths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPaths_GreaterThan(String paths) { + setPaths_GreaterThan(paths, null); + } + + public void setPaths_GreaterThan(String paths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("paths", ConditionKey.CK_GREATER_THAN, paths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPaths_LessThan(String paths) { + setPaths_LessThan(paths, null); + } + + public void setPaths_LessThan(String paths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("paths", ConditionKey.CK_LESS_THAN, paths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPaths_GreaterEqual(String paths) { + setPaths_GreaterEqual(paths, null); + } + + public void setPaths_GreaterEqual(String paths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("paths", ConditionKey.CK_GREATER_EQUAL, paths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPaths_LessEqual(String paths) { + setPaths_LessEqual(paths, null); + } + + public void setPaths_LessEqual(String paths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("paths", ConditionKey.CK_LESS_EQUAL, paths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Term(Integer sortOrder) { + setSortOrder_Term(sortOrder, null); + } + + public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("sortOrder", sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Terms(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_InScope(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { + setSortOrder_Terms(sortOrderList, opLambda); + } + + public void setSortOrder_Exists() { + setSortOrder_Exists(null); + } + + public void setSortOrder_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Missing() { + setSortOrder_Missing(null); + } + + public void setSortOrder_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterThan(Integer sortOrder) { + setSortOrder_GreaterThan(sortOrder, null); + } + + public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessThan(Integer sortOrder) { + setSortOrder_LessThan(sortOrder, null); + } + + public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterEqual(Integer sortOrder) { + setSortOrder_GreaterEqual(sortOrder, null); + } + + public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessEqual(Integer sortOrder) { + setSortOrder_LessEqual(sortOrder, null); + } + + public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigToLabelCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigToLabelCF.java new file mode 100644 index 000000000..64ef860e2 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigToLabelCF.java @@ -0,0 +1,430 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.FileConfigToLabelCF; +import org.codelibs.fess.es.cbean.cq.FileConfigToLabelCQ; +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 BsFileConfigToLabelCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + FileConfigToLabelCF mustFilter = new FileConfigToLabelCF(); + FileConfigToLabelCF shouldFilter = new FileConfigToLabelCF(); + FileConfigToLabelCF mustNotFilter = new FileConfigToLabelCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + FileConfigToLabelCF andFilter = new FileConfigToLabelCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + FileConfigToLabelCF orFilter = new FileConfigToLabelCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + FileConfigToLabelCF notFilter = new FileConfigToLabelCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + FileConfigToLabelCQ query = new FileConfigToLabelCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setFileConfigId_Term(String fileConfigId) { + setFileConfigId_Term(fileConfigId, null); + } + + public void setFileConfigId_Term(String fileConfigId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("fileConfigId", fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_Terms(Collection fileConfigIdList) { + setFileConfigId_Terms(fileConfigIdList, null); + } + + public void setFileConfigId_Terms(Collection fileConfigIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("fileConfigId", fileConfigIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_InScope(Collection fileConfigIdList) { + setFileConfigId_Terms(fileConfigIdList, null); + } + + public void setFileConfigId_InScope(Collection fileConfigIdList, ConditionOptionCall opLambda) { + setFileConfigId_Terms(fileConfigIdList, opLambda); + } + + public void setFileConfigId_Prefix(String fileConfigId) { + setFileConfigId_Prefix(fileConfigId, null); + } + + public void setFileConfigId_Prefix(String fileConfigId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("fileConfigId", fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_Exists() { + setFileConfigId_Exists(null); + } + + public void setFileConfigId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("fileConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_Missing() { + setFileConfigId_Missing(null); + } + + public void setFileConfigId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("fileConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_GreaterThan(String fileConfigId) { + setFileConfigId_GreaterThan(fileConfigId, null); + } + + public void setFileConfigId_GreaterThan(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_LessThan(String fileConfigId) { + setFileConfigId_LessThan(fileConfigId, null); + } + + public void setFileConfigId_LessThan(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_GreaterEqual(String fileConfigId) { + setFileConfigId_GreaterEqual(fileConfigId, null); + } + + public void setFileConfigId_GreaterEqual(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_LessEqual(String fileConfigId) { + setFileConfigId_LessEqual(fileConfigId, null); + } + + public void setFileConfigId_LessEqual(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Term(String labelTypeId) { + setLabelTypeId_Term(labelTypeId, null); + } + + public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("labelTypeId", labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Terms(Collection labelTypeIdList) { + setLabelTypeId_Terms(labelTypeIdList, null); + } + + public void setLabelTypeId_Terms(Collection labelTypeIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("labelTypeId", labelTypeIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_InScope(Collection labelTypeIdList) { + setLabelTypeId_Terms(labelTypeIdList, null); + } + + public void setLabelTypeId_InScope(Collection labelTypeIdList, ConditionOptionCall opLambda) { + setLabelTypeId_Terms(labelTypeIdList, opLambda); + } + + public void setLabelTypeId_Prefix(String labelTypeId) { + setLabelTypeId_Prefix(labelTypeId, null); + } + + public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("labelTypeId", labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Exists() { + setLabelTypeId_Exists(null); + } + + public void setLabelTypeId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("labelTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Missing() { + setLabelTypeId_Missing(null); + } + + public void setLabelTypeId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("labelTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_GreaterThan(String labelTypeId) { + setLabelTypeId_GreaterThan(labelTypeId, null); + } + + public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_LessThan(String labelTypeId) { + setLabelTypeId_LessThan(labelTypeId, null); + } + + public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_GreaterEqual(String labelTypeId) { + setLabelTypeId_GreaterEqual(labelTypeId, null); + } + + public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_LessEqual(String labelTypeId) { + setLabelTypeId_LessEqual(labelTypeId, null); + } + + public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigToRoleCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigToRoleCF.java new file mode 100644 index 000000000..442573810 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsFileConfigToRoleCF.java @@ -0,0 +1,430 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.FileConfigToRoleCF; +import org.codelibs.fess.es.cbean.cq.FileConfigToRoleCQ; +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 BsFileConfigToRoleCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + FileConfigToRoleCF mustFilter = new FileConfigToRoleCF(); + FileConfigToRoleCF shouldFilter = new FileConfigToRoleCF(); + FileConfigToRoleCF mustNotFilter = new FileConfigToRoleCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + FileConfigToRoleCF andFilter = new FileConfigToRoleCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + FileConfigToRoleCF orFilter = new FileConfigToRoleCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + FileConfigToRoleCF notFilter = new FileConfigToRoleCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + FileConfigToRoleCQ query = new FileConfigToRoleCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setFileConfigId_Term(String fileConfigId) { + setFileConfigId_Term(fileConfigId, null); + } + + public void setFileConfigId_Term(String fileConfigId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("fileConfigId", fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_Terms(Collection fileConfigIdList) { + setFileConfigId_Terms(fileConfigIdList, null); + } + + public void setFileConfigId_Terms(Collection fileConfigIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("fileConfigId", fileConfigIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_InScope(Collection fileConfigIdList) { + setFileConfigId_Terms(fileConfigIdList, null); + } + + public void setFileConfigId_InScope(Collection fileConfigIdList, ConditionOptionCall opLambda) { + setFileConfigId_Terms(fileConfigIdList, opLambda); + } + + public void setFileConfigId_Prefix(String fileConfigId) { + setFileConfigId_Prefix(fileConfigId, null); + } + + public void setFileConfigId_Prefix(String fileConfigId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("fileConfigId", fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_Exists() { + setFileConfigId_Exists(null); + } + + public void setFileConfigId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("fileConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_Missing() { + setFileConfigId_Missing(null); + } + + public void setFileConfigId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("fileConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_GreaterThan(String fileConfigId) { + setFileConfigId_GreaterThan(fileConfigId, null); + } + + public void setFileConfigId_GreaterThan(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_LessThan(String fileConfigId) { + setFileConfigId_LessThan(fileConfigId, null); + } + + public void setFileConfigId_LessThan(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_GreaterEqual(String fileConfigId) { + setFileConfigId_GreaterEqual(fileConfigId, null); + } + + public void setFileConfigId_GreaterEqual(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setFileConfigId_LessEqual(String fileConfigId) { + setFileConfigId_LessEqual(fileConfigId, null); + } + + public void setFileConfigId_LessEqual(String fileConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Term(String roleTypeId) { + setRoleTypeId_Term(roleTypeId, null); + } + + public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("roleTypeId", roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Terms(Collection roleTypeIdList) { + setRoleTypeId_Terms(roleTypeIdList, null); + } + + public void setRoleTypeId_Terms(Collection roleTypeIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("roleTypeId", roleTypeIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_InScope(Collection roleTypeIdList) { + setRoleTypeId_Terms(roleTypeIdList, null); + } + + public void setRoleTypeId_InScope(Collection roleTypeIdList, ConditionOptionCall opLambda) { + setRoleTypeId_Terms(roleTypeIdList, opLambda); + } + + public void setRoleTypeId_Prefix(String roleTypeId) { + setRoleTypeId_Prefix(roleTypeId, null); + } + + public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("roleTypeId", roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Exists() { + setRoleTypeId_Exists(null); + } + + public void setRoleTypeId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("roleTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Missing() { + setRoleTypeId_Missing(null); + } + + public void setRoleTypeId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("roleTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_GreaterThan(String roleTypeId) { + setRoleTypeId_GreaterThan(roleTypeId, null); + } + + public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_LessThan(String roleTypeId) { + setRoleTypeId_LessThan(roleTypeId, null); + } + + public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_GreaterEqual(String roleTypeId) { + setRoleTypeId_GreaterEqual(roleTypeId, null); + } + + public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_LessEqual(String roleTypeId) { + setRoleTypeId_LessEqual(roleTypeId, null); + } + + public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsJobLogCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsJobLogCF.java new file mode 100644 index 000000000..820e2d86b --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsJobLogCF.java @@ -0,0 +1,1050 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.JobLogCF; +import org.codelibs.fess.es.cbean.cq.JobLogCQ; +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 BsJobLogCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + JobLogCF mustFilter = new JobLogCF(); + JobLogCF shouldFilter = new JobLogCF(); + JobLogCF mustNotFilter = new JobLogCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + JobLogCF andFilter = new JobLogCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + JobLogCF orFilter = new JobLogCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + JobLogCF notFilter = new JobLogCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + JobLogCQ query = new JobLogCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setEndTime_Term(Long endTime) { + setEndTime_Term(endTime, null); + } + + public void setEndTime_Term(Long endTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("endTime", endTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setEndTime_Terms(Collection endTimeList) { + setEndTime_Terms(endTimeList, null); + } + + public void setEndTime_Terms(Collection endTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("endTime", endTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setEndTime_InScope(Collection endTimeList) { + setEndTime_Terms(endTimeList, null); + } + + public void setEndTime_InScope(Collection endTimeList, ConditionOptionCall opLambda) { + setEndTime_Terms(endTimeList, opLambda); + } + + public void setEndTime_Exists() { + setEndTime_Exists(null); + } + + public void setEndTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("endTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setEndTime_Missing() { + setEndTime_Missing(null); + } + + public void setEndTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("endTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setEndTime_GreaterThan(Long endTime) { + setEndTime_GreaterThan(endTime, null); + } + + public void setEndTime_GreaterThan(Long endTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("endTime", ConditionKey.CK_GREATER_THAN, endTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setEndTime_LessThan(Long endTime) { + setEndTime_LessThan(endTime, null); + } + + public void setEndTime_LessThan(Long endTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("endTime", ConditionKey.CK_LESS_THAN, endTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setEndTime_GreaterEqual(Long endTime) { + setEndTime_GreaterEqual(endTime, null); + } + + public void setEndTime_GreaterEqual(Long endTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("endTime", ConditionKey.CK_GREATER_EQUAL, endTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setEndTime_LessEqual(Long endTime) { + setEndTime_LessEqual(endTime, null); + } + + public void setEndTime_LessEqual(Long endTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("endTime", ConditionKey.CK_LESS_EQUAL, endTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobName_Term(String jobName) { + setJobName_Term(jobName, null); + } + + public void setJobName_Term(String jobName, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("jobName", jobName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobName_Terms(Collection jobNameList) { + setJobName_Terms(jobNameList, null); + } + + public void setJobName_Terms(Collection jobNameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("jobName", jobNameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobName_InScope(Collection jobNameList) { + setJobName_Terms(jobNameList, null); + } + + public void setJobName_InScope(Collection jobNameList, ConditionOptionCall opLambda) { + setJobName_Terms(jobNameList, opLambda); + } + + public void setJobName_Prefix(String jobName) { + setJobName_Prefix(jobName, null); + } + + public void setJobName_Prefix(String jobName, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("jobName", jobName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobName_Exists() { + setJobName_Exists(null); + } + + public void setJobName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("jobName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobName_Missing() { + setJobName_Missing(null); + } + + public void setJobName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("jobName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobName_GreaterThan(String jobName) { + setJobName_GreaterThan(jobName, null); + } + + public void setJobName_GreaterThan(String jobName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobName", ConditionKey.CK_GREATER_THAN, jobName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobName_LessThan(String jobName) { + setJobName_LessThan(jobName, null); + } + + public void setJobName_LessThan(String jobName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobName", ConditionKey.CK_LESS_THAN, jobName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobName_GreaterEqual(String jobName) { + setJobName_GreaterEqual(jobName, null); + } + + public void setJobName_GreaterEqual(String jobName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobName", ConditionKey.CK_GREATER_EQUAL, jobName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobName_LessEqual(String jobName) { + setJobName_LessEqual(jobName, null); + } + + public void setJobName_LessEqual(String jobName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobName", ConditionKey.CK_LESS_EQUAL, jobName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobStatus_Term(String jobStatus) { + setJobStatus_Term(jobStatus, null); + } + + public void setJobStatus_Term(String jobStatus, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("jobStatus", jobStatus); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobStatus_Terms(Collection jobStatusList) { + setJobStatus_Terms(jobStatusList, null); + } + + public void setJobStatus_Terms(Collection jobStatusList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("jobStatus", jobStatusList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobStatus_InScope(Collection jobStatusList) { + setJobStatus_Terms(jobStatusList, null); + } + + public void setJobStatus_InScope(Collection jobStatusList, ConditionOptionCall opLambda) { + setJobStatus_Terms(jobStatusList, opLambda); + } + + public void setJobStatus_Prefix(String jobStatus) { + setJobStatus_Prefix(jobStatus, null); + } + + public void setJobStatus_Prefix(String jobStatus, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("jobStatus", jobStatus); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobStatus_Exists() { + setJobStatus_Exists(null); + } + + public void setJobStatus_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("jobStatus"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobStatus_Missing() { + setJobStatus_Missing(null); + } + + public void setJobStatus_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("jobStatus"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobStatus_GreaterThan(String jobStatus) { + setJobStatus_GreaterThan(jobStatus, null); + } + + public void setJobStatus_GreaterThan(String jobStatus, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobStatus", ConditionKey.CK_GREATER_THAN, jobStatus); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobStatus_LessThan(String jobStatus) { + setJobStatus_LessThan(jobStatus, null); + } + + public void setJobStatus_LessThan(String jobStatus, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobStatus", ConditionKey.CK_LESS_THAN, jobStatus); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobStatus_GreaterEqual(String jobStatus) { + setJobStatus_GreaterEqual(jobStatus, null); + } + + public void setJobStatus_GreaterEqual(String jobStatus, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobStatus", ConditionKey.CK_GREATER_EQUAL, jobStatus); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobStatus_LessEqual(String jobStatus) { + setJobStatus_LessEqual(jobStatus, null); + } + + public void setJobStatus_LessEqual(String jobStatus, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobStatus", ConditionKey.CK_LESS_EQUAL, jobStatus); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_Term(String scriptData) { + setScriptData_Term(scriptData, null); + } + + public void setScriptData_Term(String scriptData, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("scriptData", scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_Terms(Collection scriptDataList) { + setScriptData_Terms(scriptDataList, null); + } + + public void setScriptData_Terms(Collection scriptDataList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("scriptData", scriptDataList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_InScope(Collection scriptDataList) { + setScriptData_Terms(scriptDataList, null); + } + + public void setScriptData_InScope(Collection scriptDataList, ConditionOptionCall opLambda) { + setScriptData_Terms(scriptDataList, opLambda); + } + + public void setScriptData_Prefix(String scriptData) { + setScriptData_Prefix(scriptData, null); + } + + public void setScriptData_Prefix(String scriptData, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("scriptData", scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_Exists() { + setScriptData_Exists(null); + } + + public void setScriptData_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("scriptData"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_Missing() { + setScriptData_Missing(null); + } + + public void setScriptData_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("scriptData"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_GreaterThan(String scriptData) { + setScriptData_GreaterThan(scriptData, null); + } + + public void setScriptData_GreaterThan(String scriptData, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_GREATER_THAN, scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_LessThan(String scriptData) { + setScriptData_LessThan(scriptData, null); + } + + public void setScriptData_LessThan(String scriptData, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_LESS_THAN, scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_GreaterEqual(String scriptData) { + setScriptData_GreaterEqual(scriptData, null); + } + + public void setScriptData_GreaterEqual(String scriptData, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_GREATER_EQUAL, scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_LessEqual(String scriptData) { + setScriptData_LessEqual(scriptData, null); + } + + public void setScriptData_LessEqual(String scriptData, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_LESS_EQUAL, scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptResult_Term(String scriptResult) { + setScriptResult_Term(scriptResult, null); + } + + public void setScriptResult_Term(String scriptResult, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("scriptResult", scriptResult); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptResult_Terms(Collection scriptResultList) { + setScriptResult_Terms(scriptResultList, null); + } + + public void setScriptResult_Terms(Collection scriptResultList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("scriptResult", scriptResultList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptResult_InScope(Collection scriptResultList) { + setScriptResult_Terms(scriptResultList, null); + } + + public void setScriptResult_InScope(Collection scriptResultList, ConditionOptionCall opLambda) { + setScriptResult_Terms(scriptResultList, opLambda); + } + + public void setScriptResult_Prefix(String scriptResult) { + setScriptResult_Prefix(scriptResult, null); + } + + public void setScriptResult_Prefix(String scriptResult, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("scriptResult", scriptResult); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptResult_Exists() { + setScriptResult_Exists(null); + } + + public void setScriptResult_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("scriptResult"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptResult_Missing() { + setScriptResult_Missing(null); + } + + public void setScriptResult_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("scriptResult"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptResult_GreaterThan(String scriptResult) { + setScriptResult_GreaterThan(scriptResult, null); + } + + public void setScriptResult_GreaterThan(String scriptResult, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptResult", ConditionKey.CK_GREATER_THAN, scriptResult); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptResult_LessThan(String scriptResult) { + setScriptResult_LessThan(scriptResult, null); + } + + public void setScriptResult_LessThan(String scriptResult, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptResult", ConditionKey.CK_LESS_THAN, scriptResult); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptResult_GreaterEqual(String scriptResult) { + setScriptResult_GreaterEqual(scriptResult, null); + } + + public void setScriptResult_GreaterEqual(String scriptResult, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptResult", ConditionKey.CK_GREATER_EQUAL, scriptResult); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptResult_LessEqual(String scriptResult) { + setScriptResult_LessEqual(scriptResult, null); + } + + public void setScriptResult_LessEqual(String scriptResult, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptResult", ConditionKey.CK_LESS_EQUAL, scriptResult); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_Term(String scriptType) { + setScriptType_Term(scriptType, null); + } + + public void setScriptType_Term(String scriptType, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("scriptType", scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_Terms(Collection scriptTypeList) { + setScriptType_Terms(scriptTypeList, null); + } + + public void setScriptType_Terms(Collection scriptTypeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("scriptType", scriptTypeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_InScope(Collection scriptTypeList) { + setScriptType_Terms(scriptTypeList, null); + } + + public void setScriptType_InScope(Collection scriptTypeList, ConditionOptionCall opLambda) { + setScriptType_Terms(scriptTypeList, opLambda); + } + + public void setScriptType_Prefix(String scriptType) { + setScriptType_Prefix(scriptType, null); + } + + public void setScriptType_Prefix(String scriptType, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("scriptType", scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_Exists() { + setScriptType_Exists(null); + } + + public void setScriptType_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("scriptType"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_Missing() { + setScriptType_Missing(null); + } + + public void setScriptType_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("scriptType"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_GreaterThan(String scriptType) { + setScriptType_GreaterThan(scriptType, null); + } + + public void setScriptType_GreaterThan(String scriptType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_GREATER_THAN, scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_LessThan(String scriptType) { + setScriptType_LessThan(scriptType, null); + } + + public void setScriptType_LessThan(String scriptType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_LESS_THAN, scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_GreaterEqual(String scriptType) { + setScriptType_GreaterEqual(scriptType, null); + } + + public void setScriptType_GreaterEqual(String scriptType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_GREATER_EQUAL, scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_LessEqual(String scriptType) { + setScriptType_LessEqual(scriptType, null); + } + + public void setScriptType_LessEqual(String scriptType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_LESS_EQUAL, scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setStartTime_Term(Long startTime) { + setStartTime_Term(startTime, null); + } + + public void setStartTime_Term(Long startTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("startTime", startTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setStartTime_Terms(Collection startTimeList) { + setStartTime_Terms(startTimeList, null); + } + + public void setStartTime_Terms(Collection startTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("startTime", startTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setStartTime_InScope(Collection startTimeList) { + setStartTime_Terms(startTimeList, null); + } + + public void setStartTime_InScope(Collection startTimeList, ConditionOptionCall opLambda) { + setStartTime_Terms(startTimeList, opLambda); + } + + public void setStartTime_Exists() { + setStartTime_Exists(null); + } + + public void setStartTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("startTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setStartTime_Missing() { + setStartTime_Missing(null); + } + + public void setStartTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("startTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setStartTime_GreaterThan(Long startTime) { + setStartTime_GreaterThan(startTime, null); + } + + public void setStartTime_GreaterThan(Long startTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("startTime", ConditionKey.CK_GREATER_THAN, startTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setStartTime_LessThan(Long startTime) { + setStartTime_LessThan(startTime, null); + } + + public void setStartTime_LessThan(Long startTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("startTime", ConditionKey.CK_LESS_THAN, startTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setStartTime_GreaterEqual(Long startTime) { + setStartTime_GreaterEqual(startTime, null); + } + + public void setStartTime_GreaterEqual(Long startTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("startTime", ConditionKey.CK_GREATER_EQUAL, startTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setStartTime_LessEqual(Long startTime) { + setStartTime_LessEqual(startTime, null); + } + + public void setStartTime_LessEqual(Long startTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("startTime", ConditionKey.CK_LESS_EQUAL, startTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_Term(String target) { + setTarget_Term(target, null); + } + + public void setTarget_Term(String target, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("target", target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_Terms(Collection targetList) { + setTarget_Terms(targetList, null); + } + + public void setTarget_Terms(Collection targetList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("target", targetList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_InScope(Collection targetList) { + setTarget_Terms(targetList, null); + } + + public void setTarget_InScope(Collection targetList, ConditionOptionCall opLambda) { + setTarget_Terms(targetList, opLambda); + } + + public void setTarget_Prefix(String target) { + setTarget_Prefix(target, null); + } + + public void setTarget_Prefix(String target, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("target", target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_Exists() { + setTarget_Exists(null); + } + + public void setTarget_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("target"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_Missing() { + setTarget_Missing(null); + } + + public void setTarget_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("target"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_GreaterThan(String target) { + setTarget_GreaterThan(target, null); + } + + public void setTarget_GreaterThan(String target, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_GREATER_THAN, target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_LessThan(String target) { + setTarget_LessThan(target, null); + } + + public void setTarget_LessThan(String target, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_LESS_THAN, target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_GreaterEqual(String target) { + setTarget_GreaterEqual(target, null); + } + + public void setTarget_GreaterEqual(String target, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_GREATER_EQUAL, target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_LessEqual(String target) { + setTarget_LessEqual(target, null); + } + + public void setTarget_LessEqual(String target, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_LESS_EQUAL, target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsKeyMatchCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsKeyMatchCF.java new file mode 100644 index 000000000..d5ae20e4b --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsKeyMatchCF.java @@ -0,0 +1,1028 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.KeyMatchCF; +import org.codelibs.fess.es.cbean.cq.KeyMatchCQ; +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 BsKeyMatchCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + KeyMatchCF mustFilter = new KeyMatchCF(); + KeyMatchCF shouldFilter = new KeyMatchCF(); + KeyMatchCF mustNotFilter = new KeyMatchCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + KeyMatchCF andFilter = new KeyMatchCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + KeyMatchCF orFilter = new KeyMatchCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + KeyMatchCF notFilter = new KeyMatchCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + KeyMatchCQ query = new KeyMatchCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setBoost_Term(Float boost) { + setBoost_Term(boost, null); + } + + public void setBoost_Term(Float boost, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("boost", boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Terms(Collection boostList) { + setBoost_Terms(boostList, null); + } + + public void setBoost_Terms(Collection boostList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("boost", boostList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_InScope(Collection boostList) { + setBoost_Terms(boostList, null); + } + + public void setBoost_InScope(Collection boostList, ConditionOptionCall opLambda) { + setBoost_Terms(boostList, opLambda); + } + + public void setBoost_Exists() { + setBoost_Exists(null); + } + + public void setBoost_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("boost"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Missing() { + setBoost_Missing(null); + } + + public void setBoost_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("boost"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_GreaterThan(Float boost) { + setBoost_GreaterThan(boost, null); + } + + public void setBoost_GreaterThan(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_THAN, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_LessThan(Float boost) { + setBoost_LessThan(boost, null); + } + + public void setBoost_LessThan(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_THAN, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_GreaterEqual(Float boost) { + setBoost_GreaterEqual(boost, null); + } + + public void setBoost_GreaterEqual(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_EQUAL, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_LessEqual(Float boost) { + setBoost_LessEqual(boost, null); + } + + public void setBoost_LessEqual(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_EQUAL, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxSize_Term(Integer maxSize) { + setMaxSize_Term(maxSize, null); + } + + public void setMaxSize_Term(Integer maxSize, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("maxSize", maxSize); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxSize_Terms(Collection maxSizeList) { + setMaxSize_Terms(maxSizeList, null); + } + + public void setMaxSize_Terms(Collection maxSizeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("maxSize", maxSizeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxSize_InScope(Collection maxSizeList) { + setMaxSize_Terms(maxSizeList, null); + } + + public void setMaxSize_InScope(Collection maxSizeList, ConditionOptionCall opLambda) { + setMaxSize_Terms(maxSizeList, opLambda); + } + + public void setMaxSize_Exists() { + setMaxSize_Exists(null); + } + + public void setMaxSize_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("maxSize"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxSize_Missing() { + setMaxSize_Missing(null); + } + + public void setMaxSize_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("maxSize"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxSize_GreaterThan(Integer maxSize) { + setMaxSize_GreaterThan(maxSize, null); + } + + public void setMaxSize_GreaterThan(Integer maxSize, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxSize", ConditionKey.CK_GREATER_THAN, maxSize); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxSize_LessThan(Integer maxSize) { + setMaxSize_LessThan(maxSize, null); + } + + public void setMaxSize_LessThan(Integer maxSize, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxSize", ConditionKey.CK_LESS_THAN, maxSize); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxSize_GreaterEqual(Integer maxSize) { + setMaxSize_GreaterEqual(maxSize, null); + } + + public void setMaxSize_GreaterEqual(Integer maxSize, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxSize", ConditionKey.CK_GREATER_EQUAL, maxSize); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxSize_LessEqual(Integer maxSize) { + setMaxSize_LessEqual(maxSize, null); + } + + public void setMaxSize_LessEqual(Integer maxSize, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxSize", ConditionKey.CK_LESS_EQUAL, maxSize); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQuery_Term(String query) { + setQuery_Term(query, null); + } + + public void setQuery_Term(String query, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("query", query); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQuery_Terms(Collection queryList) { + setQuery_Terms(queryList, null); + } + + public void setQuery_Terms(Collection queryList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("query", queryList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQuery_InScope(Collection queryList) { + setQuery_Terms(queryList, null); + } + + public void setQuery_InScope(Collection queryList, ConditionOptionCall opLambda) { + setQuery_Terms(queryList, opLambda); + } + + public void setQuery_Prefix(String query) { + setQuery_Prefix(query, null); + } + + public void setQuery_Prefix(String query, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("query", query); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQuery_Exists() { + setQuery_Exists(null); + } + + public void setQuery_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("query"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQuery_Missing() { + setQuery_Missing(null); + } + + public void setQuery_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("query"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQuery_GreaterThan(String query) { + setQuery_GreaterThan(query, null); + } + + public void setQuery_GreaterThan(String query, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("query", ConditionKey.CK_GREATER_THAN, query); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQuery_LessThan(String query) { + setQuery_LessThan(query, null); + } + + public void setQuery_LessThan(String query, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("query", ConditionKey.CK_LESS_THAN, query); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQuery_GreaterEqual(String query) { + setQuery_GreaterEqual(query, null); + } + + public void setQuery_GreaterEqual(String query, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("query", ConditionKey.CK_GREATER_EQUAL, query); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQuery_LessEqual(String query) { + setQuery_LessEqual(query, null); + } + + public void setQuery_LessEqual(String query, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("query", ConditionKey.CK_LESS_EQUAL, query); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTerm_Term(String term) { + setTerm_Term(term, null); + } + + public void setTerm_Term(String term, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("term", term); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTerm_Terms(Collection termList) { + setTerm_Terms(termList, null); + } + + public void setTerm_Terms(Collection termList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("term", termList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTerm_InScope(Collection termList) { + setTerm_Terms(termList, null); + } + + public void setTerm_InScope(Collection termList, ConditionOptionCall opLambda) { + setTerm_Terms(termList, opLambda); + } + + public void setTerm_Prefix(String term) { + setTerm_Prefix(term, null); + } + + public void setTerm_Prefix(String term, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("term", term); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTerm_Exists() { + setTerm_Exists(null); + } + + public void setTerm_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("term"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTerm_Missing() { + setTerm_Missing(null); + } + + public void setTerm_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("term"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTerm_GreaterThan(String term) { + setTerm_GreaterThan(term, null); + } + + public void setTerm_GreaterThan(String term, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("term", ConditionKey.CK_GREATER_THAN, term); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTerm_LessThan(String term) { + setTerm_LessThan(term, null); + } + + public void setTerm_LessThan(String term, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("term", ConditionKey.CK_LESS_THAN, term); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTerm_GreaterEqual(String term) { + setTerm_GreaterEqual(term, null); + } + + public void setTerm_GreaterEqual(String term, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("term", ConditionKey.CK_GREATER_EQUAL, term); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTerm_LessEqual(String term) { + setTerm_LessEqual(term, null); + } + + public void setTerm_LessEqual(String term, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("term", ConditionKey.CK_LESS_EQUAL, term); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsLabelToRoleCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsLabelToRoleCF.java new file mode 100644 index 000000000..5accfe9aa --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsLabelToRoleCF.java @@ -0,0 +1,430 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.LabelToRoleCF; +import org.codelibs.fess.es.cbean.cq.LabelToRoleCQ; +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 BsLabelToRoleCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + LabelToRoleCF mustFilter = new LabelToRoleCF(); + LabelToRoleCF shouldFilter = new LabelToRoleCF(); + LabelToRoleCF mustNotFilter = new LabelToRoleCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + LabelToRoleCF andFilter = new LabelToRoleCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + LabelToRoleCF orFilter = new LabelToRoleCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + LabelToRoleCF notFilter = new LabelToRoleCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + LabelToRoleCQ query = new LabelToRoleCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Term(String labelTypeId) { + setLabelTypeId_Term(labelTypeId, null); + } + + public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("labelTypeId", labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Terms(Collection labelTypeIdList) { + setLabelTypeId_Terms(labelTypeIdList, null); + } + + public void setLabelTypeId_Terms(Collection labelTypeIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("labelTypeId", labelTypeIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_InScope(Collection labelTypeIdList) { + setLabelTypeId_Terms(labelTypeIdList, null); + } + + public void setLabelTypeId_InScope(Collection labelTypeIdList, ConditionOptionCall opLambda) { + setLabelTypeId_Terms(labelTypeIdList, opLambda); + } + + public void setLabelTypeId_Prefix(String labelTypeId) { + setLabelTypeId_Prefix(labelTypeId, null); + } + + public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("labelTypeId", labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Exists() { + setLabelTypeId_Exists(null); + } + + public void setLabelTypeId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("labelTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Missing() { + setLabelTypeId_Missing(null); + } + + public void setLabelTypeId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("labelTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_GreaterThan(String labelTypeId) { + setLabelTypeId_GreaterThan(labelTypeId, null); + } + + public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_LessThan(String labelTypeId) { + setLabelTypeId_LessThan(labelTypeId, null); + } + + public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_GreaterEqual(String labelTypeId) { + setLabelTypeId_GreaterEqual(labelTypeId, null); + } + + public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_LessEqual(String labelTypeId) { + setLabelTypeId_LessEqual(labelTypeId, null); + } + + public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Term(String roleTypeId) { + setRoleTypeId_Term(roleTypeId, null); + } + + public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("roleTypeId", roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Terms(Collection roleTypeIdList) { + setRoleTypeId_Terms(roleTypeIdList, null); + } + + public void setRoleTypeId_Terms(Collection roleTypeIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("roleTypeId", roleTypeIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_InScope(Collection roleTypeIdList) { + setRoleTypeId_Terms(roleTypeIdList, null); + } + + public void setRoleTypeId_InScope(Collection roleTypeIdList, ConditionOptionCall opLambda) { + setRoleTypeId_Terms(roleTypeIdList, opLambda); + } + + public void setRoleTypeId_Prefix(String roleTypeId) { + setRoleTypeId_Prefix(roleTypeId, null); + } + + public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("roleTypeId", roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Exists() { + setRoleTypeId_Exists(null); + } + + public void setRoleTypeId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("roleTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Missing() { + setRoleTypeId_Missing(null); + } + + public void setRoleTypeId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("roleTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_GreaterThan(String roleTypeId) { + setRoleTypeId_GreaterThan(roleTypeId, null); + } + + public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_LessThan(String roleTypeId) { + setRoleTypeId_LessThan(roleTypeId, null); + } + + public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_GreaterEqual(String roleTypeId) { + setRoleTypeId_GreaterEqual(roleTypeId, null); + } + + public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_LessEqual(String roleTypeId) { + setRoleTypeId_LessEqual(roleTypeId, null); + } + + public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsLabelTypeCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsLabelTypeCF.java new file mode 100644 index 000000000..fb4d6bc51 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsLabelTypeCF.java @@ -0,0 +1,1146 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.LabelTypeCF; +import org.codelibs.fess.es.cbean.cq.LabelTypeCQ; +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 BsLabelTypeCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + LabelTypeCF mustFilter = new LabelTypeCF(); + LabelTypeCF shouldFilter = new LabelTypeCF(); + LabelTypeCF mustNotFilter = new LabelTypeCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + LabelTypeCF andFilter = new LabelTypeCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + LabelTypeCF orFilter = new LabelTypeCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + LabelTypeCF notFilter = new LabelTypeCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + LabelTypeCQ query = new LabelTypeCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_Term(String excludedPaths) { + setExcludedPaths_Term(excludedPaths, null); + } + + public void setExcludedPaths_Term(String excludedPaths, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("excludedPaths", excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_Terms(Collection excludedPathsList) { + setExcludedPaths_Terms(excludedPathsList, null); + } + + public void setExcludedPaths_Terms(Collection excludedPathsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("excludedPaths", excludedPathsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_InScope(Collection excludedPathsList) { + setExcludedPaths_Terms(excludedPathsList, null); + } + + public void setExcludedPaths_InScope(Collection excludedPathsList, ConditionOptionCall opLambda) { + setExcludedPaths_Terms(excludedPathsList, opLambda); + } + + public void setExcludedPaths_Prefix(String excludedPaths) { + setExcludedPaths_Prefix(excludedPaths, null); + } + + public void setExcludedPaths_Prefix(String excludedPaths, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("excludedPaths", excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_Exists() { + setExcludedPaths_Exists(null); + } + + public void setExcludedPaths_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("excludedPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_Missing() { + setExcludedPaths_Missing(null); + } + + public void setExcludedPaths_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("excludedPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_GreaterThan(String excludedPaths) { + setExcludedPaths_GreaterThan(excludedPaths, null); + } + + public void setExcludedPaths_GreaterThan(String excludedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_GREATER_THAN, excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_LessThan(String excludedPaths) { + setExcludedPaths_LessThan(excludedPaths, null); + } + + public void setExcludedPaths_LessThan(String excludedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_LESS_THAN, excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_GreaterEqual(String excludedPaths) { + setExcludedPaths_GreaterEqual(excludedPaths, null); + } + + public void setExcludedPaths_GreaterEqual(String excludedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_GREATER_EQUAL, excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedPaths_LessEqual(String excludedPaths) { + setExcludedPaths_LessEqual(excludedPaths, null); + } + + public void setExcludedPaths_LessEqual(String excludedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedPaths", ConditionKey.CK_LESS_EQUAL, excludedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_Term(String includedPaths) { + setIncludedPaths_Term(includedPaths, null); + } + + public void setIncludedPaths_Term(String includedPaths, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("includedPaths", includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_Terms(Collection includedPathsList) { + setIncludedPaths_Terms(includedPathsList, null); + } + + public void setIncludedPaths_Terms(Collection includedPathsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("includedPaths", includedPathsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_InScope(Collection includedPathsList) { + setIncludedPaths_Terms(includedPathsList, null); + } + + public void setIncludedPaths_InScope(Collection includedPathsList, ConditionOptionCall opLambda) { + setIncludedPaths_Terms(includedPathsList, opLambda); + } + + public void setIncludedPaths_Prefix(String includedPaths) { + setIncludedPaths_Prefix(includedPaths, null); + } + + public void setIncludedPaths_Prefix(String includedPaths, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("includedPaths", includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_Exists() { + setIncludedPaths_Exists(null); + } + + public void setIncludedPaths_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("includedPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_Missing() { + setIncludedPaths_Missing(null); + } + + public void setIncludedPaths_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("includedPaths"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_GreaterThan(String includedPaths) { + setIncludedPaths_GreaterThan(includedPaths, null); + } + + public void setIncludedPaths_GreaterThan(String includedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_GREATER_THAN, includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_LessThan(String includedPaths) { + setIncludedPaths_LessThan(includedPaths, null); + } + + public void setIncludedPaths_LessThan(String includedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_LESS_THAN, includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_GreaterEqual(String includedPaths) { + setIncludedPaths_GreaterEqual(includedPaths, null); + } + + public void setIncludedPaths_GreaterEqual(String includedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_GREATER_EQUAL, includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedPaths_LessEqual(String includedPaths) { + setIncludedPaths_LessEqual(includedPaths, null); + } + + public void setIncludedPaths_LessEqual(String includedPaths, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedPaths", ConditionKey.CK_LESS_EQUAL, includedPaths); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Term(String name) { + setName_Term(name, null); + } + + public void setName_Term(String name, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Terms(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("name", nameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_InScope(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { + setName_Terms(nameList, opLambda); + } + + public void setName_Prefix(String name) { + setName_Prefix(name, null); + } + + public void setName_Prefix(String name, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Exists() { + setName_Exists(null); + } + + public void setName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Missing() { + setName_Missing(null); + } + + public void setName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterThan(String name) { + setName_GreaterThan(name, null); + } + + public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessThan(String name) { + setName_LessThan(name, null); + } + + public void setName_LessThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterEqual(String name) { + setName_GreaterEqual(name, null); + } + + public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessEqual(String name) { + setName_LessEqual(name, null); + } + + public void setName_LessEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Term(Integer sortOrder) { + setSortOrder_Term(sortOrder, null); + } + + public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("sortOrder", sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Terms(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_InScope(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { + setSortOrder_Terms(sortOrderList, opLambda); + } + + public void setSortOrder_Exists() { + setSortOrder_Exists(null); + } + + public void setSortOrder_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Missing() { + setSortOrder_Missing(null); + } + + public void setSortOrder_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterThan(Integer sortOrder) { + setSortOrder_GreaterThan(sortOrder, null); + } + + public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessThan(Integer sortOrder) { + setSortOrder_LessThan(sortOrder, null); + } + + public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterEqual(Integer sortOrder) { + setSortOrder_GreaterEqual(sortOrder, null); + } + + public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessEqual(Integer sortOrder) { + setSortOrder_LessEqual(sortOrder, null); + } + + public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Term(String value) { + setValue_Term(value, null); + } + + public void setValue_Term(String value, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("value", value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Terms(Collection valueList) { + setValue_Terms(valueList, null); + } + + public void setValue_Terms(Collection valueList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("value", valueList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_InScope(Collection valueList) { + setValue_Terms(valueList, null); + } + + public void setValue_InScope(Collection valueList, ConditionOptionCall opLambda) { + setValue_Terms(valueList, opLambda); + } + + public void setValue_Prefix(String value) { + setValue_Prefix(value, null); + } + + public void setValue_Prefix(String value, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("value", value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Exists() { + setValue_Exists(null); + } + + public void setValue_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("value"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Missing() { + setValue_Missing(null); + } + + public void setValue_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("value"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_GreaterThan(String value) { + setValue_GreaterThan(value, null); + } + + public void setValue_GreaterThan(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_THAN, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_LessThan(String value) { + setValue_LessThan(value, null); + } + + public void setValue_LessThan(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_THAN, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_GreaterEqual(String value) { + setValue_GreaterEqual(value, null); + } + + public void setValue_GreaterEqual(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_EQUAL, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_LessEqual(String value) { + setValue_LessEqual(value, null); + } + + public void setValue_LessEqual(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_EQUAL, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsOverlappingHostCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsOverlappingHostCF.java new file mode 100644 index 000000000..2672ad965 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsOverlappingHostCF.java @@ -0,0 +1,932 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.OverlappingHostCF; +import org.codelibs.fess.es.cbean.cq.OverlappingHostCQ; +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 BsOverlappingHostCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + OverlappingHostCF mustFilter = new OverlappingHostCF(); + OverlappingHostCF shouldFilter = new OverlappingHostCF(); + OverlappingHostCF mustNotFilter = new OverlappingHostCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + OverlappingHostCF andFilter = new OverlappingHostCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + OverlappingHostCF orFilter = new OverlappingHostCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + OverlappingHostCF notFilter = new OverlappingHostCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + OverlappingHostCQ query = new OverlappingHostCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setOverlappingName_Term(String overlappingName) { + setOverlappingName_Term(overlappingName, null); + } + + public void setOverlappingName_Term(String overlappingName, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("overlappingName", overlappingName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setOverlappingName_Terms(Collection overlappingNameList) { + setOverlappingName_Terms(overlappingNameList, null); + } + + public void setOverlappingName_Terms(Collection overlappingNameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("overlappingName", overlappingNameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setOverlappingName_InScope(Collection overlappingNameList) { + setOverlappingName_Terms(overlappingNameList, null); + } + + public void setOverlappingName_InScope(Collection overlappingNameList, ConditionOptionCall opLambda) { + setOverlappingName_Terms(overlappingNameList, opLambda); + } + + public void setOverlappingName_Prefix(String overlappingName) { + setOverlappingName_Prefix(overlappingName, null); + } + + public void setOverlappingName_Prefix(String overlappingName, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("overlappingName", overlappingName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setOverlappingName_Exists() { + setOverlappingName_Exists(null); + } + + public void setOverlappingName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("overlappingName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setOverlappingName_Missing() { + setOverlappingName_Missing(null); + } + + public void setOverlappingName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("overlappingName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setOverlappingName_GreaterThan(String overlappingName) { + setOverlappingName_GreaterThan(overlappingName, null); + } + + public void setOverlappingName_GreaterThan(String overlappingName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("overlappingName", ConditionKey.CK_GREATER_THAN, overlappingName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setOverlappingName_LessThan(String overlappingName) { + setOverlappingName_LessThan(overlappingName, null); + } + + public void setOverlappingName_LessThan(String overlappingName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("overlappingName", ConditionKey.CK_LESS_THAN, overlappingName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setOverlappingName_GreaterEqual(String overlappingName) { + setOverlappingName_GreaterEqual(overlappingName, null); + } + + public void setOverlappingName_GreaterEqual(String overlappingName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("overlappingName", ConditionKey.CK_GREATER_EQUAL, overlappingName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setOverlappingName_LessEqual(String overlappingName) { + setOverlappingName_LessEqual(overlappingName, null); + } + + public void setOverlappingName_LessEqual(String overlappingName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("overlappingName", ConditionKey.CK_LESS_EQUAL, overlappingName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegularName_Term(String regularName) { + setRegularName_Term(regularName, null); + } + + public void setRegularName_Term(String regularName, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("regularName", regularName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegularName_Terms(Collection regularNameList) { + setRegularName_Terms(regularNameList, null); + } + + public void setRegularName_Terms(Collection regularNameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("regularName", regularNameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegularName_InScope(Collection regularNameList) { + setRegularName_Terms(regularNameList, null); + } + + public void setRegularName_InScope(Collection regularNameList, ConditionOptionCall opLambda) { + setRegularName_Terms(regularNameList, opLambda); + } + + public void setRegularName_Prefix(String regularName) { + setRegularName_Prefix(regularName, null); + } + + public void setRegularName_Prefix(String regularName, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("regularName", regularName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegularName_Exists() { + setRegularName_Exists(null); + } + + public void setRegularName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("regularName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegularName_Missing() { + setRegularName_Missing(null); + } + + public void setRegularName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("regularName"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegularName_GreaterThan(String regularName) { + setRegularName_GreaterThan(regularName, null); + } + + public void setRegularName_GreaterThan(String regularName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("regularName", ConditionKey.CK_GREATER_THAN, regularName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegularName_LessThan(String regularName) { + setRegularName_LessThan(regularName, null); + } + + public void setRegularName_LessThan(String regularName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("regularName", ConditionKey.CK_LESS_THAN, regularName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegularName_GreaterEqual(String regularName) { + setRegularName_GreaterEqual(regularName, null); + } + + public void setRegularName_GreaterEqual(String regularName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("regularName", ConditionKey.CK_GREATER_EQUAL, regularName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegularName_LessEqual(String regularName) { + setRegularName_LessEqual(regularName, null); + } + + public void setRegularName_LessEqual(String regularName, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("regularName", ConditionKey.CK_LESS_EQUAL, regularName); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Term(Integer sortOrder) { + setSortOrder_Term(sortOrder, null); + } + + public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("sortOrder", sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Terms(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_InScope(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { + setSortOrder_Terms(sortOrderList, opLambda); + } + + public void setSortOrder_Exists() { + setSortOrder_Exists(null); + } + + public void setSortOrder_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Missing() { + setSortOrder_Missing(null); + } + + public void setSortOrder_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterThan(Integer sortOrder) { + setSortOrder_GreaterThan(sortOrder, null); + } + + public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessThan(Integer sortOrder) { + setSortOrder_LessThan(sortOrder, null); + } + + public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterEqual(Integer sortOrder) { + setSortOrder_GreaterEqual(sortOrder, null); + } + + public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessEqual(Integer sortOrder) { + setSortOrder_LessEqual(sortOrder, null); + } + + public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsPathMappingCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsPathMappingCF.java new file mode 100644 index 000000000..fa2041543 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsPathMappingCF.java @@ -0,0 +1,1039 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.PathMappingCF; +import org.codelibs.fess.es.cbean.cq.PathMappingCQ; +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 BsPathMappingCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + PathMappingCF mustFilter = new PathMappingCF(); + PathMappingCF shouldFilter = new PathMappingCF(); + PathMappingCF mustNotFilter = new PathMappingCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + PathMappingCF andFilter = new PathMappingCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + PathMappingCF orFilter = new PathMappingCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + PathMappingCF notFilter = new PathMappingCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + PathMappingCQ query = new PathMappingCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProcessType_Term(String processType) { + setProcessType_Term(processType, null); + } + + public void setProcessType_Term(String processType, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("processType", processType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProcessType_Terms(Collection processTypeList) { + setProcessType_Terms(processTypeList, null); + } + + public void setProcessType_Terms(Collection processTypeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("processType", processTypeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProcessType_InScope(Collection processTypeList) { + setProcessType_Terms(processTypeList, null); + } + + public void setProcessType_InScope(Collection processTypeList, ConditionOptionCall opLambda) { + setProcessType_Terms(processTypeList, opLambda); + } + + public void setProcessType_Prefix(String processType) { + setProcessType_Prefix(processType, null); + } + + public void setProcessType_Prefix(String processType, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("processType", processType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProcessType_Exists() { + setProcessType_Exists(null); + } + + public void setProcessType_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("processType"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProcessType_Missing() { + setProcessType_Missing(null); + } + + public void setProcessType_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("processType"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProcessType_GreaterThan(String processType) { + setProcessType_GreaterThan(processType, null); + } + + public void setProcessType_GreaterThan(String processType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("processType", ConditionKey.CK_GREATER_THAN, processType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProcessType_LessThan(String processType) { + setProcessType_LessThan(processType, null); + } + + public void setProcessType_LessThan(String processType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("processType", ConditionKey.CK_LESS_THAN, processType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProcessType_GreaterEqual(String processType) { + setProcessType_GreaterEqual(processType, null); + } + + public void setProcessType_GreaterEqual(String processType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("processType", ConditionKey.CK_GREATER_EQUAL, processType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProcessType_LessEqual(String processType) { + setProcessType_LessEqual(processType, null); + } + + public void setProcessType_LessEqual(String processType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("processType", ConditionKey.CK_LESS_EQUAL, processType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegex_Term(String regex) { + setRegex_Term(regex, null); + } + + public void setRegex_Term(String regex, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("regex", regex); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegex_Terms(Collection regexList) { + setRegex_Terms(regexList, null); + } + + public void setRegex_Terms(Collection regexList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("regex", regexList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegex_InScope(Collection regexList) { + setRegex_Terms(regexList, null); + } + + public void setRegex_InScope(Collection regexList, ConditionOptionCall opLambda) { + setRegex_Terms(regexList, opLambda); + } + + public void setRegex_Prefix(String regex) { + setRegex_Prefix(regex, null); + } + + public void setRegex_Prefix(String regex, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("regex", regex); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegex_Exists() { + setRegex_Exists(null); + } + + public void setRegex_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("regex"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegex_Missing() { + setRegex_Missing(null); + } + + public void setRegex_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("regex"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegex_GreaterThan(String regex) { + setRegex_GreaterThan(regex, null); + } + + public void setRegex_GreaterThan(String regex, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("regex", ConditionKey.CK_GREATER_THAN, regex); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegex_LessThan(String regex) { + setRegex_LessThan(regex, null); + } + + public void setRegex_LessThan(String regex, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("regex", ConditionKey.CK_LESS_THAN, regex); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegex_GreaterEqual(String regex) { + setRegex_GreaterEqual(regex, null); + } + + public void setRegex_GreaterEqual(String regex, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("regex", ConditionKey.CK_GREATER_EQUAL, regex); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRegex_LessEqual(String regex) { + setRegex_LessEqual(regex, null); + } + + public void setRegex_LessEqual(String regex, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("regex", ConditionKey.CK_LESS_EQUAL, regex); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReplacement_Term(String replacement) { + setReplacement_Term(replacement, null); + } + + public void setReplacement_Term(String replacement, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("replacement", replacement); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReplacement_Terms(Collection replacementList) { + setReplacement_Terms(replacementList, null); + } + + public void setReplacement_Terms(Collection replacementList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("replacement", replacementList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReplacement_InScope(Collection replacementList) { + setReplacement_Terms(replacementList, null); + } + + public void setReplacement_InScope(Collection replacementList, ConditionOptionCall opLambda) { + setReplacement_Terms(replacementList, opLambda); + } + + public void setReplacement_Prefix(String replacement) { + setReplacement_Prefix(replacement, null); + } + + public void setReplacement_Prefix(String replacement, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("replacement", replacement); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReplacement_Exists() { + setReplacement_Exists(null); + } + + public void setReplacement_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("replacement"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReplacement_Missing() { + setReplacement_Missing(null); + } + + public void setReplacement_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("replacement"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReplacement_GreaterThan(String replacement) { + setReplacement_GreaterThan(replacement, null); + } + + public void setReplacement_GreaterThan(String replacement, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("replacement", ConditionKey.CK_GREATER_THAN, replacement); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReplacement_LessThan(String replacement) { + setReplacement_LessThan(replacement, null); + } + + public void setReplacement_LessThan(String replacement, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("replacement", ConditionKey.CK_LESS_THAN, replacement); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReplacement_GreaterEqual(String replacement) { + setReplacement_GreaterEqual(replacement, null); + } + + public void setReplacement_GreaterEqual(String replacement, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("replacement", ConditionKey.CK_GREATER_EQUAL, replacement); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReplacement_LessEqual(String replacement) { + setReplacement_LessEqual(replacement, null); + } + + public void setReplacement_LessEqual(String replacement, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("replacement", ConditionKey.CK_LESS_EQUAL, replacement); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Term(Integer sortOrder) { + setSortOrder_Term(sortOrder, null); + } + + public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("sortOrder", sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Terms(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_InScope(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { + setSortOrder_Terms(sortOrderList, opLambda); + } + + public void setSortOrder_Exists() { + setSortOrder_Exists(null); + } + + public void setSortOrder_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Missing() { + setSortOrder_Missing(null); + } + + public void setSortOrder_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterThan(Integer sortOrder) { + setSortOrder_GreaterThan(sortOrder, null); + } + + public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessThan(Integer sortOrder) { + setSortOrder_LessThan(sortOrder, null); + } + + public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterEqual(Integer sortOrder) { + setSortOrder_GreaterEqual(sortOrder, null); + } + + public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessEqual(Integer sortOrder) { + setSortOrder_LessEqual(sortOrder, null); + } + + public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsRequestHeaderCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsRequestHeaderCF.java new file mode 100644 index 000000000..92d166b06 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsRequestHeaderCF.java @@ -0,0 +1,943 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.RequestHeaderCF; +import org.codelibs.fess.es.cbean.cq.RequestHeaderCQ; +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 BsRequestHeaderCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + RequestHeaderCF mustFilter = new RequestHeaderCF(); + RequestHeaderCF shouldFilter = new RequestHeaderCF(); + RequestHeaderCF mustNotFilter = new RequestHeaderCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + RequestHeaderCF andFilter = new RequestHeaderCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + RequestHeaderCF orFilter = new RequestHeaderCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + RequestHeaderCF notFilter = new RequestHeaderCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + RequestHeaderCQ query = new RequestHeaderCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Term(String name) { + setName_Term(name, null); + } + + public void setName_Term(String name, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Terms(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("name", nameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_InScope(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { + setName_Terms(nameList, opLambda); + } + + public void setName_Prefix(String name) { + setName_Prefix(name, null); + } + + public void setName_Prefix(String name, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Exists() { + setName_Exists(null); + } + + public void setName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Missing() { + setName_Missing(null); + } + + public void setName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterThan(String name) { + setName_GreaterThan(name, null); + } + + public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessThan(String name) { + setName_LessThan(name, null); + } + + public void setName_LessThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterEqual(String name) { + setName_GreaterEqual(name, null); + } + + public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessEqual(String name) { + setName_LessEqual(name, null); + } + + public void setName_LessEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Term(String value) { + setValue_Term(value, null); + } + + public void setValue_Term(String value, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("value", value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Terms(Collection valueList) { + setValue_Terms(valueList, null); + } + + public void setValue_Terms(Collection valueList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("value", valueList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_InScope(Collection valueList) { + setValue_Terms(valueList, null); + } + + public void setValue_InScope(Collection valueList, ConditionOptionCall opLambda) { + setValue_Terms(valueList, opLambda); + } + + public void setValue_Prefix(String value) { + setValue_Prefix(value, null); + } + + public void setValue_Prefix(String value, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("value", value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Exists() { + setValue_Exists(null); + } + + public void setValue_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("value"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Missing() { + setValue_Missing(null); + } + + public void setValue_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("value"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_GreaterThan(String value) { + setValue_GreaterThan(value, null); + } + + public void setValue_GreaterThan(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_THAN, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_LessThan(String value) { + setValue_LessThan(value, null); + } + + public void setValue_LessThan(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_THAN, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_GreaterEqual(String value) { + setValue_GreaterEqual(value, null); + } + + public void setValue_GreaterEqual(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_EQUAL, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_LessEqual(String value) { + setValue_LessEqual(value, null); + } + + public void setValue_LessEqual(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_EQUAL, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Term(String webConfigId) { + setWebConfigId_Term(webConfigId, null); + } + + public void setWebConfigId_Term(String webConfigId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("webConfigId", webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Terms(Collection webConfigIdList) { + setWebConfigId_Terms(webConfigIdList, null); + } + + public void setWebConfigId_Terms(Collection webConfigIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("webConfigId", webConfigIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_InScope(Collection webConfigIdList) { + setWebConfigId_Terms(webConfigIdList, null); + } + + public void setWebConfigId_InScope(Collection webConfigIdList, ConditionOptionCall opLambda) { + setWebConfigId_Terms(webConfigIdList, opLambda); + } + + public void setWebConfigId_Prefix(String webConfigId) { + setWebConfigId_Prefix(webConfigId, null); + } + + public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("webConfigId", webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Exists() { + setWebConfigId_Exists(null); + } + + public void setWebConfigId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("webConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Missing() { + setWebConfigId_Missing(null); + } + + public void setWebConfigId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("webConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_GreaterThan(String webConfigId) { + setWebConfigId_GreaterThan(webConfigId, null); + } + + public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_LessThan(String webConfigId) { + setWebConfigId_LessThan(webConfigId, null); + } + + public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_GreaterEqual(String webConfigId) { + setWebConfigId_GreaterEqual(webConfigId, null); + } + + public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_LessEqual(String webConfigId) { + setWebConfigId_LessEqual(webConfigId, null); + } + + public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsRoleTypeCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsRoleTypeCF.java new file mode 100644 index 000000000..177e9c2ce --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsRoleTypeCF.java @@ -0,0 +1,932 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.RoleTypeCF; +import org.codelibs.fess.es.cbean.cq.RoleTypeCQ; +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 BsRoleTypeCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + RoleTypeCF mustFilter = new RoleTypeCF(); + RoleTypeCF shouldFilter = new RoleTypeCF(); + RoleTypeCF mustNotFilter = new RoleTypeCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + RoleTypeCF andFilter = new RoleTypeCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + RoleTypeCF orFilter = new RoleTypeCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + RoleTypeCF notFilter = new RoleTypeCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + RoleTypeCQ query = new RoleTypeCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Term(String name) { + setName_Term(name, null); + } + + public void setName_Term(String name, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Terms(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("name", nameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_InScope(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { + setName_Terms(nameList, opLambda); + } + + public void setName_Prefix(String name) { + setName_Prefix(name, null); + } + + public void setName_Prefix(String name, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Exists() { + setName_Exists(null); + } + + public void setName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Missing() { + setName_Missing(null); + } + + public void setName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterThan(String name) { + setName_GreaterThan(name, null); + } + + public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessThan(String name) { + setName_LessThan(name, null); + } + + public void setName_LessThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterEqual(String name) { + setName_GreaterEqual(name, null); + } + + public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessEqual(String name) { + setName_LessEqual(name, null); + } + + public void setName_LessEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Term(Integer sortOrder) { + setSortOrder_Term(sortOrder, null); + } + + public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("sortOrder", sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Terms(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_InScope(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { + setSortOrder_Terms(sortOrderList, opLambda); + } + + public void setSortOrder_Exists() { + setSortOrder_Exists(null); + } + + public void setSortOrder_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Missing() { + setSortOrder_Missing(null); + } + + public void setSortOrder_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterThan(Integer sortOrder) { + setSortOrder_GreaterThan(sortOrder, null); + } + + public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessThan(Integer sortOrder) { + setSortOrder_LessThan(sortOrder, null); + } + + public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterEqual(Integer sortOrder) { + setSortOrder_GreaterEqual(sortOrder, null); + } + + public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessEqual(Integer sortOrder) { + setSortOrder_LessEqual(sortOrder, null); + } + + public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Term(String value) { + setValue_Term(value, null); + } + + public void setValue_Term(String value, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("value", value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Terms(Collection valueList) { + setValue_Terms(valueList, null); + } + + public void setValue_Terms(Collection valueList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("value", valueList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_InScope(Collection valueList) { + setValue_Terms(valueList, null); + } + + public void setValue_InScope(Collection valueList, ConditionOptionCall opLambda) { + setValue_Terms(valueList, opLambda); + } + + public void setValue_Prefix(String value) { + setValue_Prefix(value, null); + } + + public void setValue_Prefix(String value, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("value", value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Exists() { + setValue_Exists(null); + } + + public void setValue_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("value"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Missing() { + setValue_Missing(null); + } + + public void setValue_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("value"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_GreaterThan(String value) { + setValue_GreaterThan(value, null); + } + + public void setValue_GreaterThan(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_THAN, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_LessThan(String value) { + setValue_LessThan(value, null); + } + + public void setValue_LessThan(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_THAN, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_GreaterEqual(String value) { + setValue_GreaterEqual(value, null); + } + + public void setValue_GreaterEqual(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_EQUAL, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_LessEqual(String value) { + setValue_LessEqual(value, null); + } + + public void setValue_LessEqual(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_EQUAL, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsScheduledJobCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsScheduledJobCF.java new file mode 100644 index 000000000..f21488410 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsScheduledJobCF.java @@ -0,0 +1,1552 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.ScheduledJobCF; +import org.codelibs.fess.es.cbean.cq.ScheduledJobCQ; +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 BsScheduledJobCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + ScheduledJobCF mustFilter = new ScheduledJobCF(); + ScheduledJobCF shouldFilter = new ScheduledJobCF(); + ScheduledJobCF mustNotFilter = new ScheduledJobCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + ScheduledJobCF andFilter = new ScheduledJobCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + ScheduledJobCF orFilter = new ScheduledJobCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + ScheduledJobCF notFilter = new ScheduledJobCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + ScheduledJobCQ query = new ScheduledJobCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setAvailable_Term(Boolean available) { + setAvailable_Term(available, null); + } + + public void setAvailable_Term(Boolean available, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("available", available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_Terms(Collection availableList) { + setAvailable_Terms(availableList, null); + } + + public void setAvailable_Terms(Collection availableList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("available", availableList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_InScope(Collection availableList) { + setAvailable_Terms(availableList, null); + } + + public void setAvailable_InScope(Collection availableList, ConditionOptionCall opLambda) { + setAvailable_Terms(availableList, opLambda); + } + + public void setAvailable_Exists() { + setAvailable_Exists(null); + } + + public void setAvailable_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("available"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_Missing() { + setAvailable_Missing(null); + } + + public void setAvailable_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("available"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_GreaterThan(Boolean available) { + setAvailable_GreaterThan(available, null); + } + + public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_THAN, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_LessThan(Boolean available) { + setAvailable_LessThan(available, null); + } + + public void setAvailable_LessThan(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_THAN, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_GreaterEqual(Boolean available) { + setAvailable_GreaterEqual(available, null); + } + + public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_EQUAL, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_LessEqual(Boolean available) { + setAvailable_LessEqual(available, null); + } + + public void setAvailable_LessEqual(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_EQUAL, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawler_Term(String crawler) { + setCrawler_Term(crawler, null); + } + + public void setCrawler_Term(String crawler, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("crawler", crawler); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawler_Terms(Collection crawlerList) { + setCrawler_Terms(crawlerList, null); + } + + public void setCrawler_Terms(Collection crawlerList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("crawler", crawlerList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawler_InScope(Collection crawlerList) { + setCrawler_Terms(crawlerList, null); + } + + public void setCrawler_InScope(Collection crawlerList, ConditionOptionCall opLambda) { + setCrawler_Terms(crawlerList, opLambda); + } + + public void setCrawler_Prefix(String crawler) { + setCrawler_Prefix(crawler, null); + } + + public void setCrawler_Prefix(String crawler, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("crawler", crawler); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawler_Exists() { + setCrawler_Exists(null); + } + + public void setCrawler_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("crawler"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawler_Missing() { + setCrawler_Missing(null); + } + + public void setCrawler_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("crawler"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawler_GreaterThan(String crawler) { + setCrawler_GreaterThan(crawler, null); + } + + public void setCrawler_GreaterThan(String crawler, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("crawler", ConditionKey.CK_GREATER_THAN, crawler); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawler_LessThan(String crawler) { + setCrawler_LessThan(crawler, null); + } + + public void setCrawler_LessThan(String crawler, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("crawler", ConditionKey.CK_LESS_THAN, crawler); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawler_GreaterEqual(String crawler) { + setCrawler_GreaterEqual(crawler, null); + } + + public void setCrawler_GreaterEqual(String crawler, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("crawler", ConditionKey.CK_GREATER_EQUAL, crawler); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCrawler_LessEqual(String crawler) { + setCrawler_LessEqual(crawler, null); + } + + public void setCrawler_LessEqual(String crawler, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("crawler", ConditionKey.CK_LESS_EQUAL, crawler); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCronExpression_Term(String cronExpression) { + setCronExpression_Term(cronExpression, null); + } + + public void setCronExpression_Term(String cronExpression, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("cronExpression", cronExpression); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCronExpression_Terms(Collection cronExpressionList) { + setCronExpression_Terms(cronExpressionList, null); + } + + public void setCronExpression_Terms(Collection cronExpressionList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("cronExpression", cronExpressionList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCronExpression_InScope(Collection cronExpressionList) { + setCronExpression_Terms(cronExpressionList, null); + } + + public void setCronExpression_InScope(Collection cronExpressionList, ConditionOptionCall opLambda) { + setCronExpression_Terms(cronExpressionList, opLambda); + } + + public void setCronExpression_Prefix(String cronExpression) { + setCronExpression_Prefix(cronExpression, null); + } + + public void setCronExpression_Prefix(String cronExpression, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("cronExpression", cronExpression); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCronExpression_Exists() { + setCronExpression_Exists(null); + } + + public void setCronExpression_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("cronExpression"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCronExpression_Missing() { + setCronExpression_Missing(null); + } + + public void setCronExpression_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("cronExpression"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCronExpression_GreaterThan(String cronExpression) { + setCronExpression_GreaterThan(cronExpression, null); + } + + public void setCronExpression_GreaterThan(String cronExpression, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("cronExpression", ConditionKey.CK_GREATER_THAN, cronExpression); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCronExpression_LessThan(String cronExpression) { + setCronExpression_LessThan(cronExpression, null); + } + + public void setCronExpression_LessThan(String cronExpression, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("cronExpression", ConditionKey.CK_LESS_THAN, cronExpression); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCronExpression_GreaterEqual(String cronExpression) { + setCronExpression_GreaterEqual(cronExpression, null); + } + + public void setCronExpression_GreaterEqual(String cronExpression, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("cronExpression", ConditionKey.CK_GREATER_EQUAL, cronExpression); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCronExpression_LessEqual(String cronExpression) { + setCronExpression_LessEqual(cronExpression, null); + } + + public void setCronExpression_LessEqual(String cronExpression, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("cronExpression", ConditionKey.CK_LESS_EQUAL, cronExpression); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobLogging_Term(Boolean jobLogging) { + setJobLogging_Term(jobLogging, null); + } + + public void setJobLogging_Term(Boolean jobLogging, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("jobLogging", jobLogging); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobLogging_Terms(Collection jobLoggingList) { + setJobLogging_Terms(jobLoggingList, null); + } + + public void setJobLogging_Terms(Collection jobLoggingList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("jobLogging", jobLoggingList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobLogging_InScope(Collection jobLoggingList) { + setJobLogging_Terms(jobLoggingList, null); + } + + public void setJobLogging_InScope(Collection jobLoggingList, ConditionOptionCall opLambda) { + setJobLogging_Terms(jobLoggingList, opLambda); + } + + public void setJobLogging_Exists() { + setJobLogging_Exists(null); + } + + public void setJobLogging_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("jobLogging"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobLogging_Missing() { + setJobLogging_Missing(null); + } + + public void setJobLogging_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("jobLogging"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobLogging_GreaterThan(Boolean jobLogging) { + setJobLogging_GreaterThan(jobLogging, null); + } + + public void setJobLogging_GreaterThan(Boolean jobLogging, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobLogging", ConditionKey.CK_GREATER_THAN, jobLogging); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobLogging_LessThan(Boolean jobLogging) { + setJobLogging_LessThan(jobLogging, null); + } + + public void setJobLogging_LessThan(Boolean jobLogging, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobLogging", ConditionKey.CK_LESS_THAN, jobLogging); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobLogging_GreaterEqual(Boolean jobLogging) { + setJobLogging_GreaterEqual(jobLogging, null); + } + + public void setJobLogging_GreaterEqual(Boolean jobLogging, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobLogging", ConditionKey.CK_GREATER_EQUAL, jobLogging); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setJobLogging_LessEqual(Boolean jobLogging) { + setJobLogging_LessEqual(jobLogging, null); + } + + public void setJobLogging_LessEqual(Boolean jobLogging, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("jobLogging", ConditionKey.CK_LESS_EQUAL, jobLogging); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Term(String name) { + setName_Term(name, null); + } + + public void setName_Term(String name, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Terms(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("name", nameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_InScope(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { + setName_Terms(nameList, opLambda); + } + + public void setName_Prefix(String name) { + setName_Prefix(name, null); + } + + public void setName_Prefix(String name, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Exists() { + setName_Exists(null); + } + + public void setName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Missing() { + setName_Missing(null); + } + + public void setName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterThan(String name) { + setName_GreaterThan(name, null); + } + + public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessThan(String name) { + setName_LessThan(name, null); + } + + public void setName_LessThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterEqual(String name) { + setName_GreaterEqual(name, null); + } + + public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessEqual(String name) { + setName_LessEqual(name, null); + } + + public void setName_LessEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_Term(String scriptData) { + setScriptData_Term(scriptData, null); + } + + public void setScriptData_Term(String scriptData, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("scriptData", scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_Terms(Collection scriptDataList) { + setScriptData_Terms(scriptDataList, null); + } + + public void setScriptData_Terms(Collection scriptDataList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("scriptData", scriptDataList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_InScope(Collection scriptDataList) { + setScriptData_Terms(scriptDataList, null); + } + + public void setScriptData_InScope(Collection scriptDataList, ConditionOptionCall opLambda) { + setScriptData_Terms(scriptDataList, opLambda); + } + + public void setScriptData_Prefix(String scriptData) { + setScriptData_Prefix(scriptData, null); + } + + public void setScriptData_Prefix(String scriptData, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("scriptData", scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_Exists() { + setScriptData_Exists(null); + } + + public void setScriptData_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("scriptData"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_Missing() { + setScriptData_Missing(null); + } + + public void setScriptData_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("scriptData"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_GreaterThan(String scriptData) { + setScriptData_GreaterThan(scriptData, null); + } + + public void setScriptData_GreaterThan(String scriptData, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_GREATER_THAN, scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_LessThan(String scriptData) { + setScriptData_LessThan(scriptData, null); + } + + public void setScriptData_LessThan(String scriptData, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_LESS_THAN, scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_GreaterEqual(String scriptData) { + setScriptData_GreaterEqual(scriptData, null); + } + + public void setScriptData_GreaterEqual(String scriptData, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_GREATER_EQUAL, scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptData_LessEqual(String scriptData) { + setScriptData_LessEqual(scriptData, null); + } + + public void setScriptData_LessEqual(String scriptData, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptData", ConditionKey.CK_LESS_EQUAL, scriptData); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_Term(String scriptType) { + setScriptType_Term(scriptType, null); + } + + public void setScriptType_Term(String scriptType, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("scriptType", scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_Terms(Collection scriptTypeList) { + setScriptType_Terms(scriptTypeList, null); + } + + public void setScriptType_Terms(Collection scriptTypeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("scriptType", scriptTypeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_InScope(Collection scriptTypeList) { + setScriptType_Terms(scriptTypeList, null); + } + + public void setScriptType_InScope(Collection scriptTypeList, ConditionOptionCall opLambda) { + setScriptType_Terms(scriptTypeList, opLambda); + } + + public void setScriptType_Prefix(String scriptType) { + setScriptType_Prefix(scriptType, null); + } + + public void setScriptType_Prefix(String scriptType, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("scriptType", scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_Exists() { + setScriptType_Exists(null); + } + + public void setScriptType_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("scriptType"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_Missing() { + setScriptType_Missing(null); + } + + public void setScriptType_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("scriptType"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_GreaterThan(String scriptType) { + setScriptType_GreaterThan(scriptType, null); + } + + public void setScriptType_GreaterThan(String scriptType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_GREATER_THAN, scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_LessThan(String scriptType) { + setScriptType_LessThan(scriptType, null); + } + + public void setScriptType_LessThan(String scriptType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_LESS_THAN, scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_GreaterEqual(String scriptType) { + setScriptType_GreaterEqual(scriptType, null); + } + + public void setScriptType_GreaterEqual(String scriptType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_GREATER_EQUAL, scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setScriptType_LessEqual(String scriptType) { + setScriptType_LessEqual(scriptType, null); + } + + public void setScriptType_LessEqual(String scriptType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("scriptType", ConditionKey.CK_LESS_EQUAL, scriptType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Term(Integer sortOrder) { + setSortOrder_Term(sortOrder, null); + } + + public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("sortOrder", sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Terms(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_InScope(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { + setSortOrder_Terms(sortOrderList, opLambda); + } + + public void setSortOrder_Exists() { + setSortOrder_Exists(null); + } + + public void setSortOrder_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Missing() { + setSortOrder_Missing(null); + } + + public void setSortOrder_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterThan(Integer sortOrder) { + setSortOrder_GreaterThan(sortOrder, null); + } + + public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessThan(Integer sortOrder) { + setSortOrder_LessThan(sortOrder, null); + } + + public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterEqual(Integer sortOrder) { + setSortOrder_GreaterEqual(sortOrder, null); + } + + public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessEqual(Integer sortOrder) { + setSortOrder_LessEqual(sortOrder, null); + } + + public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_Term(String target) { + setTarget_Term(target, null); + } + + public void setTarget_Term(String target, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("target", target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_Terms(Collection targetList) { + setTarget_Terms(targetList, null); + } + + public void setTarget_Terms(Collection targetList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("target", targetList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_InScope(Collection targetList) { + setTarget_Terms(targetList, null); + } + + public void setTarget_InScope(Collection targetList, ConditionOptionCall opLambda) { + setTarget_Terms(targetList, opLambda); + } + + public void setTarget_Prefix(String target) { + setTarget_Prefix(target, null); + } + + public void setTarget_Prefix(String target, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("target", target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_Exists() { + setTarget_Exists(null); + } + + public void setTarget_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("target"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_Missing() { + setTarget_Missing(null); + } + + public void setTarget_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("target"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_GreaterThan(String target) { + setTarget_GreaterThan(target, null); + } + + public void setTarget_GreaterThan(String target, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_GREATER_THAN, target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_LessThan(String target) { + setTarget_LessThan(target, null); + } + + public void setTarget_LessThan(String target, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_LESS_THAN, target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_GreaterEqual(String target) { + setTarget_GreaterEqual(target, null); + } + + public void setTarget_GreaterEqual(String target, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_GREATER_EQUAL, target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTarget_LessEqual(String target) { + setTarget_LessEqual(target, null); + } + + public void setTarget_LessEqual(String target, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("target", ConditionKey.CK_LESS_EQUAL, target); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSearchFieldLogCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSearchFieldLogCF.java new file mode 100644 index 000000000..af5c7dcb1 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSearchFieldLogCF.java @@ -0,0 +1,537 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.SearchFieldLogCF; +import org.codelibs.fess.es.cbean.cq.SearchFieldLogCQ; +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 BsSearchFieldLogCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + SearchFieldLogCF mustFilter = new SearchFieldLogCF(); + SearchFieldLogCF shouldFilter = new SearchFieldLogCF(); + SearchFieldLogCF mustNotFilter = new SearchFieldLogCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + SearchFieldLogCF andFilter = new SearchFieldLogCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + SearchFieldLogCF orFilter = new SearchFieldLogCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + SearchFieldLogCF notFilter = new SearchFieldLogCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + SearchFieldLogCQ query = new SearchFieldLogCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Term(String name) { + setName_Term(name, null); + } + + public void setName_Term(String name, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Terms(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("name", nameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_InScope(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { + setName_Terms(nameList, opLambda); + } + + public void setName_Prefix(String name) { + setName_Prefix(name, null); + } + + public void setName_Prefix(String name, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Exists() { + setName_Exists(null); + } + + public void setName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Missing() { + setName_Missing(null); + } + + public void setName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterThan(String name) { + setName_GreaterThan(name, null); + } + + public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessThan(String name) { + setName_LessThan(name, null); + } + + public void setName_LessThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterEqual(String name) { + setName_GreaterEqual(name, null); + } + + public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessEqual(String name) { + setName_LessEqual(name, null); + } + + public void setName_LessEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_Term(String searchLogId) { + setSearchLogId_Term(searchLogId, null); + } + + public void setSearchLogId_Term(String searchLogId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("searchLogId", searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_Terms(Collection searchLogIdList) { + setSearchLogId_Terms(searchLogIdList, null); + } + + public void setSearchLogId_Terms(Collection searchLogIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("searchLogId", searchLogIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_InScope(Collection searchLogIdList) { + setSearchLogId_Terms(searchLogIdList, null); + } + + public void setSearchLogId_InScope(Collection searchLogIdList, ConditionOptionCall opLambda) { + setSearchLogId_Terms(searchLogIdList, opLambda); + } + + public void setSearchLogId_Prefix(String searchLogId) { + setSearchLogId_Prefix(searchLogId, null); + } + + public void setSearchLogId_Prefix(String searchLogId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("searchLogId", searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_Exists() { + setSearchLogId_Exists(null); + } + + public void setSearchLogId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("searchLogId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_Missing() { + setSearchLogId_Missing(null); + } + + public void setSearchLogId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("searchLogId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_GreaterThan(String searchLogId) { + setSearchLogId_GreaterThan(searchLogId, null); + } + + public void setSearchLogId_GreaterThan(String searchLogId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_LessThan(String searchLogId) { + setSearchLogId_LessThan(searchLogId, null); + } + + public void setSearchLogId_LessThan(String searchLogId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_GreaterEqual(String searchLogId) { + setSearchLogId_GreaterEqual(searchLogId, null); + } + + public void setSearchLogId_GreaterEqual(String searchLogId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchLogId_LessEqual(String searchLogId) { + setSearchLogId_LessEqual(searchLogId, null); + } + + public void setSearchLogId_LessEqual(String searchLogId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Term(String value) { + setValue_Term(value, null); + } + + public void setValue_Term(String value, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("value", value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Terms(Collection valueList) { + setValue_Terms(valueList, null); + } + + public void setValue_Terms(Collection valueList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("value", valueList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_InScope(Collection valueList) { + setValue_Terms(valueList, null); + } + + public void setValue_InScope(Collection valueList, ConditionOptionCall opLambda) { + setValue_Terms(valueList, opLambda); + } + + public void setValue_Prefix(String value) { + setValue_Prefix(value, null); + } + + public void setValue_Prefix(String value, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("value", value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Exists() { + setValue_Exists(null); + } + + public void setValue_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("value"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_Missing() { + setValue_Missing(null); + } + + public void setValue_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("value"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_GreaterThan(String value) { + setValue_GreaterThan(value, null); + } + + public void setValue_GreaterThan(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_THAN, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_LessThan(String value) { + setValue_LessThan(value, null); + } + + public void setValue_LessThan(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_THAN, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_GreaterEqual(String value) { + setValue_GreaterEqual(value, null); + } + + public void setValue_GreaterEqual(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_GREATER_EQUAL, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setValue_LessEqual(String value) { + setValue_LessEqual(value, null); + } + + public void setValue_LessEqual(String value, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("value", ConditionKey.CK_LESS_EQUAL, value); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSearchLogCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSearchLogCF.java new file mode 100644 index 000000000..026c5c3ce --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSearchLogCF.java @@ -0,0 +1,1434 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.SearchLogCF; +import org.codelibs.fess.es.cbean.cq.SearchLogCQ; +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 BsSearchLogCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + SearchLogCF mustFilter = new SearchLogCF(); + SearchLogCF shouldFilter = new SearchLogCF(); + SearchLogCF mustNotFilter = new SearchLogCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + SearchLogCF andFilter = new SearchLogCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + SearchLogCF orFilter = new SearchLogCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + SearchLogCF notFilter = new SearchLogCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + SearchLogCQ query = new SearchLogCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setAccessType_Term(String accessType) { + setAccessType_Term(accessType, null); + } + + public void setAccessType_Term(String accessType, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("accessType", accessType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAccessType_Terms(Collection accessTypeList) { + setAccessType_Terms(accessTypeList, null); + } + + public void setAccessType_Terms(Collection accessTypeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("accessType", accessTypeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAccessType_InScope(Collection accessTypeList) { + setAccessType_Terms(accessTypeList, null); + } + + public void setAccessType_InScope(Collection accessTypeList, ConditionOptionCall opLambda) { + setAccessType_Terms(accessTypeList, opLambda); + } + + public void setAccessType_Prefix(String accessType) { + setAccessType_Prefix(accessType, null); + } + + public void setAccessType_Prefix(String accessType, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("accessType", accessType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAccessType_Exists() { + setAccessType_Exists(null); + } + + public void setAccessType_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("accessType"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAccessType_Missing() { + setAccessType_Missing(null); + } + + public void setAccessType_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("accessType"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAccessType_GreaterThan(String accessType) { + setAccessType_GreaterThan(accessType, null); + } + + public void setAccessType_GreaterThan(String accessType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("accessType", ConditionKey.CK_GREATER_THAN, accessType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAccessType_LessThan(String accessType) { + setAccessType_LessThan(accessType, null); + } + + public void setAccessType_LessThan(String accessType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("accessType", ConditionKey.CK_LESS_THAN, accessType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAccessType_GreaterEqual(String accessType) { + setAccessType_GreaterEqual(accessType, null); + } + + public void setAccessType_GreaterEqual(String accessType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("accessType", ConditionKey.CK_GREATER_EQUAL, accessType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAccessType_LessEqual(String accessType) { + setAccessType_LessEqual(accessType, null); + } + + public void setAccessType_LessEqual(String accessType, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("accessType", ConditionKey.CK_LESS_EQUAL, accessType); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setClientIp_Term(String clientIp) { + setClientIp_Term(clientIp, null); + } + + public void setClientIp_Term(String clientIp, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("clientIp", clientIp); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setClientIp_Terms(Collection clientIpList) { + setClientIp_Terms(clientIpList, null); + } + + public void setClientIp_Terms(Collection clientIpList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("clientIp", clientIpList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setClientIp_InScope(Collection clientIpList) { + setClientIp_Terms(clientIpList, null); + } + + public void setClientIp_InScope(Collection clientIpList, ConditionOptionCall opLambda) { + setClientIp_Terms(clientIpList, opLambda); + } + + public void setClientIp_Prefix(String clientIp) { + setClientIp_Prefix(clientIp, null); + } + + public void setClientIp_Prefix(String clientIp, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("clientIp", clientIp); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setClientIp_Exists() { + setClientIp_Exists(null); + } + + public void setClientIp_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("clientIp"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setClientIp_Missing() { + setClientIp_Missing(null); + } + + public void setClientIp_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("clientIp"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setClientIp_GreaterThan(String clientIp) { + setClientIp_GreaterThan(clientIp, null); + } + + public void setClientIp_GreaterThan(String clientIp, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("clientIp", ConditionKey.CK_GREATER_THAN, clientIp); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setClientIp_LessThan(String clientIp) { + setClientIp_LessThan(clientIp, null); + } + + public void setClientIp_LessThan(String clientIp, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("clientIp", ConditionKey.CK_LESS_THAN, clientIp); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setClientIp_GreaterEqual(String clientIp) { + setClientIp_GreaterEqual(clientIp, null); + } + + public void setClientIp_GreaterEqual(String clientIp, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("clientIp", ConditionKey.CK_GREATER_EQUAL, clientIp); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setClientIp_LessEqual(String clientIp) { + setClientIp_LessEqual(clientIp, null); + } + + public void setClientIp_LessEqual(String clientIp, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("clientIp", ConditionKey.CK_LESS_EQUAL, clientIp); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHitCount_Term(Long hitCount) { + setHitCount_Term(hitCount, null); + } + + public void setHitCount_Term(Long hitCount, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("hitCount", hitCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHitCount_Terms(Collection hitCountList) { + setHitCount_Terms(hitCountList, null); + } + + public void setHitCount_Terms(Collection hitCountList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("hitCount", hitCountList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHitCount_InScope(Collection hitCountList) { + setHitCount_Terms(hitCountList, null); + } + + public void setHitCount_InScope(Collection hitCountList, ConditionOptionCall opLambda) { + setHitCount_Terms(hitCountList, opLambda); + } + + public void setHitCount_Exists() { + setHitCount_Exists(null); + } + + public void setHitCount_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("hitCount"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHitCount_Missing() { + setHitCount_Missing(null); + } + + public void setHitCount_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("hitCount"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHitCount_GreaterThan(Long hitCount) { + setHitCount_GreaterThan(hitCount, null); + } + + public void setHitCount_GreaterThan(Long hitCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hitCount", ConditionKey.CK_GREATER_THAN, hitCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHitCount_LessThan(Long hitCount) { + setHitCount_LessThan(hitCount, null); + } + + public void setHitCount_LessThan(Long hitCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hitCount", ConditionKey.CK_LESS_THAN, hitCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHitCount_GreaterEqual(Long hitCount) { + setHitCount_GreaterEqual(hitCount, null); + } + + public void setHitCount_GreaterEqual(Long hitCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hitCount", ConditionKey.CK_GREATER_EQUAL, hitCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHitCount_LessEqual(Long hitCount) { + setHitCount_LessEqual(hitCount, null); + } + + public void setHitCount_LessEqual(Long hitCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hitCount", ConditionKey.CK_LESS_EQUAL, hitCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryOffset_Term(Integer queryOffset) { + setQueryOffset_Term(queryOffset, null); + } + + public void setQueryOffset_Term(Integer queryOffset, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("queryOffset", queryOffset); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryOffset_Terms(Collection queryOffsetList) { + setQueryOffset_Terms(queryOffsetList, null); + } + + public void setQueryOffset_Terms(Collection queryOffsetList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("queryOffset", queryOffsetList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryOffset_InScope(Collection queryOffsetList) { + setQueryOffset_Terms(queryOffsetList, null); + } + + public void setQueryOffset_InScope(Collection queryOffsetList, ConditionOptionCall opLambda) { + setQueryOffset_Terms(queryOffsetList, opLambda); + } + + public void setQueryOffset_Exists() { + setQueryOffset_Exists(null); + } + + public void setQueryOffset_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("queryOffset"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryOffset_Missing() { + setQueryOffset_Missing(null); + } + + public void setQueryOffset_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("queryOffset"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryOffset_GreaterThan(Integer queryOffset) { + setQueryOffset_GreaterThan(queryOffset, null); + } + + public void setQueryOffset_GreaterThan(Integer queryOffset, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("queryOffset", ConditionKey.CK_GREATER_THAN, queryOffset); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryOffset_LessThan(Integer queryOffset) { + setQueryOffset_LessThan(queryOffset, null); + } + + public void setQueryOffset_LessThan(Integer queryOffset, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("queryOffset", ConditionKey.CK_LESS_THAN, queryOffset); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryOffset_GreaterEqual(Integer queryOffset) { + setQueryOffset_GreaterEqual(queryOffset, null); + } + + public void setQueryOffset_GreaterEqual(Integer queryOffset, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("queryOffset", ConditionKey.CK_GREATER_EQUAL, queryOffset); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryOffset_LessEqual(Integer queryOffset) { + setQueryOffset_LessEqual(queryOffset, null); + } + + public void setQueryOffset_LessEqual(Integer queryOffset, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("queryOffset", ConditionKey.CK_LESS_EQUAL, queryOffset); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryPageSize_Term(Integer queryPageSize) { + setQueryPageSize_Term(queryPageSize, null); + } + + public void setQueryPageSize_Term(Integer queryPageSize, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("queryPageSize", queryPageSize); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryPageSize_Terms(Collection queryPageSizeList) { + setQueryPageSize_Terms(queryPageSizeList, null); + } + + public void setQueryPageSize_Terms(Collection queryPageSizeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("queryPageSize", queryPageSizeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryPageSize_InScope(Collection queryPageSizeList) { + setQueryPageSize_Terms(queryPageSizeList, null); + } + + public void setQueryPageSize_InScope(Collection queryPageSizeList, ConditionOptionCall opLambda) { + setQueryPageSize_Terms(queryPageSizeList, opLambda); + } + + public void setQueryPageSize_Exists() { + setQueryPageSize_Exists(null); + } + + public void setQueryPageSize_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("queryPageSize"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryPageSize_Missing() { + setQueryPageSize_Missing(null); + } + + public void setQueryPageSize_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("queryPageSize"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryPageSize_GreaterThan(Integer queryPageSize) { + setQueryPageSize_GreaterThan(queryPageSize, null); + } + + public void setQueryPageSize_GreaterThan(Integer queryPageSize, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("queryPageSize", ConditionKey.CK_GREATER_THAN, queryPageSize); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryPageSize_LessThan(Integer queryPageSize) { + setQueryPageSize_LessThan(queryPageSize, null); + } + + public void setQueryPageSize_LessThan(Integer queryPageSize, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("queryPageSize", ConditionKey.CK_LESS_THAN, queryPageSize); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryPageSize_GreaterEqual(Integer queryPageSize) { + setQueryPageSize_GreaterEqual(queryPageSize, null); + } + + public void setQueryPageSize_GreaterEqual(Integer queryPageSize, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("queryPageSize", ConditionKey.CK_GREATER_EQUAL, queryPageSize); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setQueryPageSize_LessEqual(Integer queryPageSize) { + setQueryPageSize_LessEqual(queryPageSize, null); + } + + public void setQueryPageSize_LessEqual(Integer queryPageSize, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("queryPageSize", ConditionKey.CK_LESS_EQUAL, queryPageSize); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReferer_Term(String referer) { + setReferer_Term(referer, null); + } + + public void setReferer_Term(String referer, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("referer", referer); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReferer_Terms(Collection refererList) { + setReferer_Terms(refererList, null); + } + + public void setReferer_Terms(Collection refererList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("referer", refererList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReferer_InScope(Collection refererList) { + setReferer_Terms(refererList, null); + } + + public void setReferer_InScope(Collection refererList, ConditionOptionCall opLambda) { + setReferer_Terms(refererList, opLambda); + } + + public void setReferer_Prefix(String referer) { + setReferer_Prefix(referer, null); + } + + public void setReferer_Prefix(String referer, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("referer", referer); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReferer_Exists() { + setReferer_Exists(null); + } + + public void setReferer_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("referer"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReferer_Missing() { + setReferer_Missing(null); + } + + public void setReferer_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("referer"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReferer_GreaterThan(String referer) { + setReferer_GreaterThan(referer, null); + } + + public void setReferer_GreaterThan(String referer, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("referer", ConditionKey.CK_GREATER_THAN, referer); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReferer_LessThan(String referer) { + setReferer_LessThan(referer, null); + } + + public void setReferer_LessThan(String referer, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("referer", ConditionKey.CK_LESS_THAN, referer); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReferer_GreaterEqual(String referer) { + setReferer_GreaterEqual(referer, null); + } + + public void setReferer_GreaterEqual(String referer, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("referer", ConditionKey.CK_GREATER_EQUAL, referer); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReferer_LessEqual(String referer) { + setReferer_LessEqual(referer, null); + } + + public void setReferer_LessEqual(String referer, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("referer", ConditionKey.CK_LESS_EQUAL, referer); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_Term(Long requestedTime) { + setRequestedTime_Term(requestedTime, null); + } + + public void setRequestedTime_Term(Long requestedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("requestedTime", requestedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_Terms(Collection requestedTimeList) { + setRequestedTime_Terms(requestedTimeList, null); + } + + public void setRequestedTime_Terms(Collection requestedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("requestedTime", requestedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_InScope(Collection requestedTimeList) { + setRequestedTime_Terms(requestedTimeList, null); + } + + public void setRequestedTime_InScope(Collection requestedTimeList, ConditionOptionCall opLambda) { + setRequestedTime_Terms(requestedTimeList, opLambda); + } + + public void setRequestedTime_Exists() { + setRequestedTime_Exists(null); + } + + public void setRequestedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("requestedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_Missing() { + setRequestedTime_Missing(null); + } + + public void setRequestedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("requestedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_GreaterThan(Long requestedTime) { + setRequestedTime_GreaterThan(requestedTime, null); + } + + public void setRequestedTime_GreaterThan(Long requestedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_GREATER_THAN, requestedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_LessThan(Long requestedTime) { + setRequestedTime_LessThan(requestedTime, null); + } + + public void setRequestedTime_LessThan(Long requestedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_LESS_THAN, requestedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_GreaterEqual(Long requestedTime) { + setRequestedTime_GreaterEqual(requestedTime, null); + } + + public void setRequestedTime_GreaterEqual(Long requestedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_GREATER_EQUAL, requestedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRequestedTime_LessEqual(Long requestedTime) { + setRequestedTime_LessEqual(requestedTime, null); + } + + public void setRequestedTime_LessEqual(Long requestedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("requestedTime", ConditionKey.CK_LESS_EQUAL, requestedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setResponseTime_Term(Integer responseTime) { + setResponseTime_Term(responseTime, null); + } + + public void setResponseTime_Term(Integer responseTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("responseTime", responseTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setResponseTime_Terms(Collection responseTimeList) { + setResponseTime_Terms(responseTimeList, null); + } + + public void setResponseTime_Terms(Collection responseTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("responseTime", responseTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setResponseTime_InScope(Collection responseTimeList) { + setResponseTime_Terms(responseTimeList, null); + } + + public void setResponseTime_InScope(Collection responseTimeList, ConditionOptionCall opLambda) { + setResponseTime_Terms(responseTimeList, opLambda); + } + + public void setResponseTime_Exists() { + setResponseTime_Exists(null); + } + + public void setResponseTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("responseTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setResponseTime_Missing() { + setResponseTime_Missing(null); + } + + public void setResponseTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("responseTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setResponseTime_GreaterThan(Integer responseTime) { + setResponseTime_GreaterThan(responseTime, null); + } + + public void setResponseTime_GreaterThan(Integer responseTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("responseTime", ConditionKey.CK_GREATER_THAN, responseTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setResponseTime_LessThan(Integer responseTime) { + setResponseTime_LessThan(responseTime, null); + } + + public void setResponseTime_LessThan(Integer responseTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("responseTime", ConditionKey.CK_LESS_THAN, responseTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setResponseTime_GreaterEqual(Integer responseTime) { + setResponseTime_GreaterEqual(responseTime, null); + } + + public void setResponseTime_GreaterEqual(Integer responseTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("responseTime", ConditionKey.CK_GREATER_EQUAL, responseTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setResponseTime_LessEqual(Integer responseTime) { + setResponseTime_LessEqual(responseTime, null); + } + + public void setResponseTime_LessEqual(Integer responseTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("responseTime", ConditionKey.CK_LESS_EQUAL, responseTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchWord_Term(String searchWord) { + setSearchWord_Term(searchWord, null); + } + + public void setSearchWord_Term(String searchWord, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("searchWord", searchWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchWord_Terms(Collection searchWordList) { + setSearchWord_Terms(searchWordList, null); + } + + public void setSearchWord_Terms(Collection searchWordList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("searchWord", searchWordList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchWord_InScope(Collection searchWordList) { + setSearchWord_Terms(searchWordList, null); + } + + public void setSearchWord_InScope(Collection searchWordList, ConditionOptionCall opLambda) { + setSearchWord_Terms(searchWordList, opLambda); + } + + public void setSearchWord_Prefix(String searchWord) { + setSearchWord_Prefix(searchWord, null); + } + + public void setSearchWord_Prefix(String searchWord, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("searchWord", searchWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchWord_Exists() { + setSearchWord_Exists(null); + } + + public void setSearchWord_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("searchWord"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchWord_Missing() { + setSearchWord_Missing(null); + } + + public void setSearchWord_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("searchWord"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchWord_GreaterThan(String searchWord) { + setSearchWord_GreaterThan(searchWord, null); + } + + public void setSearchWord_GreaterThan(String searchWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchWord", ConditionKey.CK_GREATER_THAN, searchWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchWord_LessThan(String searchWord) { + setSearchWord_LessThan(searchWord, null); + } + + public void setSearchWord_LessThan(String searchWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchWord", ConditionKey.CK_LESS_THAN, searchWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchWord_GreaterEqual(String searchWord) { + setSearchWord_GreaterEqual(searchWord, null); + } + + public void setSearchWord_GreaterEqual(String searchWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchWord", ConditionKey.CK_GREATER_EQUAL, searchWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSearchWord_LessEqual(String searchWord) { + setSearchWord_LessEqual(searchWord, null); + } + + public void setSearchWord_LessEqual(String searchWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("searchWord", ConditionKey.CK_LESS_EQUAL, searchWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_Term(String userAgent) { + setUserAgent_Term(userAgent, null); + } + + public void setUserAgent_Term(String userAgent, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("userAgent", userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_Terms(Collection userAgentList) { + setUserAgent_Terms(userAgentList, null); + } + + public void setUserAgent_Terms(Collection userAgentList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("userAgent", userAgentList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_InScope(Collection userAgentList) { + setUserAgent_Terms(userAgentList, null); + } + + public void setUserAgent_InScope(Collection userAgentList, ConditionOptionCall opLambda) { + setUserAgent_Terms(userAgentList, opLambda); + } + + public void setUserAgent_Prefix(String userAgent) { + setUserAgent_Prefix(userAgent, null); + } + + public void setUserAgent_Prefix(String userAgent, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("userAgent", userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_Exists() { + setUserAgent_Exists(null); + } + + public void setUserAgent_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("userAgent"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_Missing() { + setUserAgent_Missing(null); + } + + public void setUserAgent_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("userAgent"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_GreaterThan(String userAgent) { + setUserAgent_GreaterThan(userAgent, null); + } + + public void setUserAgent_GreaterThan(String userAgent, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_GREATER_THAN, userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_LessThan(String userAgent) { + setUserAgent_LessThan(userAgent, null); + } + + public void setUserAgent_LessThan(String userAgent, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_LESS_THAN, userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_GreaterEqual(String userAgent) { + setUserAgent_GreaterEqual(userAgent, null); + } + + public void setUserAgent_GreaterEqual(String userAgent, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_GREATER_EQUAL, userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_LessEqual(String userAgent) { + setUserAgent_LessEqual(userAgent, null); + } + + public void setUserAgent_LessEqual(String userAgent, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_LESS_EQUAL, userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserId_Term(Long userId) { + setUserId_Term(userId, null); + } + + public void setUserId_Term(Long userId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("userId", userId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserId_Terms(Collection userIdList) { + setUserId_Terms(userIdList, null); + } + + public void setUserId_Terms(Collection userIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("userId", userIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserId_InScope(Collection userIdList) { + setUserId_Terms(userIdList, null); + } + + public void setUserId_InScope(Collection userIdList, ConditionOptionCall opLambda) { + setUserId_Terms(userIdList, opLambda); + } + + public void setUserId_Exists() { + setUserId_Exists(null); + } + + public void setUserId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("userId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserId_Missing() { + setUserId_Missing(null); + } + + public void setUserId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("userId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserId_GreaterThan(Long userId) { + setUserId_GreaterThan(userId, null); + } + + public void setUserId_GreaterThan(Long userId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userId", ConditionKey.CK_GREATER_THAN, userId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserId_LessThan(Long userId) { + setUserId_LessThan(userId, null); + } + + public void setUserId_LessThan(Long userId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userId", ConditionKey.CK_LESS_THAN, userId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserId_GreaterEqual(Long userId) { + setUserId_GreaterEqual(userId, null); + } + + public void setUserId_GreaterEqual(Long userId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userId", ConditionKey.CK_GREATER_EQUAL, userId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserId_LessEqual(Long userId) { + setUserId_LessEqual(userId, null); + } + + public void setUserId_LessEqual(Long userId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userId", ConditionKey.CK_LESS_EQUAL, userId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserSessionId_Term(String userSessionId) { + setUserSessionId_Term(userSessionId, null); + } + + public void setUserSessionId_Term(String userSessionId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("userSessionId", userSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserSessionId_Terms(Collection userSessionIdList) { + setUserSessionId_Terms(userSessionIdList, null); + } + + public void setUserSessionId_Terms(Collection userSessionIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("userSessionId", userSessionIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserSessionId_InScope(Collection userSessionIdList) { + setUserSessionId_Terms(userSessionIdList, null); + } + + public void setUserSessionId_InScope(Collection userSessionIdList, ConditionOptionCall opLambda) { + setUserSessionId_Terms(userSessionIdList, opLambda); + } + + public void setUserSessionId_Prefix(String userSessionId) { + setUserSessionId_Prefix(userSessionId, null); + } + + public void setUserSessionId_Prefix(String userSessionId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("userSessionId", userSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserSessionId_Exists() { + setUserSessionId_Exists(null); + } + + public void setUserSessionId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("userSessionId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserSessionId_Missing() { + setUserSessionId_Missing(null); + } + + public void setUserSessionId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("userSessionId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserSessionId_GreaterThan(String userSessionId) { + setUserSessionId_GreaterThan(userSessionId, null); + } + + public void setUserSessionId_GreaterThan(String userSessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userSessionId", ConditionKey.CK_GREATER_THAN, userSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserSessionId_LessThan(String userSessionId) { + setUserSessionId_LessThan(userSessionId, null); + } + + public void setUserSessionId_LessThan(String userSessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userSessionId", ConditionKey.CK_LESS_THAN, userSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserSessionId_GreaterEqual(String userSessionId) { + setUserSessionId_GreaterEqual(userSessionId, null); + } + + public void setUserSessionId_GreaterEqual(String userSessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userSessionId", ConditionKey.CK_GREATER_EQUAL, userSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserSessionId_LessEqual(String userSessionId) { + setUserSessionId_LessEqual(userSessionId, null); + } + + public void setUserSessionId_LessEqual(String userSessionId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userSessionId", ConditionKey.CK_LESS_EQUAL, userSessionId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSuggestBadWordCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSuggestBadWordCF.java new file mode 100644 index 000000000..c3e26e301 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSuggestBadWordCF.java @@ -0,0 +1,943 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.SuggestBadWordCF; +import org.codelibs.fess.es.cbean.cq.SuggestBadWordCQ; +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 BsSuggestBadWordCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + SuggestBadWordCF mustFilter = new SuggestBadWordCF(); + SuggestBadWordCF shouldFilter = new SuggestBadWordCF(); + SuggestBadWordCF mustNotFilter = new SuggestBadWordCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + SuggestBadWordCF andFilter = new SuggestBadWordCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + SuggestBadWordCF orFilter = new SuggestBadWordCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + SuggestBadWordCF notFilter = new SuggestBadWordCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + SuggestBadWordCQ query = new SuggestBadWordCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_Term(String suggestWord) { + setSuggestWord_Term(suggestWord, null); + } + + public void setSuggestWord_Term(String suggestWord, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("suggestWord", suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_Terms(Collection suggestWordList) { + setSuggestWord_Terms(suggestWordList, null); + } + + public void setSuggestWord_Terms(Collection suggestWordList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("suggestWord", suggestWordList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_InScope(Collection suggestWordList) { + setSuggestWord_Terms(suggestWordList, null); + } + + public void setSuggestWord_InScope(Collection suggestWordList, ConditionOptionCall opLambda) { + setSuggestWord_Terms(suggestWordList, opLambda); + } + + public void setSuggestWord_Prefix(String suggestWord) { + setSuggestWord_Prefix(suggestWord, null); + } + + public void setSuggestWord_Prefix(String suggestWord, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("suggestWord", suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_Exists() { + setSuggestWord_Exists(null); + } + + public void setSuggestWord_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("suggestWord"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_Missing() { + setSuggestWord_Missing(null); + } + + public void setSuggestWord_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("suggestWord"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_GreaterThan(String suggestWord) { + setSuggestWord_GreaterThan(suggestWord, null); + } + + public void setSuggestWord_GreaterThan(String suggestWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_GREATER_THAN, suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_LessThan(String suggestWord) { + setSuggestWord_LessThan(suggestWord, null); + } + + public void setSuggestWord_LessThan(String suggestWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_LESS_THAN, suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_GreaterEqual(String suggestWord) { + setSuggestWord_GreaterEqual(suggestWord, null); + } + + public void setSuggestWord_GreaterEqual(String suggestWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_GREATER_EQUAL, suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_LessEqual(String suggestWord) { + setSuggestWord_LessEqual(suggestWord, null); + } + + public void setSuggestWord_LessEqual(String suggestWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_LESS_EQUAL, suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_Term(String targetLabel) { + setTargetLabel_Term(targetLabel, null); + } + + public void setTargetLabel_Term(String targetLabel, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("targetLabel", targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_Terms(Collection targetLabelList) { + setTargetLabel_Terms(targetLabelList, null); + } + + public void setTargetLabel_Terms(Collection targetLabelList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("targetLabel", targetLabelList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_InScope(Collection targetLabelList) { + setTargetLabel_Terms(targetLabelList, null); + } + + public void setTargetLabel_InScope(Collection targetLabelList, ConditionOptionCall opLambda) { + setTargetLabel_Terms(targetLabelList, opLambda); + } + + public void setTargetLabel_Prefix(String targetLabel) { + setTargetLabel_Prefix(targetLabel, null); + } + + public void setTargetLabel_Prefix(String targetLabel, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("targetLabel", targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_Exists() { + setTargetLabel_Exists(null); + } + + public void setTargetLabel_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("targetLabel"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_Missing() { + setTargetLabel_Missing(null); + } + + public void setTargetLabel_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("targetLabel"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_GreaterThan(String targetLabel) { + setTargetLabel_GreaterThan(targetLabel, null); + } + + public void setTargetLabel_GreaterThan(String targetLabel, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_GREATER_THAN, targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_LessThan(String targetLabel) { + setTargetLabel_LessThan(targetLabel, null); + } + + public void setTargetLabel_LessThan(String targetLabel, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_LESS_THAN, targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_GreaterEqual(String targetLabel) { + setTargetLabel_GreaterEqual(targetLabel, null); + } + + public void setTargetLabel_GreaterEqual(String targetLabel, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_GREATER_EQUAL, targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_LessEqual(String targetLabel) { + setTargetLabel_LessEqual(targetLabel, null); + } + + public void setTargetLabel_LessEqual(String targetLabel, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_LESS_EQUAL, targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_Term(String targetRole) { + setTargetRole_Term(targetRole, null); + } + + public void setTargetRole_Term(String targetRole, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("targetRole", targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_Terms(Collection targetRoleList) { + setTargetRole_Terms(targetRoleList, null); + } + + public void setTargetRole_Terms(Collection targetRoleList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("targetRole", targetRoleList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_InScope(Collection targetRoleList) { + setTargetRole_Terms(targetRoleList, null); + } + + public void setTargetRole_InScope(Collection targetRoleList, ConditionOptionCall opLambda) { + setTargetRole_Terms(targetRoleList, opLambda); + } + + public void setTargetRole_Prefix(String targetRole) { + setTargetRole_Prefix(targetRole, null); + } + + public void setTargetRole_Prefix(String targetRole, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("targetRole", targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_Exists() { + setTargetRole_Exists(null); + } + + public void setTargetRole_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("targetRole"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_Missing() { + setTargetRole_Missing(null); + } + + public void setTargetRole_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("targetRole"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_GreaterThan(String targetRole) { + setTargetRole_GreaterThan(targetRole, null); + } + + public void setTargetRole_GreaterThan(String targetRole, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_GREATER_THAN, targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_LessThan(String targetRole) { + setTargetRole_LessThan(targetRole, null); + } + + public void setTargetRole_LessThan(String targetRole, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_LESS_THAN, targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_GreaterEqual(String targetRole) { + setTargetRole_GreaterEqual(targetRole, null); + } + + public void setTargetRole_GreaterEqual(String targetRole, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_GREATER_EQUAL, targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_LessEqual(String targetRole) { + setTargetRole_LessEqual(targetRole, null); + } + + public void setTargetRole_LessEqual(String targetRole, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_LESS_EQUAL, targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSuggestElevateWordCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSuggestElevateWordCF.java new file mode 100644 index 000000000..c88450e15 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsSuggestElevateWordCF.java @@ -0,0 +1,1146 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.SuggestElevateWordCF; +import org.codelibs.fess.es.cbean.cq.SuggestElevateWordCQ; +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 BsSuggestElevateWordCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + SuggestElevateWordCF mustFilter = new SuggestElevateWordCF(); + SuggestElevateWordCF shouldFilter = new SuggestElevateWordCF(); + SuggestElevateWordCF mustNotFilter = new SuggestElevateWordCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + SuggestElevateWordCF andFilter = new SuggestElevateWordCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + SuggestElevateWordCF orFilter = new SuggestElevateWordCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + SuggestElevateWordCF notFilter = new SuggestElevateWordCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + SuggestElevateWordCQ query = new SuggestElevateWordCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setBoost_Term(Float boost) { + setBoost_Term(boost, null); + } + + public void setBoost_Term(Float boost, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("boost", boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Terms(Collection boostList) { + setBoost_Terms(boostList, null); + } + + public void setBoost_Terms(Collection boostList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("boost", boostList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_InScope(Collection boostList) { + setBoost_Terms(boostList, null); + } + + public void setBoost_InScope(Collection boostList, ConditionOptionCall opLambda) { + setBoost_Terms(boostList, opLambda); + } + + public void setBoost_Exists() { + setBoost_Exists(null); + } + + public void setBoost_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("boost"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Missing() { + setBoost_Missing(null); + } + + public void setBoost_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("boost"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_GreaterThan(Float boost) { + setBoost_GreaterThan(boost, null); + } + + public void setBoost_GreaterThan(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_THAN, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_LessThan(Float boost) { + setBoost_LessThan(boost, null); + } + + public void setBoost_LessThan(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_THAN, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_GreaterEqual(Float boost) { + setBoost_GreaterEqual(boost, null); + } + + public void setBoost_GreaterEqual(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_EQUAL, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_LessEqual(Float boost) { + setBoost_LessEqual(boost, null); + } + + public void setBoost_LessEqual(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_EQUAL, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReading_Term(String reading) { + setReading_Term(reading, null); + } + + public void setReading_Term(String reading, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("reading", reading); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReading_Terms(Collection readingList) { + setReading_Terms(readingList, null); + } + + public void setReading_Terms(Collection readingList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("reading", readingList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReading_InScope(Collection readingList) { + setReading_Terms(readingList, null); + } + + public void setReading_InScope(Collection readingList, ConditionOptionCall opLambda) { + setReading_Terms(readingList, opLambda); + } + + public void setReading_Prefix(String reading) { + setReading_Prefix(reading, null); + } + + public void setReading_Prefix(String reading, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("reading", reading); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReading_Exists() { + setReading_Exists(null); + } + + public void setReading_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("reading"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReading_Missing() { + setReading_Missing(null); + } + + public void setReading_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("reading"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReading_GreaterThan(String reading) { + setReading_GreaterThan(reading, null); + } + + public void setReading_GreaterThan(String reading, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("reading", ConditionKey.CK_GREATER_THAN, reading); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReading_LessThan(String reading) { + setReading_LessThan(reading, null); + } + + public void setReading_LessThan(String reading, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("reading", ConditionKey.CK_LESS_THAN, reading); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReading_GreaterEqual(String reading) { + setReading_GreaterEqual(reading, null); + } + + public void setReading_GreaterEqual(String reading, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("reading", ConditionKey.CK_GREATER_EQUAL, reading); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setReading_LessEqual(String reading) { + setReading_LessEqual(reading, null); + } + + public void setReading_LessEqual(String reading, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("reading", ConditionKey.CK_LESS_EQUAL, reading); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_Term(String suggestWord) { + setSuggestWord_Term(suggestWord, null); + } + + public void setSuggestWord_Term(String suggestWord, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("suggestWord", suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_Terms(Collection suggestWordList) { + setSuggestWord_Terms(suggestWordList, null); + } + + public void setSuggestWord_Terms(Collection suggestWordList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("suggestWord", suggestWordList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_InScope(Collection suggestWordList) { + setSuggestWord_Terms(suggestWordList, null); + } + + public void setSuggestWord_InScope(Collection suggestWordList, ConditionOptionCall opLambda) { + setSuggestWord_Terms(suggestWordList, opLambda); + } + + public void setSuggestWord_Prefix(String suggestWord) { + setSuggestWord_Prefix(suggestWord, null); + } + + public void setSuggestWord_Prefix(String suggestWord, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("suggestWord", suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_Exists() { + setSuggestWord_Exists(null); + } + + public void setSuggestWord_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("suggestWord"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_Missing() { + setSuggestWord_Missing(null); + } + + public void setSuggestWord_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("suggestWord"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_GreaterThan(String suggestWord) { + setSuggestWord_GreaterThan(suggestWord, null); + } + + public void setSuggestWord_GreaterThan(String suggestWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_GREATER_THAN, suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_LessThan(String suggestWord) { + setSuggestWord_LessThan(suggestWord, null); + } + + public void setSuggestWord_LessThan(String suggestWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_LESS_THAN, suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_GreaterEqual(String suggestWord) { + setSuggestWord_GreaterEqual(suggestWord, null); + } + + public void setSuggestWord_GreaterEqual(String suggestWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_GREATER_EQUAL, suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSuggestWord_LessEqual(String suggestWord) { + setSuggestWord_LessEqual(suggestWord, null); + } + + public void setSuggestWord_LessEqual(String suggestWord, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("suggestWord", ConditionKey.CK_LESS_EQUAL, suggestWord); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_Term(String targetLabel) { + setTargetLabel_Term(targetLabel, null); + } + + public void setTargetLabel_Term(String targetLabel, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("targetLabel", targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_Terms(Collection targetLabelList) { + setTargetLabel_Terms(targetLabelList, null); + } + + public void setTargetLabel_Terms(Collection targetLabelList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("targetLabel", targetLabelList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_InScope(Collection targetLabelList) { + setTargetLabel_Terms(targetLabelList, null); + } + + public void setTargetLabel_InScope(Collection targetLabelList, ConditionOptionCall opLambda) { + setTargetLabel_Terms(targetLabelList, opLambda); + } + + public void setTargetLabel_Prefix(String targetLabel) { + setTargetLabel_Prefix(targetLabel, null); + } + + public void setTargetLabel_Prefix(String targetLabel, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("targetLabel", targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_Exists() { + setTargetLabel_Exists(null); + } + + public void setTargetLabel_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("targetLabel"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_Missing() { + setTargetLabel_Missing(null); + } + + public void setTargetLabel_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("targetLabel"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_GreaterThan(String targetLabel) { + setTargetLabel_GreaterThan(targetLabel, null); + } + + public void setTargetLabel_GreaterThan(String targetLabel, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_GREATER_THAN, targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_LessThan(String targetLabel) { + setTargetLabel_LessThan(targetLabel, null); + } + + public void setTargetLabel_LessThan(String targetLabel, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_LESS_THAN, targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_GreaterEqual(String targetLabel) { + setTargetLabel_GreaterEqual(targetLabel, null); + } + + public void setTargetLabel_GreaterEqual(String targetLabel, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_GREATER_EQUAL, targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetLabel_LessEqual(String targetLabel) { + setTargetLabel_LessEqual(targetLabel, null); + } + + public void setTargetLabel_LessEqual(String targetLabel, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetLabel", ConditionKey.CK_LESS_EQUAL, targetLabel); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_Term(String targetRole) { + setTargetRole_Term(targetRole, null); + } + + public void setTargetRole_Term(String targetRole, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("targetRole", targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_Terms(Collection targetRoleList) { + setTargetRole_Terms(targetRoleList, null); + } + + public void setTargetRole_Terms(Collection targetRoleList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("targetRole", targetRoleList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_InScope(Collection targetRoleList) { + setTargetRole_Terms(targetRoleList, null); + } + + public void setTargetRole_InScope(Collection targetRoleList, ConditionOptionCall opLambda) { + setTargetRole_Terms(targetRoleList, opLambda); + } + + public void setTargetRole_Prefix(String targetRole) { + setTargetRole_Prefix(targetRole, null); + } + + public void setTargetRole_Prefix(String targetRole, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("targetRole", targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_Exists() { + setTargetRole_Exists(null); + } + + public void setTargetRole_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("targetRole"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_Missing() { + setTargetRole_Missing(null); + } + + public void setTargetRole_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("targetRole"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_GreaterThan(String targetRole) { + setTargetRole_GreaterThan(targetRole, null); + } + + public void setTargetRole_GreaterThan(String targetRole, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_GREATER_THAN, targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_LessThan(String targetRole) { + setTargetRole_LessThan(targetRole, null); + } + + public void setTargetRole_LessThan(String targetRole, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_LESS_THAN, targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_GreaterEqual(String targetRole) { + setTargetRole_GreaterEqual(targetRole, null); + } + + public void setTargetRole_GreaterEqual(String targetRole, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_GREATER_EQUAL, targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setTargetRole_LessEqual(String targetRole) { + setTargetRole_LessEqual(targetRole, null); + } + + public void setTargetRole_LessEqual(String targetRole, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("targetRole", ConditionKey.CK_LESS_EQUAL, targetRole); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsUserInfoCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsUserInfoCF.java new file mode 100644 index 000000000..5f7a7a400 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsUserInfoCF.java @@ -0,0 +1,515 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.UserInfoCF; +import org.codelibs.fess.es.cbean.cq.UserInfoCQ; +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 BsUserInfoCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + UserInfoCF mustFilter = new UserInfoCF(); + UserInfoCF shouldFilter = new UserInfoCF(); + UserInfoCF mustNotFilter = new UserInfoCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + UserInfoCF andFilter = new UserInfoCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + UserInfoCF orFilter = new UserInfoCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + UserInfoCF notFilter = new UserInfoCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + UserInfoCQ query = new UserInfoCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setCode_Term(String code) { + setCode_Term(code, null); + } + + public void setCode_Term(String code, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("code", code); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCode_Terms(Collection codeList) { + setCode_Terms(codeList, null); + } + + public void setCode_Terms(Collection codeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("code", codeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCode_InScope(Collection codeList) { + setCode_Terms(codeList, null); + } + + public void setCode_InScope(Collection codeList, ConditionOptionCall opLambda) { + setCode_Terms(codeList, opLambda); + } + + public void setCode_Prefix(String code) { + setCode_Prefix(code, null); + } + + public void setCode_Prefix(String code, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("code", code); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCode_Exists() { + setCode_Exists(null); + } + + public void setCode_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("code"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCode_Missing() { + setCode_Missing(null); + } + + public void setCode_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("code"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCode_GreaterThan(String code) { + setCode_GreaterThan(code, null); + } + + public void setCode_GreaterThan(String code, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("code", ConditionKey.CK_GREATER_THAN, code); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCode_LessThan(String code) { + setCode_LessThan(code, null); + } + + public void setCode_LessThan(String code, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("code", ConditionKey.CK_LESS_THAN, code); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCode_GreaterEqual(String code) { + setCode_GreaterEqual(code, null); + } + + public void setCode_GreaterEqual(String code, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("code", ConditionKey.CK_GREATER_EQUAL, code); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCode_LessEqual(String code) { + setCode_LessEqual(code, null); + } + + public void setCode_LessEqual(String code, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("code", ConditionKey.CK_LESS_EQUAL, code); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebAuthenticationCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebAuthenticationCF.java new file mode 100644 index 000000000..b251145d1 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebAuthenticationCF.java @@ -0,0 +1,1467 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.WebAuthenticationCF; +import org.codelibs.fess.es.cbean.cq.WebAuthenticationCQ; +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 BsWebAuthenticationCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + WebAuthenticationCF mustFilter = new WebAuthenticationCF(); + WebAuthenticationCF shouldFilter = new WebAuthenticationCF(); + WebAuthenticationCF mustNotFilter = new WebAuthenticationCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + WebAuthenticationCF andFilter = new WebAuthenticationCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + WebAuthenticationCF orFilter = new WebAuthenticationCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + WebAuthenticationCF notFilter = new WebAuthenticationCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + WebAuthenticationCQ query = new WebAuthenticationCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setAuthRealm_Term(String authRealm) { + setAuthRealm_Term(authRealm, null); + } + + public void setAuthRealm_Term(String authRealm, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("authRealm", authRealm); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAuthRealm_Terms(Collection authRealmList) { + setAuthRealm_Terms(authRealmList, null); + } + + public void setAuthRealm_Terms(Collection authRealmList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("authRealm", authRealmList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAuthRealm_InScope(Collection authRealmList) { + setAuthRealm_Terms(authRealmList, null); + } + + public void setAuthRealm_InScope(Collection authRealmList, ConditionOptionCall opLambda) { + setAuthRealm_Terms(authRealmList, opLambda); + } + + public void setAuthRealm_Prefix(String authRealm) { + setAuthRealm_Prefix(authRealm, null); + } + + public void setAuthRealm_Prefix(String authRealm, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("authRealm", authRealm); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAuthRealm_Exists() { + setAuthRealm_Exists(null); + } + + public void setAuthRealm_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("authRealm"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAuthRealm_Missing() { + setAuthRealm_Missing(null); + } + + public void setAuthRealm_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("authRealm"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAuthRealm_GreaterThan(String authRealm) { + setAuthRealm_GreaterThan(authRealm, null); + } + + public void setAuthRealm_GreaterThan(String authRealm, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("authRealm", ConditionKey.CK_GREATER_THAN, authRealm); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAuthRealm_LessThan(String authRealm) { + setAuthRealm_LessThan(authRealm, null); + } + + public void setAuthRealm_LessThan(String authRealm, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("authRealm", ConditionKey.CK_LESS_THAN, authRealm); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAuthRealm_GreaterEqual(String authRealm) { + setAuthRealm_GreaterEqual(authRealm, null); + } + + public void setAuthRealm_GreaterEqual(String authRealm, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("authRealm", ConditionKey.CK_GREATER_EQUAL, authRealm); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAuthRealm_LessEqual(String authRealm) { + setAuthRealm_LessEqual(authRealm, null); + } + + public void setAuthRealm_LessEqual(String authRealm, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("authRealm", ConditionKey.CK_LESS_EQUAL, authRealm); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_Term(String hostname) { + setHostname_Term(hostname, null); + } + + public void setHostname_Term(String hostname, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("hostname", hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_Terms(Collection hostnameList) { + setHostname_Terms(hostnameList, null); + } + + public void setHostname_Terms(Collection hostnameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("hostname", hostnameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_InScope(Collection hostnameList) { + setHostname_Terms(hostnameList, null); + } + + public void setHostname_InScope(Collection hostnameList, ConditionOptionCall opLambda) { + setHostname_Terms(hostnameList, opLambda); + } + + public void setHostname_Prefix(String hostname) { + setHostname_Prefix(hostname, null); + } + + public void setHostname_Prefix(String hostname, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("hostname", hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_Exists() { + setHostname_Exists(null); + } + + public void setHostname_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("hostname"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_Missing() { + setHostname_Missing(null); + } + + public void setHostname_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("hostname"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_GreaterThan(String hostname) { + setHostname_GreaterThan(hostname, null); + } + + public void setHostname_GreaterThan(String hostname, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_GREATER_THAN, hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_LessThan(String hostname) { + setHostname_LessThan(hostname, null); + } + + public void setHostname_LessThan(String hostname, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_LESS_THAN, hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_GreaterEqual(String hostname) { + setHostname_GreaterEqual(hostname, null); + } + + public void setHostname_GreaterEqual(String hostname, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_GREATER_EQUAL, hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setHostname_LessEqual(String hostname) { + setHostname_LessEqual(hostname, null); + } + + public void setHostname_LessEqual(String hostname, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("hostname", ConditionKey.CK_LESS_EQUAL, hostname); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_Term(String parameters) { + setParameters_Term(parameters, null); + } + + public void setParameters_Term(String parameters, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("parameters", parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_Terms(Collection parametersList) { + setParameters_Terms(parametersList, null); + } + + public void setParameters_Terms(Collection parametersList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("parameters", parametersList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_InScope(Collection parametersList) { + setParameters_Terms(parametersList, null); + } + + public void setParameters_InScope(Collection parametersList, ConditionOptionCall opLambda) { + setParameters_Terms(parametersList, opLambda); + } + + public void setParameters_Prefix(String parameters) { + setParameters_Prefix(parameters, null); + } + + public void setParameters_Prefix(String parameters, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("parameters", parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_Exists() { + setParameters_Exists(null); + } + + public void setParameters_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("parameters"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_Missing() { + setParameters_Missing(null); + } + + public void setParameters_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("parameters"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_GreaterThan(String parameters) { + setParameters_GreaterThan(parameters, null); + } + + public void setParameters_GreaterThan(String parameters, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_GREATER_THAN, parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_LessThan(String parameters) { + setParameters_LessThan(parameters, null); + } + + public void setParameters_LessThan(String parameters, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_LESS_THAN, parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_GreaterEqual(String parameters) { + setParameters_GreaterEqual(parameters, null); + } + + public void setParameters_GreaterEqual(String parameters, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_GREATER_EQUAL, parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setParameters_LessEqual(String parameters) { + setParameters_LessEqual(parameters, null); + } + + public void setParameters_LessEqual(String parameters, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("parameters", ConditionKey.CK_LESS_EQUAL, parameters); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_Term(String password) { + setPassword_Term(password, null); + } + + public void setPassword_Term(String password, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("password", password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_Terms(Collection passwordList) { + setPassword_Terms(passwordList, null); + } + + public void setPassword_Terms(Collection passwordList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("password", passwordList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_InScope(Collection passwordList) { + setPassword_Terms(passwordList, null); + } + + public void setPassword_InScope(Collection passwordList, ConditionOptionCall opLambda) { + setPassword_Terms(passwordList, opLambda); + } + + public void setPassword_Prefix(String password) { + setPassword_Prefix(password, null); + } + + public void setPassword_Prefix(String password, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("password", password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_Exists() { + setPassword_Exists(null); + } + + public void setPassword_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("password"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_Missing() { + setPassword_Missing(null); + } + + public void setPassword_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("password"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_GreaterThan(String password) { + setPassword_GreaterThan(password, null); + } + + public void setPassword_GreaterThan(String password, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_GREATER_THAN, password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_LessThan(String password) { + setPassword_LessThan(password, null); + } + + public void setPassword_LessThan(String password, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_LESS_THAN, password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_GreaterEqual(String password) { + setPassword_GreaterEqual(password, null); + } + + public void setPassword_GreaterEqual(String password, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_GREATER_EQUAL, password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPassword_LessEqual(String password) { + setPassword_LessEqual(password, null); + } + + public void setPassword_LessEqual(String password, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("password", ConditionKey.CK_LESS_EQUAL, password); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_Term(Integer port) { + setPort_Term(port, null); + } + + public void setPort_Term(Integer port, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("port", port); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_Terms(Collection portList) { + setPort_Terms(portList, null); + } + + public void setPort_Terms(Collection portList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("port", portList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_InScope(Collection portList) { + setPort_Terms(portList, null); + } + + public void setPort_InScope(Collection portList, ConditionOptionCall opLambda) { + setPort_Terms(portList, opLambda); + } + + public void setPort_Exists() { + setPort_Exists(null); + } + + public void setPort_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("port"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_Missing() { + setPort_Missing(null); + } + + public void setPort_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("port"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_GreaterThan(Integer port) { + setPort_GreaterThan(port, null); + } + + public void setPort_GreaterThan(Integer port, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_GREATER_THAN, port); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_LessThan(Integer port) { + setPort_LessThan(port, null); + } + + public void setPort_LessThan(Integer port, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_LESS_THAN, port); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_GreaterEqual(Integer port) { + setPort_GreaterEqual(port, null); + } + + public void setPort_GreaterEqual(Integer port, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_GREATER_EQUAL, port); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setPort_LessEqual(Integer port) { + setPort_LessEqual(port, null); + } + + public void setPort_LessEqual(Integer port, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("port", ConditionKey.CK_LESS_EQUAL, port); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_Term(String protocolScheme) { + setProtocolScheme_Term(protocolScheme, null); + } + + public void setProtocolScheme_Term(String protocolScheme, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("protocolScheme", protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_Terms(Collection protocolSchemeList) { + setProtocolScheme_Terms(protocolSchemeList, null); + } + + public void setProtocolScheme_Terms(Collection protocolSchemeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("protocolScheme", protocolSchemeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_InScope(Collection protocolSchemeList) { + setProtocolScheme_Terms(protocolSchemeList, null); + } + + public void setProtocolScheme_InScope(Collection protocolSchemeList, ConditionOptionCall opLambda) { + setProtocolScheme_Terms(protocolSchemeList, opLambda); + } + + public void setProtocolScheme_Prefix(String protocolScheme) { + setProtocolScheme_Prefix(protocolScheme, null); + } + + public void setProtocolScheme_Prefix(String protocolScheme, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("protocolScheme", protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_Exists() { + setProtocolScheme_Exists(null); + } + + public void setProtocolScheme_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("protocolScheme"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_Missing() { + setProtocolScheme_Missing(null); + } + + public void setProtocolScheme_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("protocolScheme"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_GreaterThan(String protocolScheme) { + setProtocolScheme_GreaterThan(protocolScheme, null); + } + + public void setProtocolScheme_GreaterThan(String protocolScheme, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_GREATER_THAN, protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_LessThan(String protocolScheme) { + setProtocolScheme_LessThan(protocolScheme, null); + } + + public void setProtocolScheme_LessThan(String protocolScheme, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_LESS_THAN, protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_GreaterEqual(String protocolScheme) { + setProtocolScheme_GreaterEqual(protocolScheme, null); + } + + public void setProtocolScheme_GreaterEqual(String protocolScheme, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_GREATER_EQUAL, protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setProtocolScheme_LessEqual(String protocolScheme) { + setProtocolScheme_LessEqual(protocolScheme, null); + } + + public void setProtocolScheme_LessEqual(String protocolScheme, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("protocolScheme", ConditionKey.CK_LESS_EQUAL, protocolScheme); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_Term(String username) { + setUsername_Term(username, null); + } + + public void setUsername_Term(String username, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("username", username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_Terms(Collection usernameList) { + setUsername_Terms(usernameList, null); + } + + public void setUsername_Terms(Collection usernameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("username", usernameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_InScope(Collection usernameList) { + setUsername_Terms(usernameList, null); + } + + public void setUsername_InScope(Collection usernameList, ConditionOptionCall opLambda) { + setUsername_Terms(usernameList, opLambda); + } + + public void setUsername_Prefix(String username) { + setUsername_Prefix(username, null); + } + + public void setUsername_Prefix(String username, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("username", username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_Exists() { + setUsername_Exists(null); + } + + public void setUsername_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("username"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_Missing() { + setUsername_Missing(null); + } + + public void setUsername_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("username"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_GreaterThan(String username) { + setUsername_GreaterThan(username, null); + } + + public void setUsername_GreaterThan(String username, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_GREATER_THAN, username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_LessThan(String username) { + setUsername_LessThan(username, null); + } + + public void setUsername_LessThan(String username, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_LESS_THAN, username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_GreaterEqual(String username) { + setUsername_GreaterEqual(username, null); + } + + public void setUsername_GreaterEqual(String username, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_GREATER_EQUAL, username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUsername_LessEqual(String username) { + setUsername_LessEqual(username, null); + } + + public void setUsername_LessEqual(String username, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("username", ConditionKey.CK_LESS_EQUAL, username); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Term(String webConfigId) { + setWebConfigId_Term(webConfigId, null); + } + + public void setWebConfigId_Term(String webConfigId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("webConfigId", webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Terms(Collection webConfigIdList) { + setWebConfigId_Terms(webConfigIdList, null); + } + + public void setWebConfigId_Terms(Collection webConfigIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("webConfigId", webConfigIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_InScope(Collection webConfigIdList) { + setWebConfigId_Terms(webConfigIdList, null); + } + + public void setWebConfigId_InScope(Collection webConfigIdList, ConditionOptionCall opLambda) { + setWebConfigId_Terms(webConfigIdList, opLambda); + } + + public void setWebConfigId_Prefix(String webConfigId) { + setWebConfigId_Prefix(webConfigId, null); + } + + public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("webConfigId", webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Exists() { + setWebConfigId_Exists(null); + } + + public void setWebConfigId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("webConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Missing() { + setWebConfigId_Missing(null); + } + + public void setWebConfigId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("webConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_GreaterThan(String webConfigId) { + setWebConfigId_GreaterThan(webConfigId, null); + } + + public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_LessThan(String webConfigId) { + setWebConfigId_LessThan(webConfigId, null); + } + + public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_GreaterEqual(String webConfigId) { + setWebConfigId_GreaterEqual(webConfigId, null); + } + + public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_LessEqual(String webConfigId) { + setWebConfigId_LessEqual(webConfigId, null); + } + + public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigCF.java new file mode 100644 index 000000000..bd65e3e33 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigCF.java @@ -0,0 +1,2150 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.WebConfigCF; +import org.codelibs.fess.es.cbean.cq.WebConfigCQ; +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 BsWebConfigCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + WebConfigCF mustFilter = new WebConfigCF(); + WebConfigCF shouldFilter = new WebConfigCF(); + WebConfigCF mustNotFilter = new WebConfigCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + WebConfigCF andFilter = new WebConfigCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + WebConfigCF orFilter = new WebConfigCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + WebConfigCF notFilter = new WebConfigCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + WebConfigCQ query = new WebConfigCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setAvailable_Term(Boolean available) { + setAvailable_Term(available, null); + } + + public void setAvailable_Term(Boolean available, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("available", available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_Terms(Collection availableList) { + setAvailable_Terms(availableList, null); + } + + public void setAvailable_Terms(Collection availableList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("available", availableList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_InScope(Collection availableList) { + setAvailable_Terms(availableList, null); + } + + public void setAvailable_InScope(Collection availableList, ConditionOptionCall opLambda) { + setAvailable_Terms(availableList, opLambda); + } + + public void setAvailable_Exists() { + setAvailable_Exists(null); + } + + public void setAvailable_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("available"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_Missing() { + setAvailable_Missing(null); + } + + public void setAvailable_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("available"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_GreaterThan(Boolean available) { + setAvailable_GreaterThan(available, null); + } + + public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_THAN, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_LessThan(Boolean available) { + setAvailable_LessThan(available, null); + } + + public void setAvailable_LessThan(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_THAN, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_GreaterEqual(Boolean available) { + setAvailable_GreaterEqual(available, null); + } + + public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_GREATER_EQUAL, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setAvailable_LessEqual(Boolean available) { + setAvailable_LessEqual(available, null); + } + + public void setAvailable_LessEqual(Boolean available, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("available", ConditionKey.CK_LESS_EQUAL, available); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Term(Float boost) { + setBoost_Term(boost, null); + } + + public void setBoost_Term(Float boost, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("boost", boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Terms(Collection boostList) { + setBoost_Terms(boostList, null); + } + + public void setBoost_Terms(Collection boostList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("boost", boostList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_InScope(Collection boostList) { + setBoost_Terms(boostList, null); + } + + public void setBoost_InScope(Collection boostList, ConditionOptionCall opLambda) { + setBoost_Terms(boostList, opLambda); + } + + public void setBoost_Exists() { + setBoost_Exists(null); + } + + public void setBoost_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("boost"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_Missing() { + setBoost_Missing(null); + } + + public void setBoost_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("boost"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_GreaterThan(Float boost) { + setBoost_GreaterThan(boost, null); + } + + public void setBoost_GreaterThan(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_THAN, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_LessThan(Float boost) { + setBoost_LessThan(boost, null); + } + + public void setBoost_LessThan(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_THAN, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_GreaterEqual(Float boost) { + setBoost_GreaterEqual(boost, null); + } + + public void setBoost_GreaterEqual(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_GREATER_EQUAL, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setBoost_LessEqual(Float boost) { + setBoost_LessEqual(boost, null); + } + + public void setBoost_LessEqual(Float boost, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("boost", ConditionKey.CK_LESS_EQUAL, boost); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_Term(String configParameter) { + setConfigParameter_Term(configParameter, null); + } + + public void setConfigParameter_Term(String configParameter, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("configParameter", configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_Terms(Collection configParameterList) { + setConfigParameter_Terms(configParameterList, null); + } + + public void setConfigParameter_Terms(Collection configParameterList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("configParameter", configParameterList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_InScope(Collection configParameterList) { + setConfigParameter_Terms(configParameterList, null); + } + + public void setConfigParameter_InScope(Collection configParameterList, ConditionOptionCall opLambda) { + setConfigParameter_Terms(configParameterList, opLambda); + } + + public void setConfigParameter_Prefix(String configParameter) { + setConfigParameter_Prefix(configParameter, null); + } + + public void setConfigParameter_Prefix(String configParameter, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("configParameter", configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_Exists() { + setConfigParameter_Exists(null); + } + + public void setConfigParameter_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("configParameter"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_Missing() { + setConfigParameter_Missing(null); + } + + public void setConfigParameter_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("configParameter"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_GreaterThan(String configParameter) { + setConfigParameter_GreaterThan(configParameter, null); + } + + public void setConfigParameter_GreaterThan(String configParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_GREATER_THAN, configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_LessThan(String configParameter) { + setConfigParameter_LessThan(configParameter, null); + } + + public void setConfigParameter_LessThan(String configParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_LESS_THAN, configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_GreaterEqual(String configParameter) { + setConfigParameter_GreaterEqual(configParameter, null); + } + + public void setConfigParameter_GreaterEqual(String configParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_GREATER_EQUAL, configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setConfigParameter_LessEqual(String configParameter) { + setConfigParameter_LessEqual(configParameter, null); + } + + public void setConfigParameter_LessEqual(String configParameter, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("configParameter", ConditionKey.CK_LESS_EQUAL, configParameter); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Term(String createdBy) { + setCreatedBy_Term(createdBy, null); + } + + public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Terms(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdBy", createdByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_InScope(Collection createdByList) { + setCreatedBy_Terms(createdByList, null); + } + + public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { + setCreatedBy_Terms(createdByList, opLambda); + } + + public void setCreatedBy_Prefix(String createdBy) { + setCreatedBy_Prefix(createdBy, null); + } + + public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("createdBy", createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Exists() { + setCreatedBy_Exists(null); + } + + public void setCreatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_Missing() { + setCreatedBy_Missing(null); + } + + public void setCreatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterThan(String createdBy) { + setCreatedBy_GreaterThan(createdBy, null); + } + + public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessThan(String createdBy) { + setCreatedBy_LessThan(createdBy, null); + } + + public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_GreaterEqual(String createdBy) { + setCreatedBy_GreaterEqual(createdBy, null); + } + + public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedBy_LessEqual(String createdBy) { + setCreatedBy_LessEqual(createdBy, null); + } + + public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Term(Long createdTime) { + setCreatedTime_Term(createdTime, null); + } + + public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("createdTime", createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Terms(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("createdTime", createdTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_InScope(Collection createdTimeList) { + setCreatedTime_Terms(createdTimeList, null); + } + + public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { + setCreatedTime_Terms(createdTimeList, opLambda); + } + + public void setCreatedTime_Exists() { + setCreatedTime_Exists(null); + } + + public void setCreatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_Missing() { + setCreatedTime_Missing(null); + } + + public void setCreatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("createdTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterThan(Long createdTime) { + setCreatedTime_GreaterThan(createdTime, null); + } + + public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessThan(Long createdTime) { + setCreatedTime_LessThan(createdTime, null); + } + + public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_GreaterEqual(Long createdTime) { + setCreatedTime_GreaterEqual(createdTime, null); + } + + public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setCreatedTime_LessEqual(Long createdTime) { + setCreatedTime_LessEqual(createdTime, null); + } + + public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_Term(Integer depth) { + setDepth_Term(depth, null); + } + + public void setDepth_Term(Integer depth, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("depth", depth); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_Terms(Collection depthList) { + setDepth_Terms(depthList, null); + } + + public void setDepth_Terms(Collection depthList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("depth", depthList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_InScope(Collection depthList) { + setDepth_Terms(depthList, null); + } + + public void setDepth_InScope(Collection depthList, ConditionOptionCall opLambda) { + setDepth_Terms(depthList, opLambda); + } + + public void setDepth_Exists() { + setDepth_Exists(null); + } + + public void setDepth_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("depth"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_Missing() { + setDepth_Missing(null); + } + + public void setDepth_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("depth"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_GreaterThan(Integer depth) { + setDepth_GreaterThan(depth, null); + } + + public void setDepth_GreaterThan(Integer depth, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_GREATER_THAN, depth); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_LessThan(Integer depth) { + setDepth_LessThan(depth, null); + } + + public void setDepth_LessThan(Integer depth, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_LESS_THAN, depth); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_GreaterEqual(Integer depth) { + setDepth_GreaterEqual(depth, null); + } + + public void setDepth_GreaterEqual(Integer depth, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_GREATER_EQUAL, depth); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setDepth_LessEqual(Integer depth) { + setDepth_LessEqual(depth, null); + } + + public void setDepth_LessEqual(Integer depth, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("depth", ConditionKey.CK_LESS_EQUAL, depth); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocUrls_Term(String excludedDocUrls) { + setExcludedDocUrls_Term(excludedDocUrls, null); + } + + public void setExcludedDocUrls_Term(String excludedDocUrls, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("excludedDocUrls", excludedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocUrls_Terms(Collection excludedDocUrlsList) { + setExcludedDocUrls_Terms(excludedDocUrlsList, null); + } + + public void setExcludedDocUrls_Terms(Collection excludedDocUrlsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("excludedDocUrls", excludedDocUrlsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocUrls_InScope(Collection excludedDocUrlsList) { + setExcludedDocUrls_Terms(excludedDocUrlsList, null); + } + + public void setExcludedDocUrls_InScope(Collection excludedDocUrlsList, ConditionOptionCall opLambda) { + setExcludedDocUrls_Terms(excludedDocUrlsList, opLambda); + } + + public void setExcludedDocUrls_Prefix(String excludedDocUrls) { + setExcludedDocUrls_Prefix(excludedDocUrls, null); + } + + public void setExcludedDocUrls_Prefix(String excludedDocUrls, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("excludedDocUrls", excludedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocUrls_Exists() { + setExcludedDocUrls_Exists(null); + } + + public void setExcludedDocUrls_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("excludedDocUrls"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocUrls_Missing() { + setExcludedDocUrls_Missing(null); + } + + public void setExcludedDocUrls_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("excludedDocUrls"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocUrls_GreaterThan(String excludedDocUrls) { + setExcludedDocUrls_GreaterThan(excludedDocUrls, null); + } + + public void setExcludedDocUrls_GreaterThan(String excludedDocUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedDocUrls", ConditionKey.CK_GREATER_THAN, excludedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocUrls_LessThan(String excludedDocUrls) { + setExcludedDocUrls_LessThan(excludedDocUrls, null); + } + + public void setExcludedDocUrls_LessThan(String excludedDocUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedDocUrls", ConditionKey.CK_LESS_THAN, excludedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocUrls_GreaterEqual(String excludedDocUrls) { + setExcludedDocUrls_GreaterEqual(excludedDocUrls, null); + } + + public void setExcludedDocUrls_GreaterEqual(String excludedDocUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedDocUrls", ConditionKey.CK_GREATER_EQUAL, excludedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedDocUrls_LessEqual(String excludedDocUrls) { + setExcludedDocUrls_LessEqual(excludedDocUrls, null); + } + + public void setExcludedDocUrls_LessEqual(String excludedDocUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedDocUrls", ConditionKey.CK_LESS_EQUAL, excludedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedUrls_Term(String excludedUrls) { + setExcludedUrls_Term(excludedUrls, null); + } + + public void setExcludedUrls_Term(String excludedUrls, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("excludedUrls", excludedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedUrls_Terms(Collection excludedUrlsList) { + setExcludedUrls_Terms(excludedUrlsList, null); + } + + public void setExcludedUrls_Terms(Collection excludedUrlsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("excludedUrls", excludedUrlsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedUrls_InScope(Collection excludedUrlsList) { + setExcludedUrls_Terms(excludedUrlsList, null); + } + + public void setExcludedUrls_InScope(Collection excludedUrlsList, ConditionOptionCall opLambda) { + setExcludedUrls_Terms(excludedUrlsList, opLambda); + } + + public void setExcludedUrls_Prefix(String excludedUrls) { + setExcludedUrls_Prefix(excludedUrls, null); + } + + public void setExcludedUrls_Prefix(String excludedUrls, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("excludedUrls", excludedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedUrls_Exists() { + setExcludedUrls_Exists(null); + } + + public void setExcludedUrls_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("excludedUrls"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedUrls_Missing() { + setExcludedUrls_Missing(null); + } + + public void setExcludedUrls_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("excludedUrls"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedUrls_GreaterThan(String excludedUrls) { + setExcludedUrls_GreaterThan(excludedUrls, null); + } + + public void setExcludedUrls_GreaterThan(String excludedUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedUrls", ConditionKey.CK_GREATER_THAN, excludedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedUrls_LessThan(String excludedUrls) { + setExcludedUrls_LessThan(excludedUrls, null); + } + + public void setExcludedUrls_LessThan(String excludedUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedUrls", ConditionKey.CK_LESS_THAN, excludedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedUrls_GreaterEqual(String excludedUrls) { + setExcludedUrls_GreaterEqual(excludedUrls, null); + } + + public void setExcludedUrls_GreaterEqual(String excludedUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedUrls", ConditionKey.CK_GREATER_EQUAL, excludedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setExcludedUrls_LessEqual(String excludedUrls) { + setExcludedUrls_LessEqual(excludedUrls, null); + } + + public void setExcludedUrls_LessEqual(String excludedUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("excludedUrls", ConditionKey.CK_LESS_EQUAL, excludedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocUrls_Term(String includedDocUrls) { + setIncludedDocUrls_Term(includedDocUrls, null); + } + + public void setIncludedDocUrls_Term(String includedDocUrls, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("includedDocUrls", includedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocUrls_Terms(Collection includedDocUrlsList) { + setIncludedDocUrls_Terms(includedDocUrlsList, null); + } + + public void setIncludedDocUrls_Terms(Collection includedDocUrlsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("includedDocUrls", includedDocUrlsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocUrls_InScope(Collection includedDocUrlsList) { + setIncludedDocUrls_Terms(includedDocUrlsList, null); + } + + public void setIncludedDocUrls_InScope(Collection includedDocUrlsList, ConditionOptionCall opLambda) { + setIncludedDocUrls_Terms(includedDocUrlsList, opLambda); + } + + public void setIncludedDocUrls_Prefix(String includedDocUrls) { + setIncludedDocUrls_Prefix(includedDocUrls, null); + } + + public void setIncludedDocUrls_Prefix(String includedDocUrls, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("includedDocUrls", includedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocUrls_Exists() { + setIncludedDocUrls_Exists(null); + } + + public void setIncludedDocUrls_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("includedDocUrls"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocUrls_Missing() { + setIncludedDocUrls_Missing(null); + } + + public void setIncludedDocUrls_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("includedDocUrls"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocUrls_GreaterThan(String includedDocUrls) { + setIncludedDocUrls_GreaterThan(includedDocUrls, null); + } + + public void setIncludedDocUrls_GreaterThan(String includedDocUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedDocUrls", ConditionKey.CK_GREATER_THAN, includedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocUrls_LessThan(String includedDocUrls) { + setIncludedDocUrls_LessThan(includedDocUrls, null); + } + + public void setIncludedDocUrls_LessThan(String includedDocUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedDocUrls", ConditionKey.CK_LESS_THAN, includedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocUrls_GreaterEqual(String includedDocUrls) { + setIncludedDocUrls_GreaterEqual(includedDocUrls, null); + } + + public void setIncludedDocUrls_GreaterEqual(String includedDocUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedDocUrls", ConditionKey.CK_GREATER_EQUAL, includedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedDocUrls_LessEqual(String includedDocUrls) { + setIncludedDocUrls_LessEqual(includedDocUrls, null); + } + + public void setIncludedDocUrls_LessEqual(String includedDocUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedDocUrls", ConditionKey.CK_LESS_EQUAL, includedDocUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedUrls_Term(String includedUrls) { + setIncludedUrls_Term(includedUrls, null); + } + + public void setIncludedUrls_Term(String includedUrls, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("includedUrls", includedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedUrls_Terms(Collection includedUrlsList) { + setIncludedUrls_Terms(includedUrlsList, null); + } + + public void setIncludedUrls_Terms(Collection includedUrlsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("includedUrls", includedUrlsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedUrls_InScope(Collection includedUrlsList) { + setIncludedUrls_Terms(includedUrlsList, null); + } + + public void setIncludedUrls_InScope(Collection includedUrlsList, ConditionOptionCall opLambda) { + setIncludedUrls_Terms(includedUrlsList, opLambda); + } + + public void setIncludedUrls_Prefix(String includedUrls) { + setIncludedUrls_Prefix(includedUrls, null); + } + + public void setIncludedUrls_Prefix(String includedUrls, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("includedUrls", includedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedUrls_Exists() { + setIncludedUrls_Exists(null); + } + + public void setIncludedUrls_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("includedUrls"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedUrls_Missing() { + setIncludedUrls_Missing(null); + } + + public void setIncludedUrls_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("includedUrls"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedUrls_GreaterThan(String includedUrls) { + setIncludedUrls_GreaterThan(includedUrls, null); + } + + public void setIncludedUrls_GreaterThan(String includedUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedUrls", ConditionKey.CK_GREATER_THAN, includedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedUrls_LessThan(String includedUrls) { + setIncludedUrls_LessThan(includedUrls, null); + } + + public void setIncludedUrls_LessThan(String includedUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedUrls", ConditionKey.CK_LESS_THAN, includedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedUrls_GreaterEqual(String includedUrls) { + setIncludedUrls_GreaterEqual(includedUrls, null); + } + + public void setIncludedUrls_GreaterEqual(String includedUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedUrls", ConditionKey.CK_GREATER_EQUAL, includedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIncludedUrls_LessEqual(String includedUrls) { + setIncludedUrls_LessEqual(includedUrls, null); + } + + public void setIncludedUrls_LessEqual(String includedUrls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("includedUrls", ConditionKey.CK_LESS_EQUAL, includedUrls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_Term(Integer intervalTime) { + setIntervalTime_Term(intervalTime, null); + } + + public void setIntervalTime_Term(Integer intervalTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("intervalTime", intervalTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_Terms(Collection intervalTimeList) { + setIntervalTime_Terms(intervalTimeList, null); + } + + public void setIntervalTime_Terms(Collection intervalTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("intervalTime", intervalTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_InScope(Collection intervalTimeList) { + setIntervalTime_Terms(intervalTimeList, null); + } + + public void setIntervalTime_InScope(Collection intervalTimeList, ConditionOptionCall opLambda) { + setIntervalTime_Terms(intervalTimeList, opLambda); + } + + public void setIntervalTime_Exists() { + setIntervalTime_Exists(null); + } + + public void setIntervalTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("intervalTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_Missing() { + setIntervalTime_Missing(null); + } + + public void setIntervalTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("intervalTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_GreaterThan(Integer intervalTime) { + setIntervalTime_GreaterThan(intervalTime, null); + } + + public void setIntervalTime_GreaterThan(Integer intervalTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_GREATER_THAN, intervalTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_LessThan(Integer intervalTime) { + setIntervalTime_LessThan(intervalTime, null); + } + + public void setIntervalTime_LessThan(Integer intervalTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_LESS_THAN, intervalTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_GreaterEqual(Integer intervalTime) { + setIntervalTime_GreaterEqual(intervalTime, null); + } + + public void setIntervalTime_GreaterEqual(Integer intervalTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_GREATER_EQUAL, intervalTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setIntervalTime_LessEqual(Integer intervalTime) { + setIntervalTime_LessEqual(intervalTime, null); + } + + public void setIntervalTime_LessEqual(Integer intervalTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("intervalTime", ConditionKey.CK_LESS_EQUAL, intervalTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_Term(Long maxAccessCount) { + setMaxAccessCount_Term(maxAccessCount, null); + } + + public void setMaxAccessCount_Term(Long maxAccessCount, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("maxAccessCount", maxAccessCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_Terms(Collection maxAccessCountList) { + setMaxAccessCount_Terms(maxAccessCountList, null); + } + + public void setMaxAccessCount_Terms(Collection maxAccessCountList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("maxAccessCount", maxAccessCountList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_InScope(Collection maxAccessCountList) { + setMaxAccessCount_Terms(maxAccessCountList, null); + } + + public void setMaxAccessCount_InScope(Collection maxAccessCountList, ConditionOptionCall opLambda) { + setMaxAccessCount_Terms(maxAccessCountList, opLambda); + } + + public void setMaxAccessCount_Exists() { + setMaxAccessCount_Exists(null); + } + + public void setMaxAccessCount_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("maxAccessCount"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_Missing() { + setMaxAccessCount_Missing(null); + } + + public void setMaxAccessCount_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("maxAccessCount"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_GreaterThan(Long maxAccessCount) { + setMaxAccessCount_GreaterThan(maxAccessCount, null); + } + + public void setMaxAccessCount_GreaterThan(Long maxAccessCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_GREATER_THAN, maxAccessCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_LessThan(Long maxAccessCount) { + setMaxAccessCount_LessThan(maxAccessCount, null); + } + + public void setMaxAccessCount_LessThan(Long maxAccessCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_LESS_THAN, maxAccessCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_GreaterEqual(Long maxAccessCount) { + setMaxAccessCount_GreaterEqual(maxAccessCount, null); + } + + public void setMaxAccessCount_GreaterEqual(Long maxAccessCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_GREATER_EQUAL, maxAccessCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setMaxAccessCount_LessEqual(Long maxAccessCount) { + setMaxAccessCount_LessEqual(maxAccessCount, null); + } + + public void setMaxAccessCount_LessEqual(Long maxAccessCount, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("maxAccessCount", ConditionKey.CK_LESS_EQUAL, maxAccessCount); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Term(String name) { + setName_Term(name, null); + } + + public void setName_Term(String name, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Terms(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("name", nameList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_InScope(Collection nameList) { + setName_Terms(nameList, null); + } + + public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { + setName_Terms(nameList, opLambda); + } + + public void setName_Prefix(String name) { + setName_Prefix(name, null); + } + + public void setName_Prefix(String name, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("name", name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Exists() { + setName_Exists(null); + } + + public void setName_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_Missing() { + setName_Missing(null); + } + + public void setName_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("name"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterThan(String name) { + setName_GreaterThan(name, null); + } + + public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessThan(String name) { + setName_LessThan(name, null); + } + + public void setName_LessThan(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_THAN, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_GreaterEqual(String name) { + setName_GreaterEqual(name, null); + } + + public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_GREATER_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setName_LessEqual(String name) { + setName_LessEqual(name, null); + } + + public void setName_LessEqual(String name, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("name", ConditionKey.CK_LESS_EQUAL, name); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_Term(Integer numOfThread) { + setNumOfThread_Term(numOfThread, null); + } + + public void setNumOfThread_Term(Integer numOfThread, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("numOfThread", numOfThread); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_Terms(Collection numOfThreadList) { + setNumOfThread_Terms(numOfThreadList, null); + } + + public void setNumOfThread_Terms(Collection numOfThreadList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("numOfThread", numOfThreadList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_InScope(Collection numOfThreadList) { + setNumOfThread_Terms(numOfThreadList, null); + } + + public void setNumOfThread_InScope(Collection numOfThreadList, ConditionOptionCall opLambda) { + setNumOfThread_Terms(numOfThreadList, opLambda); + } + + public void setNumOfThread_Exists() { + setNumOfThread_Exists(null); + } + + public void setNumOfThread_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("numOfThread"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_Missing() { + setNumOfThread_Missing(null); + } + + public void setNumOfThread_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("numOfThread"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_GreaterThan(Integer numOfThread) { + setNumOfThread_GreaterThan(numOfThread, null); + } + + public void setNumOfThread_GreaterThan(Integer numOfThread, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_GREATER_THAN, numOfThread); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_LessThan(Integer numOfThread) { + setNumOfThread_LessThan(numOfThread, null); + } + + public void setNumOfThread_LessThan(Integer numOfThread, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_LESS_THAN, numOfThread); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_GreaterEqual(Integer numOfThread) { + setNumOfThread_GreaterEqual(numOfThread, null); + } + + public void setNumOfThread_GreaterEqual(Integer numOfThread, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_GREATER_EQUAL, numOfThread); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setNumOfThread_LessEqual(Integer numOfThread) { + setNumOfThread_LessEqual(numOfThread, null); + } + + public void setNumOfThread_LessEqual(Integer numOfThread, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("numOfThread", ConditionKey.CK_LESS_EQUAL, numOfThread); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Term(Integer sortOrder) { + setSortOrder_Term(sortOrder, null); + } + + public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("sortOrder", sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Terms(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("sortOrder", sortOrderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_InScope(Collection sortOrderList) { + setSortOrder_Terms(sortOrderList, null); + } + + public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { + setSortOrder_Terms(sortOrderList, opLambda); + } + + public void setSortOrder_Exists() { + setSortOrder_Exists(null); + } + + public void setSortOrder_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_Missing() { + setSortOrder_Missing(null); + } + + public void setSortOrder_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("sortOrder"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterThan(Integer sortOrder) { + setSortOrder_GreaterThan(sortOrder, null); + } + + public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessThan(Integer sortOrder) { + setSortOrder_LessThan(sortOrder, null); + } + + public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_GreaterEqual(Integer sortOrder) { + setSortOrder_GreaterEqual(sortOrder, null); + } + + public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setSortOrder_LessEqual(Integer sortOrder) { + setSortOrder_LessEqual(sortOrder, null); + } + + public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Term(String updatedBy) { + setUpdatedBy_Term(updatedBy, null); + } + + public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Terms(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedBy", updatedByList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_InScope(Collection updatedByList) { + setUpdatedBy_Terms(updatedByList, null); + } + + public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { + setUpdatedBy_Terms(updatedByList, opLambda); + } + + public void setUpdatedBy_Prefix(String updatedBy) { + setUpdatedBy_Prefix(updatedBy, null); + } + + public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("updatedBy", updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Exists() { + setUpdatedBy_Exists(null); + } + + public void setUpdatedBy_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_Missing() { + setUpdatedBy_Missing(null); + } + + public void setUpdatedBy_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedBy"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterThan(String updatedBy) { + setUpdatedBy_GreaterThan(updatedBy, null); + } + + public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessThan(String updatedBy) { + setUpdatedBy_LessThan(updatedBy, null); + } + + public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_GreaterEqual(String updatedBy) { + setUpdatedBy_GreaterEqual(updatedBy, null); + } + + public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedBy_LessEqual(String updatedBy) { + setUpdatedBy_LessEqual(updatedBy, null); + } + + public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Term(Long updatedTime) { + setUpdatedTime_Term(updatedTime, null); + } + + public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("updatedTime", updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Terms(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("updatedTime", updatedTimeList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_InScope(Collection updatedTimeList) { + setUpdatedTime_Terms(updatedTimeList, null); + } + + public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { + setUpdatedTime_Terms(updatedTimeList, opLambda); + } + + public void setUpdatedTime_Exists() { + setUpdatedTime_Exists(null); + } + + public void setUpdatedTime_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_Missing() { + setUpdatedTime_Missing(null); + } + + public void setUpdatedTime_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("updatedTime"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterThan(Long updatedTime) { + setUpdatedTime_GreaterThan(updatedTime, null); + } + + public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessThan(Long updatedTime) { + setUpdatedTime_LessThan(updatedTime, null); + } + + public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime) { + setUpdatedTime_GreaterEqual(updatedTime, null); + } + + public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUpdatedTime_LessEqual(Long updatedTime) { + setUpdatedTime_LessEqual(updatedTime, null); + } + + public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrls_Term(String urls) { + setUrls_Term(urls, null); + } + + public void setUrls_Term(String urls, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("urls", urls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrls_Terms(Collection urlsList) { + setUrls_Terms(urlsList, null); + } + + public void setUrls_Terms(Collection urlsList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("urls", urlsList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrls_InScope(Collection urlsList) { + setUrls_Terms(urlsList, null); + } + + public void setUrls_InScope(Collection urlsList, ConditionOptionCall opLambda) { + setUrls_Terms(urlsList, opLambda); + } + + public void setUrls_Prefix(String urls) { + setUrls_Prefix(urls, null); + } + + public void setUrls_Prefix(String urls, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("urls", urls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrls_Exists() { + setUrls_Exists(null); + } + + public void setUrls_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("urls"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrls_Missing() { + setUrls_Missing(null); + } + + public void setUrls_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("urls"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrls_GreaterThan(String urls) { + setUrls_GreaterThan(urls, null); + } + + public void setUrls_GreaterThan(String urls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("urls", ConditionKey.CK_GREATER_THAN, urls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrls_LessThan(String urls) { + setUrls_LessThan(urls, null); + } + + public void setUrls_LessThan(String urls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("urls", ConditionKey.CK_LESS_THAN, urls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrls_GreaterEqual(String urls) { + setUrls_GreaterEqual(urls, null); + } + + public void setUrls_GreaterEqual(String urls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("urls", ConditionKey.CK_GREATER_EQUAL, urls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUrls_LessEqual(String urls) { + setUrls_LessEqual(urls, null); + } + + public void setUrls_LessEqual(String urls, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("urls", ConditionKey.CK_LESS_EQUAL, urls); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_Term(String userAgent) { + setUserAgent_Term(userAgent, null); + } + + public void setUserAgent_Term(String userAgent, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("userAgent", userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_Terms(Collection userAgentList) { + setUserAgent_Terms(userAgentList, null); + } + + public void setUserAgent_Terms(Collection userAgentList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("userAgent", userAgentList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_InScope(Collection userAgentList) { + setUserAgent_Terms(userAgentList, null); + } + + public void setUserAgent_InScope(Collection userAgentList, ConditionOptionCall opLambda) { + setUserAgent_Terms(userAgentList, opLambda); + } + + public void setUserAgent_Prefix(String userAgent) { + setUserAgent_Prefix(userAgent, null); + } + + public void setUserAgent_Prefix(String userAgent, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("userAgent", userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_Exists() { + setUserAgent_Exists(null); + } + + public void setUserAgent_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("userAgent"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_Missing() { + setUserAgent_Missing(null); + } + + public void setUserAgent_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("userAgent"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_GreaterThan(String userAgent) { + setUserAgent_GreaterThan(userAgent, null); + } + + public void setUserAgent_GreaterThan(String userAgent, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_GREATER_THAN, userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_LessThan(String userAgent) { + setUserAgent_LessThan(userAgent, null); + } + + public void setUserAgent_LessThan(String userAgent, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_LESS_THAN, userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_GreaterEqual(String userAgent) { + setUserAgent_GreaterEqual(userAgent, null); + } + + public void setUserAgent_GreaterEqual(String userAgent, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_GREATER_EQUAL, userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setUserAgent_LessEqual(String userAgent) { + setUserAgent_LessEqual(userAgent, null); + } + + public void setUserAgent_LessEqual(String userAgent, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("userAgent", ConditionKey.CK_LESS_EQUAL, userAgent); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigToLabelCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigToLabelCF.java new file mode 100644 index 000000000..20b5742a7 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigToLabelCF.java @@ -0,0 +1,430 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.WebConfigToLabelCF; +import org.codelibs.fess.es.cbean.cq.WebConfigToLabelCQ; +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 BsWebConfigToLabelCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + WebConfigToLabelCF mustFilter = new WebConfigToLabelCF(); + WebConfigToLabelCF shouldFilter = new WebConfigToLabelCF(); + WebConfigToLabelCF mustNotFilter = new WebConfigToLabelCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + WebConfigToLabelCF andFilter = new WebConfigToLabelCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + WebConfigToLabelCF orFilter = new WebConfigToLabelCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + WebConfigToLabelCF notFilter = new WebConfigToLabelCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + WebConfigToLabelCQ query = new WebConfigToLabelCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Term(String labelTypeId) { + setLabelTypeId_Term(labelTypeId, null); + } + + public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("labelTypeId", labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Terms(Collection labelTypeIdList) { + setLabelTypeId_Terms(labelTypeIdList, null); + } + + public void setLabelTypeId_Terms(Collection labelTypeIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("labelTypeId", labelTypeIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_InScope(Collection labelTypeIdList) { + setLabelTypeId_Terms(labelTypeIdList, null); + } + + public void setLabelTypeId_InScope(Collection labelTypeIdList, ConditionOptionCall opLambda) { + setLabelTypeId_Terms(labelTypeIdList, opLambda); + } + + public void setLabelTypeId_Prefix(String labelTypeId) { + setLabelTypeId_Prefix(labelTypeId, null); + } + + public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("labelTypeId", labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Exists() { + setLabelTypeId_Exists(null); + } + + public void setLabelTypeId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("labelTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_Missing() { + setLabelTypeId_Missing(null); + } + + public void setLabelTypeId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("labelTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_GreaterThan(String labelTypeId) { + setLabelTypeId_GreaterThan(labelTypeId, null); + } + + public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_LessThan(String labelTypeId) { + setLabelTypeId_LessThan(labelTypeId, null); + } + + public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_GreaterEqual(String labelTypeId) { + setLabelTypeId_GreaterEqual(labelTypeId, null); + } + + public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setLabelTypeId_LessEqual(String labelTypeId) { + setLabelTypeId_LessEqual(labelTypeId, null); + } + + public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Term(String webConfigId) { + setWebConfigId_Term(webConfigId, null); + } + + public void setWebConfigId_Term(String webConfigId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("webConfigId", webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Terms(Collection webConfigIdList) { + setWebConfigId_Terms(webConfigIdList, null); + } + + public void setWebConfigId_Terms(Collection webConfigIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("webConfigId", webConfigIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_InScope(Collection webConfigIdList) { + setWebConfigId_Terms(webConfigIdList, null); + } + + public void setWebConfigId_InScope(Collection webConfigIdList, ConditionOptionCall opLambda) { + setWebConfigId_Terms(webConfigIdList, opLambda); + } + + public void setWebConfigId_Prefix(String webConfigId) { + setWebConfigId_Prefix(webConfigId, null); + } + + public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("webConfigId", webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Exists() { + setWebConfigId_Exists(null); + } + + public void setWebConfigId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("webConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Missing() { + setWebConfigId_Missing(null); + } + + public void setWebConfigId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("webConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_GreaterThan(String webConfigId) { + setWebConfigId_GreaterThan(webConfigId, null); + } + + public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_LessThan(String webConfigId) { + setWebConfigId_LessThan(webConfigId, null); + } + + public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_GreaterEqual(String webConfigId) { + setWebConfigId_GreaterEqual(webConfigId, null); + } + + public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_LessEqual(String webConfigId) { + setWebConfigId_LessEqual(webConfigId, null); + } + + public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigToRoleCF.java b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigToRoleCF.java new file mode 100644 index 000000000..9747c4465 --- /dev/null +++ b/src/main/java/org/codelibs/fess/es/cbean/cf/bs/BsWebConfigToRoleCF.java @@ -0,0 +1,430 @@ +package org.codelibs.fess.es.cbean.cf.bs; + +import java.util.Collection; + +import org.codelibs.fess.es.cbean.cf.WebConfigToRoleCF; +import org.codelibs.fess.es.cbean.cq.WebConfigToRoleCQ; +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 BsWebConfigToRoleCF extends AbstractConditionFilter { + + public void bool(BoolCall boolLambda) { + bool(boolLambda, null); + } + + public void bool(BoolCall boolLambda, ConditionOptionCall opLambda) { + WebConfigToRoleCF mustFilter = new WebConfigToRoleCF(); + WebConfigToRoleCF shouldFilter = new WebConfigToRoleCF(); + WebConfigToRoleCF mustNotFilter = new WebConfigToRoleCF(); + 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 andLambda) { + and(andLambda, null); + } + + public void and(OperatorCall andLambda, ConditionOptionCall opLambda) { + WebConfigToRoleCF andFilter = new WebConfigToRoleCF(); + andLambda.callback(andFilter); + if (andFilter.hasFilters()) { + AndFilterBuilder builder = regAndF(andFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void or(OperatorCall orLambda) { + or(orLambda, null); + } + + public void or(OperatorCall orLambda, ConditionOptionCall opLambda) { + WebConfigToRoleCF orFilter = new WebConfigToRoleCF(); + orLambda.callback(orFilter); + if (orFilter.hasFilters()) { + OrFilterBuilder builder = regOrF(orFilter.filterBuilderList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void not(OperatorCall notLambda) { + not(notLambda, null); + } + + public void not(OperatorCall notLambda, ConditionOptionCall opLambda) { + WebConfigToRoleCF notFilter = new WebConfigToRoleCF(); + 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 queryLambda) { + query(queryLambda, null); + } + + public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall queryLambda, + ConditionOptionCall opLambda) { + WebConfigToRoleCQ query = new WebConfigToRoleCQ(); + queryLambda.callback(query); + if (query.hasQueries()) { + QueryFilterBuilder builder = regQueryF(query.getQuery()); + if (opLambda != null) { + opLambda.callback(builder); + } + } + } + + public void setId_Term(String id) { + setId_Term(id, null); + } + + public void setId_Term(String id, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Terms(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("id", idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_InScope(Collection idList) { + setId_Terms(idList, null); + } + + public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { + setId_Terms(idList, opLambda); + } + + public void setId_Prefix(String id) { + setId_Prefix(id, null); + } + + public void setId_Prefix(String id, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("id", id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Exists() { + setId_Exists(null); + } + + public void setId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_Missing() { + setId_Missing(null); + } + + public void setId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("id"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterThan(String id) { + setId_GreaterThan(id, null); + } + + public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessThan(String id) { + setId_LessThan(id, null); + } + + public void setId_LessThan(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_THAN, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_GreaterEqual(String id) { + setId_GreaterEqual(id, null); + } + + public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_GREATER_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setId_LessEqual(String id) { + setId_LessEqual(id, null); + } + + public void setId_LessEqual(String id, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("id", ConditionKey.CK_LESS_EQUAL, id); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Term(String roleTypeId) { + setRoleTypeId_Term(roleTypeId, null); + } + + public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("roleTypeId", roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Terms(Collection roleTypeIdList) { + setRoleTypeId_Terms(roleTypeIdList, null); + } + + public void setRoleTypeId_Terms(Collection roleTypeIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("roleTypeId", roleTypeIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_InScope(Collection roleTypeIdList) { + setRoleTypeId_Terms(roleTypeIdList, null); + } + + public void setRoleTypeId_InScope(Collection roleTypeIdList, ConditionOptionCall opLambda) { + setRoleTypeId_Terms(roleTypeIdList, opLambda); + } + + public void setRoleTypeId_Prefix(String roleTypeId) { + setRoleTypeId_Prefix(roleTypeId, null); + } + + public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("roleTypeId", roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Exists() { + setRoleTypeId_Exists(null); + } + + public void setRoleTypeId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("roleTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_Missing() { + setRoleTypeId_Missing(null); + } + + public void setRoleTypeId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("roleTypeId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_GreaterThan(String roleTypeId) { + setRoleTypeId_GreaterThan(roleTypeId, null); + } + + public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_LessThan(String roleTypeId) { + setRoleTypeId_LessThan(roleTypeId, null); + } + + public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_GreaterEqual(String roleTypeId) { + setRoleTypeId_GreaterEqual(roleTypeId, null); + } + + public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setRoleTypeId_LessEqual(String roleTypeId) { + setRoleTypeId_LessEqual(roleTypeId, null); + } + + public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Term(String webConfigId) { + setWebConfigId_Term(webConfigId, null); + } + + public void setWebConfigId_Term(String webConfigId, ConditionOptionCall opLambda) { + TermFilterBuilder builder = regTermF("webConfigId", webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Terms(Collection webConfigIdList) { + setWebConfigId_Terms(webConfigIdList, null); + } + + public void setWebConfigId_Terms(Collection webConfigIdList, ConditionOptionCall opLambda) { + TermsFilterBuilder builder = regTermsF("webConfigId", webConfigIdList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_InScope(Collection webConfigIdList) { + setWebConfigId_Terms(webConfigIdList, null); + } + + public void setWebConfigId_InScope(Collection webConfigIdList, ConditionOptionCall opLambda) { + setWebConfigId_Terms(webConfigIdList, opLambda); + } + + public void setWebConfigId_Prefix(String webConfigId) { + setWebConfigId_Prefix(webConfigId, null); + } + + public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall opLambda) { + PrefixFilterBuilder builder = regPrefixF("webConfigId", webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Exists() { + setWebConfigId_Exists(null); + } + + public void setWebConfigId_Exists(ConditionOptionCall opLambda) { + ExistsFilterBuilder builder = regExistsF("webConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_Missing() { + setWebConfigId_Missing(null); + } + + public void setWebConfigId_Missing(ConditionOptionCall opLambda) { + MissingFilterBuilder builder = regMissingF("webConfigId"); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_GreaterThan(String webConfigId) { + setWebConfigId_GreaterThan(webConfigId, null); + } + + public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_LessThan(String webConfigId) { + setWebConfigId_LessThan(webConfigId, null); + } + + public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_GreaterEqual(String webConfigId) { + setWebConfigId_GreaterEqual(webConfigId, null); + } + + public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void setWebConfigId_LessEqual(String webConfigId) { + setWebConfigId_LessEqual(webConfigId, null); + } + + public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall opLambda) { + RangeFilterBuilder builder = regRangeF("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +} diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/AbstractConditionQuery.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/AbstractConditionQuery.java index 92caadd26..632b74abe 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/AbstractConditionQuery.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/AbstractConditionQuery.java @@ -5,6 +5,7 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import org.codelibs.fess.es.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 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 mustList, List shouldList, List mustNotList) { + protected BoolQueryBuilder regBoolCQ(List mustList, List shouldList, List 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,8 +371,14 @@ public abstract class AbstractConditionQuery implements ConditionQuery { } @FunctionalInterface - public interface FilteredCall { + public interface FilteredCall { - void callback(CQ query); + void callback(CQ query, CF filter); + } + + @FunctionalInterface + public interface OperatorCall { + + void callback(CQ and); } } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsBoostDocumentRuleCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsBoostDocumentRuleCQ.java index e9c1ab961..69e57de35 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsBoostDocumentRuleCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsBoostDocumentRuleCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.BoostDocumentRuleCQ; +import org.codelibs.fess.es.cbean.cf.BoostDocumentRuleCF; 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 BsBoostDocumentRuleCQ extends AbstractConditionQuery { return "boost_document_rule"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { BoostDocumentRuleCQ query = new BoostDocumentRuleCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + BoostDocumentRuleCF filter = new BoostDocumentRuleCF(); + 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 BsBoostDocumentRuleCQ extends AbstractConditionQuery { BoostDocumentRuleCQ shouldQuery = new BoostDocumentRuleCQ(); BoostDocumentRuleCQ mustNotQuery = new BoostDocumentRuleCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setBoostExpr_Term(String boostExpr, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("boostExpr", boostExpr); + TermQueryBuilder builder = regTermQ("boostExpr", boostExpr); if (opLambda != null) { opLambda.callback(builder); } } public void setBoostExpr_Terms(Collection boostExprList) { - setBoostExpr_MatchPhrasePrefix(boostExprList, null); + setBoostExpr_Terms(boostExprList, null); } - public void setBoostExpr_MatchPhrasePrefix(Collection boostExprList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("boostExpr", boostExprList); + public void setBoostExpr_Terms(Collection boostExprList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("boostExpr", boostExprList); if (opLambda != null) { opLambda.callback(builder); } } public void setBoostExpr_InScope(Collection boostExprList) { - setBoostExpr_MatchPhrasePrefix(boostExprList, null); + setBoostExpr_Terms(boostExprList, null); } public void setBoostExpr_InScope(Collection boostExprList, ConditionOptionCall opLambda) { - setBoostExpr_MatchPhrasePrefix(boostExprList, opLambda); + setBoostExpr_Terms(boostExprList, opLambda); } public void setBoostExpr_Match(String boostExpr) { @@ -96,7 +98,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setBoostExpr_Match(String boostExpr, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("boostExpr", boostExpr); + MatchQueryBuilder builder = regMatchQ("boostExpr", boostExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setBoostExpr_MatchPhrase(String boostExpr, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("boostExpr", boostExpr); + MatchQueryBuilder builder = regMatchPhraseQ("boostExpr", boostExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setBoostExpr_MatchPhrasePrefix(String boostExpr, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("boostExpr", boostExpr); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("boostExpr", boostExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setBoostExpr_Fuzzy(String boostExpr, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("boostExpr", boostExpr); + FuzzyQueryBuilder builder = regFuzzyQ("boostExpr", boostExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setBoostExpr_Prefix(String boostExpr, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("boostExpr", boostExpr); + PrefixQueryBuilder builder = regPrefixQ("boostExpr", boostExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setBoostExpr_GreaterThan(String boostExpr, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boostExpr", ConditionKey.CK_GREATER_THAN, boostExpr); + RangeQueryBuilder builder = regRangeQ("boostExpr", ConditionKey.CK_GREATER_THAN, boostExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setBoostExpr_LessThan(String boostExpr, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boostExpr", ConditionKey.CK_LESS_THAN, boostExpr); + RangeQueryBuilder builder = regRangeQ("boostExpr", ConditionKey.CK_LESS_THAN, boostExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setBoostExpr_GreaterEqual(String boostExpr, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boostExpr", ConditionKey.CK_GREATER_EQUAL, boostExpr); + RangeQueryBuilder builder = regRangeQ("boostExpr", ConditionKey.CK_GREATER_EQUAL, boostExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +186,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setBoostExpr_LessEqual(String boostExpr, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boostExpr", ConditionKey.CK_LESS_EQUAL, boostExpr); + RangeQueryBuilder builder = regRangeQ("boostExpr", ConditionKey.CK_LESS_EQUAL, boostExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +207,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -235,7 +237,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +314,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -323,7 +325,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -344,29 +346,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -374,7 +376,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +453,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +474,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -502,7 +504,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +515,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +526,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +537,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +548,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +559,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +570,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +581,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +592,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +613,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder); + TermQueryBuilder builder = regTermQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_Terms(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } - public void setSortOrder_MatchPhrasePrefix(Collection sortOrderList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList); + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_InScope(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { - setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda); + setSortOrder_Terms(sortOrderList, opLambda); } public void setSortOrder_Match(Integer sortOrder) { @@ -641,7 +643,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +654,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +665,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +676,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder); + FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +687,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +698,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +709,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +720,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -739,29 +741,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -769,7 +771,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -780,7 +782,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +793,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +804,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +815,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +826,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +837,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +848,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +859,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -878,29 +880,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -908,7 +910,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -919,7 +921,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +932,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +943,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +954,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +965,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +976,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +987,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1006,29 +1008,29 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUrlExpr_Term(String urlExpr, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("urlExpr", urlExpr); + TermQueryBuilder builder = regTermQ("urlExpr", urlExpr); if (opLambda != null) { opLambda.callback(builder); } } public void setUrlExpr_Terms(Collection urlExprList) { - setUrlExpr_MatchPhrasePrefix(urlExprList, null); + setUrlExpr_Terms(urlExprList, null); } - public void setUrlExpr_MatchPhrasePrefix(Collection urlExprList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("urlExpr", urlExprList); + public void setUrlExpr_Terms(Collection urlExprList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("urlExpr", urlExprList); if (opLambda != null) { opLambda.callback(builder); } } public void setUrlExpr_InScope(Collection urlExprList) { - setUrlExpr_MatchPhrasePrefix(urlExprList, null); + setUrlExpr_Terms(urlExprList, null); } public void setUrlExpr_InScope(Collection urlExprList, ConditionOptionCall opLambda) { - setUrlExpr_MatchPhrasePrefix(urlExprList, opLambda); + setUrlExpr_Terms(urlExprList, opLambda); } public void setUrlExpr_Match(String urlExpr) { @@ -1036,7 +1038,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUrlExpr_Match(String urlExpr, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("urlExpr", urlExpr); + MatchQueryBuilder builder = regMatchQ("urlExpr", urlExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -1047,7 +1049,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUrlExpr_MatchPhrase(String urlExpr, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("urlExpr", urlExpr); + MatchQueryBuilder builder = regMatchPhraseQ("urlExpr", urlExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1060,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUrlExpr_MatchPhrasePrefix(String urlExpr, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("urlExpr", urlExpr); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("urlExpr", urlExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1071,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUrlExpr_Fuzzy(String urlExpr, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("urlExpr", urlExpr); + FuzzyQueryBuilder builder = regFuzzyQ("urlExpr", urlExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1082,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUrlExpr_Prefix(String urlExpr, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("urlExpr", urlExpr); + PrefixQueryBuilder builder = regPrefixQ("urlExpr", urlExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1093,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUrlExpr_GreaterThan(String urlExpr, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("urlExpr", ConditionKey.CK_GREATER_THAN, urlExpr); + RangeQueryBuilder builder = regRangeQ("urlExpr", ConditionKey.CK_GREATER_THAN, urlExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1104,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUrlExpr_LessThan(String urlExpr, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("urlExpr", ConditionKey.CK_LESS_THAN, urlExpr); + RangeQueryBuilder builder = regRangeQ("urlExpr", ConditionKey.CK_LESS_THAN, urlExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1115,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUrlExpr_GreaterEqual(String urlExpr, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("urlExpr", ConditionKey.CK_GREATER_EQUAL, urlExpr); + RangeQueryBuilder builder = regRangeQ("urlExpr", ConditionKey.CK_GREATER_EQUAL, urlExpr); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1126,7 @@ public abstract class BsBoostDocumentRuleCQ extends AbstractConditionQuery { } public void setUrlExpr_LessEqual(String urlExpr, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("urlExpr", ConditionKey.CK_LESS_EQUAL, urlExpr); + RangeQueryBuilder builder = regRangeQ("urlExpr", ConditionKey.CK_LESS_EQUAL, urlExpr); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsClickLogCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsClickLogCQ.java index 66857790f..8f7d8a5d5 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsClickLogCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsClickLogCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.ClickLogCQ; +import org.codelibs.fess.es.cbean.cf.ClickLogCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { return "click_log"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { ClickLogCQ query = new ClickLogCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + ClickLogCF filter = new ClickLogCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { ClickLogCQ shouldQuery = new ClickLogCQ(); ClickLogCQ mustNotQuery = new ClickLogCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -96,7 +97,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +185,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +206,29 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setRequestedTime_Term(Long requestedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("requestedTime", requestedTime); + TermQueryBuilder builder = regTermQ("requestedTime", requestedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setRequestedTime_Terms(Collection requestedTimeList) { - setRequestedTime_MatchPhrasePrefix(requestedTimeList, null); + setRequestedTime_Terms(requestedTimeList, null); } - public void setRequestedTime_MatchPhrasePrefix(Collection requestedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("requestedTime", requestedTimeList); + public void setRequestedTime_Terms(Collection requestedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("requestedTime", requestedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setRequestedTime_InScope(Collection requestedTimeList) { - setRequestedTime_MatchPhrasePrefix(requestedTimeList, null); + setRequestedTime_Terms(requestedTimeList, null); } public void setRequestedTime_InScope(Collection requestedTimeList, ConditionOptionCall opLambda) { - setRequestedTime_MatchPhrasePrefix(requestedTimeList, opLambda); + setRequestedTime_Terms(requestedTimeList, opLambda); } public void setRequestedTime_Match(Long requestedTime) { @@ -235,7 +236,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setRequestedTime_Match(Long requestedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("requestedTime", requestedTime); + MatchQueryBuilder builder = regMatchQ("requestedTime", requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setRequestedTime_MatchPhrase(Long requestedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("requestedTime", requestedTime); + MatchQueryBuilder builder = regMatchPhraseQ("requestedTime", requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setRequestedTime_MatchPhrasePrefix(Long requestedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("requestedTime", requestedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("requestedTime", requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setRequestedTime_Fuzzy(Long requestedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("requestedTime", requestedTime); + FuzzyQueryBuilder builder = regFuzzyQ("requestedTime", requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setRequestedTime_GreaterThan(Long requestedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_GREATER_THAN, requestedTime); + RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_GREATER_THAN, requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setRequestedTime_LessThan(Long requestedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_LESS_THAN, requestedTime); + RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_LESS_THAN, requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setRequestedTime_GreaterEqual(Long requestedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_GREATER_EQUAL, requestedTime); + RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_GREATER_EQUAL, requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setRequestedTime_LessEqual(Long requestedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_LESS_EQUAL, requestedTime); + RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_LESS_EQUAL, requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setSearchLogId_Term(String searchLogId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("searchLogId", searchLogId); + TermQueryBuilder builder = regTermQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } } public void setSearchLogId_Terms(Collection searchLogIdList) { - setSearchLogId_MatchPhrasePrefix(searchLogIdList, null); + setSearchLogId_Terms(searchLogIdList, null); } - public void setSearchLogId_MatchPhrasePrefix(Collection searchLogIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("searchLogId", searchLogIdList); + public void setSearchLogId_Terms(Collection searchLogIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("searchLogId", searchLogIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setSearchLogId_InScope(Collection searchLogIdList) { - setSearchLogId_MatchPhrasePrefix(searchLogIdList, null); + setSearchLogId_Terms(searchLogIdList, null); } public void setSearchLogId_InScope(Collection searchLogIdList, ConditionOptionCall opLambda) { - setSearchLogId_MatchPhrasePrefix(searchLogIdList, opLambda); + setSearchLogId_Terms(searchLogIdList, opLambda); } public void setSearchLogId_Match(String searchLogId) { @@ -363,7 +364,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setSearchLogId_Match(String searchLogId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("searchLogId", searchLogId); + MatchQueryBuilder builder = regMatchQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setSearchLogId_MatchPhrase(String searchLogId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("searchLogId", searchLogId); + MatchQueryBuilder builder = regMatchPhraseQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setSearchLogId_MatchPhrasePrefix(String searchLogId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("searchLogId", searchLogId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setSearchLogId_Fuzzy(String searchLogId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("searchLogId", searchLogId); + FuzzyQueryBuilder builder = regFuzzyQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setSearchLogId_Prefix(String searchLogId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("searchLogId", searchLogId); + PrefixQueryBuilder builder = regPrefixQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setSearchLogId_GreaterThan(String searchLogId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId); + RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setSearchLogId_LessThan(String searchLogId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId); + RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setSearchLogId_GreaterEqual(String searchLogId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId); + RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setSearchLogId_LessEqual(String searchLogId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId); + RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setUrl_Term(String url, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("url", url); + TermQueryBuilder builder = regTermQ("url", url); if (opLambda != null) { opLambda.callback(builder); } } public void setUrl_Terms(Collection urlList) { - setUrl_MatchPhrasePrefix(urlList, null); + setUrl_Terms(urlList, null); } - public void setUrl_MatchPhrasePrefix(Collection urlList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("url", urlList); + public void setUrl_Terms(Collection urlList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("url", urlList); if (opLambda != null) { opLambda.callback(builder); } } public void setUrl_InScope(Collection urlList) { - setUrl_MatchPhrasePrefix(urlList, null); + setUrl_Terms(urlList, null); } public void setUrl_InScope(Collection urlList, ConditionOptionCall opLambda) { - setUrl_MatchPhrasePrefix(urlList, opLambda); + setUrl_Terms(urlList, opLambda); } public void setUrl_Match(String url) { @@ -502,7 +503,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setUrl_Match(String url, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("url", url); + MatchQueryBuilder builder = regMatchQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setUrl_MatchPhrase(String url, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("url", url); + MatchQueryBuilder builder = regMatchPhraseQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setUrl_MatchPhrasePrefix(String url, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("url", url); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setUrl_Fuzzy(String url, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("url", url); + FuzzyQueryBuilder builder = regFuzzyQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setUrl_Prefix(String url, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("url", url); + PrefixQueryBuilder builder = regPrefixQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setUrl_GreaterThan(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_THAN, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_THAN, url); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setUrl_LessThan(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_THAN, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_THAN, url); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setUrl_GreaterEqual(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +591,7 @@ public abstract class BsClickLogCQ extends AbstractConditionQuery { } public void setUrl_LessEqual(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_EQUAL, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_EQUAL, url); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsCrawlingSessionCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsCrawlingSessionCQ.java index 68a4fc797..14b023b3e 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsCrawlingSessionCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsCrawlingSessionCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.CrawlingSessionCQ; +import org.codelibs.fess.es.cbean.cf.CrawlingSessionCF; 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 BsCrawlingSessionCQ extends AbstractConditionQuery { return "crawling_session"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { CrawlingSessionCQ query = new CrawlingSessionCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + CrawlingSessionCF filter = new CrawlingSessionCF(); + 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 BsCrawlingSessionCQ extends AbstractConditionQuery { CrawlingSessionCQ shouldQuery = new CrawlingSessionCQ(); CrawlingSessionCQ mustNotQuery = new CrawlingSessionCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -96,7 +98,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -194,29 +196,29 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setExpiredTime_Term(Long expiredTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("expiredTime", expiredTime); + TermQueryBuilder builder = regTermQ("expiredTime", expiredTime); if (opLambda != null) { opLambda.callback(builder); } } public void setExpiredTime_Terms(Collection expiredTimeList) { - setExpiredTime_MatchPhrasePrefix(expiredTimeList, null); + setExpiredTime_Terms(expiredTimeList, null); } - public void setExpiredTime_MatchPhrasePrefix(Collection expiredTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("expiredTime", expiredTimeList); + public void setExpiredTime_Terms(Collection expiredTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("expiredTime", expiredTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setExpiredTime_InScope(Collection expiredTimeList) { - setExpiredTime_MatchPhrasePrefix(expiredTimeList, null); + setExpiredTime_Terms(expiredTimeList, null); } public void setExpiredTime_InScope(Collection expiredTimeList, ConditionOptionCall opLambda) { - setExpiredTime_MatchPhrasePrefix(expiredTimeList, opLambda); + setExpiredTime_Terms(expiredTimeList, opLambda); } public void setExpiredTime_Match(Long expiredTime) { @@ -224,7 +226,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setExpiredTime_Match(Long expiredTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("expiredTime", expiredTime); + MatchQueryBuilder builder = regMatchQ("expiredTime", expiredTime); if (opLambda != null) { opLambda.callback(builder); } @@ -235,7 +237,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setExpiredTime_MatchPhrase(Long expiredTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("expiredTime", expiredTime); + MatchQueryBuilder builder = regMatchPhraseQ("expiredTime", expiredTime); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setExpiredTime_MatchPhrasePrefix(Long expiredTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("expiredTime", expiredTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("expiredTime", expiredTime); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setExpiredTime_Fuzzy(Long expiredTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("expiredTime", expiredTime); + FuzzyQueryBuilder builder = regFuzzyQ("expiredTime", expiredTime); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setExpiredTime_GreaterThan(Long expiredTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("expiredTime", ConditionKey.CK_GREATER_THAN, expiredTime); + RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_GREATER_THAN, expiredTime); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setExpiredTime_LessThan(Long expiredTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("expiredTime", ConditionKey.CK_LESS_THAN, expiredTime); + RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_LESS_THAN, expiredTime); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setExpiredTime_GreaterEqual(Long expiredTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("expiredTime", ConditionKey.CK_GREATER_EQUAL, expiredTime); + RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_GREATER_EQUAL, expiredTime); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setExpiredTime_LessEqual(Long expiredTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("expiredTime", ConditionKey.CK_LESS_EQUAL, expiredTime); + RangeQueryBuilder builder = regRangeQ("expiredTime", ConditionKey.CK_LESS_EQUAL, expiredTime); if (opLambda != null) { opLambda.callback(builder); } @@ -322,29 +324,29 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -352,7 +354,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -363,7 +365,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +376,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -461,29 +463,29 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setName_Term(String name, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("name", name); + TermQueryBuilder builder = regTermQ("name", name); if (opLambda != null) { opLambda.callback(builder); } } public void setName_Terms(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } - public void setName_MatchPhrasePrefix(Collection nameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("name", nameList); + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("name", nameList); if (opLambda != null) { opLambda.callback(builder); } } public void setName_InScope(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { - setName_MatchPhrasePrefix(nameList, opLambda); + setName_Terms(nameList, opLambda); } public void setName_Match(String name) { @@ -491,7 +493,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setName_Match(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("name", name); + MatchQueryBuilder builder = regMatchQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -502,7 +504,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setName_MatchPhrase(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("name", name); + MatchQueryBuilder builder = regMatchPhraseQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +515,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setName_MatchPhrasePrefix(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +526,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setName_Fuzzy(String name, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("name", name); + FuzzyQueryBuilder builder = regFuzzyQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +537,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setName_Prefix(String name, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("name", name); + PrefixQueryBuilder builder = regPrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +548,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +559,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setName_LessThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +570,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +581,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setName_LessEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -600,29 +602,29 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setSessionId_Term(String sessionId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("sessionId", sessionId); + TermQueryBuilder builder = regTermQ("sessionId", sessionId); if (opLambda != null) { opLambda.callback(builder); } } public void setSessionId_Terms(Collection sessionIdList) { - setSessionId_MatchPhrasePrefix(sessionIdList, null); + setSessionId_Terms(sessionIdList, null); } - public void setSessionId_MatchPhrasePrefix(Collection sessionIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("sessionId", sessionIdList); + public void setSessionId_Terms(Collection sessionIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("sessionId", sessionIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setSessionId_InScope(Collection sessionIdList) { - setSessionId_MatchPhrasePrefix(sessionIdList, null); + setSessionId_Terms(sessionIdList, null); } public void setSessionId_InScope(Collection sessionIdList, ConditionOptionCall opLambda) { - setSessionId_MatchPhrasePrefix(sessionIdList, opLambda); + setSessionId_Terms(sessionIdList, opLambda); } public void setSessionId_Match(String sessionId) { @@ -630,7 +632,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setSessionId_Match(String sessionId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("sessionId", sessionId); + MatchQueryBuilder builder = regMatchQ("sessionId", sessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -641,7 +643,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setSessionId_MatchPhrase(String sessionId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("sessionId", sessionId); + MatchQueryBuilder builder = regMatchPhraseQ("sessionId", sessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +654,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setSessionId_MatchPhrasePrefix(String sessionId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sessionId", sessionId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("sessionId", sessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +665,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setSessionId_Fuzzy(String sessionId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("sessionId", sessionId); + FuzzyQueryBuilder builder = regFuzzyQ("sessionId", sessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +676,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setSessionId_Prefix(String sessionId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("sessionId", sessionId); + PrefixQueryBuilder builder = regPrefixQ("sessionId", sessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +687,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setSessionId_GreaterThan(String sessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sessionId", ConditionKey.CK_GREATER_THAN, sessionId); + RangeQueryBuilder builder = regRangeQ("sessionId", ConditionKey.CK_GREATER_THAN, sessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +698,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setSessionId_LessThan(String sessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sessionId", ConditionKey.CK_LESS_THAN, sessionId); + RangeQueryBuilder builder = regRangeQ("sessionId", ConditionKey.CK_LESS_THAN, sessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +709,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setSessionId_GreaterEqual(String sessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sessionId", ConditionKey.CK_GREATER_EQUAL, sessionId); + RangeQueryBuilder builder = regRangeQ("sessionId", ConditionKey.CK_GREATER_EQUAL, sessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +720,7 @@ public abstract class BsCrawlingSessionCQ extends AbstractConditionQuery { } public void setSessionId_LessEqual(String sessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sessionId", ConditionKey.CK_LESS_EQUAL, sessionId); + RangeQueryBuilder builder = regRangeQ("sessionId", ConditionKey.CK_LESS_EQUAL, sessionId); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsCrawlingSessionInfoCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsCrawlingSessionInfoCQ.java index fcd4ea9f0..12c5ae44b 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsCrawlingSessionInfoCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsCrawlingSessionInfoCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.CrawlingSessionInfoCQ; +import org.codelibs.fess.es.cbean.cf.CrawlingSessionInfoCF; 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 BsCrawlingSessionInfoCQ extends AbstractConditionQuery { return "crawling_session_info"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { CrawlingSessionInfoCQ query = new CrawlingSessionInfoCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + CrawlingSessionInfoCF filter = new CrawlingSessionInfoCF(); + 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 BsCrawlingSessionInfoCQ extends AbstractConditionQuery { CrawlingSessionInfoCQ shouldQuery = new CrawlingSessionInfoCQ(); CrawlingSessionInfoCQ mustNotQuery = new CrawlingSessionInfoCQ(); 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); } @@ -66,30 +68,29 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCrawlingSessionId_Term(String crawlingSessionId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("crawlingSessionId", crawlingSessionId); + TermQueryBuilder builder = regTermQ("crawlingSessionId", crawlingSessionId); if (opLambda != null) { opLambda.callback(builder); } } public void setCrawlingSessionId_Terms(Collection crawlingSessionIdList) { - setCrawlingSessionId_MatchPhrasePrefix(crawlingSessionIdList, null); + setCrawlingSessionId_Terms(crawlingSessionIdList, null); } - public void setCrawlingSessionId_MatchPhrasePrefix(Collection crawlingSessionIdList, - ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("crawlingSessionId", crawlingSessionIdList); + public void setCrawlingSessionId_Terms(Collection crawlingSessionIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("crawlingSessionId", crawlingSessionIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setCrawlingSessionId_InScope(Collection crawlingSessionIdList) { - setCrawlingSessionId_MatchPhrasePrefix(crawlingSessionIdList, null); + setCrawlingSessionId_Terms(crawlingSessionIdList, null); } public void setCrawlingSessionId_InScope(Collection crawlingSessionIdList, ConditionOptionCall opLambda) { - setCrawlingSessionId_MatchPhrasePrefix(crawlingSessionIdList, opLambda); + setCrawlingSessionId_Terms(crawlingSessionIdList, opLambda); } public void setCrawlingSessionId_Match(String crawlingSessionId) { @@ -97,7 +98,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCrawlingSessionId_Match(String crawlingSessionId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("crawlingSessionId", crawlingSessionId); + MatchQueryBuilder builder = regMatchQ("crawlingSessionId", crawlingSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -108,7 +109,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCrawlingSessionId_MatchPhrase(String crawlingSessionId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("crawlingSessionId", crawlingSessionId); + MatchQueryBuilder builder = regMatchPhraseQ("crawlingSessionId", crawlingSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -119,7 +120,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCrawlingSessionId_MatchPhrasePrefix(String crawlingSessionId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("crawlingSessionId", crawlingSessionId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("crawlingSessionId", crawlingSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -130,7 +131,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCrawlingSessionId_Fuzzy(String crawlingSessionId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("crawlingSessionId", crawlingSessionId); + FuzzyQueryBuilder builder = regFuzzyQ("crawlingSessionId", crawlingSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -141,7 +142,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCrawlingSessionId_Prefix(String crawlingSessionId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("crawlingSessionId", crawlingSessionId); + PrefixQueryBuilder builder = regPrefixQ("crawlingSessionId", crawlingSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -152,7 +153,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCrawlingSessionId_GreaterThan(String crawlingSessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("crawlingSessionId", ConditionKey.CK_GREATER_THAN, crawlingSessionId); + RangeQueryBuilder builder = regRangeQ("crawlingSessionId", ConditionKey.CK_GREATER_THAN, crawlingSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -163,7 +164,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCrawlingSessionId_LessThan(String crawlingSessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("crawlingSessionId", ConditionKey.CK_LESS_THAN, crawlingSessionId); + RangeQueryBuilder builder = regRangeQ("crawlingSessionId", ConditionKey.CK_LESS_THAN, crawlingSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -174,7 +175,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCrawlingSessionId_GreaterEqual(String crawlingSessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("crawlingSessionId", ConditionKey.CK_GREATER_EQUAL, crawlingSessionId); + RangeQueryBuilder builder = regRangeQ("crawlingSessionId", ConditionKey.CK_GREATER_EQUAL, crawlingSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -185,7 +186,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCrawlingSessionId_LessEqual(String crawlingSessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("crawlingSessionId", ConditionKey.CK_LESS_EQUAL, crawlingSessionId); + RangeQueryBuilder builder = regRangeQ("crawlingSessionId", ConditionKey.CK_LESS_EQUAL, crawlingSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -206,29 +207,29 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -236,7 +237,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -247,7 +248,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -258,7 +259,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -269,7 +270,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -280,7 +281,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -291,7 +292,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -302,7 +303,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -313,7 +314,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -334,29 +335,29 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -364,7 +365,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -375,7 +376,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -386,7 +387,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -397,7 +398,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -408,7 +409,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -419,7 +420,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -430,7 +431,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -441,7 +442,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -452,7 +453,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -473,29 +474,29 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setKey_Term(String key, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("key", key); + TermQueryBuilder builder = regTermQ("key", key); if (opLambda != null) { opLambda.callback(builder); } } public void setKey_Terms(Collection keyList) { - setKey_MatchPhrasePrefix(keyList, null); + setKey_Terms(keyList, null); } - public void setKey_MatchPhrasePrefix(Collection keyList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("key", keyList); + public void setKey_Terms(Collection keyList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("key", keyList); if (opLambda != null) { opLambda.callback(builder); } } public void setKey_InScope(Collection keyList) { - setKey_MatchPhrasePrefix(keyList, null); + setKey_Terms(keyList, null); } public void setKey_InScope(Collection keyList, ConditionOptionCall opLambda) { - setKey_MatchPhrasePrefix(keyList, opLambda); + setKey_Terms(keyList, opLambda); } public void setKey_Match(String key) { @@ -503,7 +504,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setKey_Match(String key, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("key", key); + MatchQueryBuilder builder = regMatchQ("key", key); if (opLambda != null) { opLambda.callback(builder); } @@ -514,7 +515,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setKey_MatchPhrase(String key, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("key", key); + MatchQueryBuilder builder = regMatchPhraseQ("key", key); if (opLambda != null) { opLambda.callback(builder); } @@ -525,7 +526,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setKey_MatchPhrasePrefix(String key, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("key", key); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("key", key); if (opLambda != null) { opLambda.callback(builder); } @@ -536,7 +537,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setKey_Fuzzy(String key, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("key", key); + FuzzyQueryBuilder builder = regFuzzyQ("key", key); if (opLambda != null) { opLambda.callback(builder); } @@ -547,7 +548,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setKey_Prefix(String key, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("key", key); + PrefixQueryBuilder builder = regPrefixQ("key", key); if (opLambda != null) { opLambda.callback(builder); } @@ -558,7 +559,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setKey_GreaterThan(String key, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("key", ConditionKey.CK_GREATER_THAN, key); + RangeQueryBuilder builder = regRangeQ("key", ConditionKey.CK_GREATER_THAN, key); if (opLambda != null) { opLambda.callback(builder); } @@ -569,7 +570,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setKey_LessThan(String key, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("key", ConditionKey.CK_LESS_THAN, key); + RangeQueryBuilder builder = regRangeQ("key", ConditionKey.CK_LESS_THAN, key); if (opLambda != null) { opLambda.callback(builder); } @@ -580,7 +581,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setKey_GreaterEqual(String key, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("key", ConditionKey.CK_GREATER_EQUAL, key); + RangeQueryBuilder builder = regRangeQ("key", ConditionKey.CK_GREATER_EQUAL, key); if (opLambda != null) { opLambda.callback(builder); } @@ -591,7 +592,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setKey_LessEqual(String key, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("key", ConditionKey.CK_LESS_EQUAL, key); + RangeQueryBuilder builder = regRangeQ("key", ConditionKey.CK_LESS_EQUAL, key); if (opLambda != null) { opLambda.callback(builder); } @@ -612,29 +613,29 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setValue_Term(String value, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("value", value); + TermQueryBuilder builder = regTermQ("value", value); if (opLambda != null) { opLambda.callback(builder); } } public void setValue_Terms(Collection valueList) { - setValue_MatchPhrasePrefix(valueList, null); + setValue_Terms(valueList, null); } - public void setValue_MatchPhrasePrefix(Collection valueList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("value", valueList); + public void setValue_Terms(Collection valueList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("value", valueList); if (opLambda != null) { opLambda.callback(builder); } } public void setValue_InScope(Collection valueList) { - setValue_MatchPhrasePrefix(valueList, null); + setValue_Terms(valueList, null); } public void setValue_InScope(Collection valueList, ConditionOptionCall opLambda) { - setValue_MatchPhrasePrefix(valueList, opLambda); + setValue_Terms(valueList, opLambda); } public void setValue_Match(String value) { @@ -642,7 +643,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setValue_Match(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("value", value); + MatchQueryBuilder builder = regMatchQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -653,7 +654,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setValue_MatchPhrase(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("value", value); + MatchQueryBuilder builder = regMatchPhraseQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -664,7 +665,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setValue_MatchPhrasePrefix(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("value", value); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -675,7 +676,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setValue_Fuzzy(String value, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("value", value); + FuzzyQueryBuilder builder = regFuzzyQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -686,7 +687,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setValue_Prefix(String value, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("value", value); + PrefixQueryBuilder builder = regPrefixQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -697,7 +698,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setValue_GreaterThan(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_THAN, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_THAN, value); if (opLambda != null) { opLambda.callback(builder); } @@ -708,7 +709,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setValue_LessThan(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_THAN, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_THAN, value); if (opLambda != null) { opLambda.callback(builder); } @@ -719,7 +720,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setValue_GreaterEqual(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value); if (opLambda != null) { opLambda.callback(builder); } @@ -730,7 +731,7 @@ public abstract class BsCrawlingSessionInfoCQ extends AbstractConditionQuery { } public void setValue_LessEqual(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_EQUAL, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_EQUAL, value); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigCQ.java index 6b24571c2..3bbae2db4 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.DataConfigCQ; +import org.codelibs.fess.es.cbean.cf.DataConfigCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { return "data_config"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { DataConfigCQ query = new DataConfigCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + DataConfigCF filter = new DataConfigCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { DataConfigCQ shouldQuery = new DataConfigCQ(); DataConfigCQ mustNotQuery = new DataConfigCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setAvailable_Term(Boolean available, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("available", available); + TermQueryBuilder builder = regTermQ("available", available); if (opLambda != null) { opLambda.callback(builder); } } public void setAvailable_Terms(Collection availableList) { - setAvailable_MatchPhrasePrefix(availableList, null); + setAvailable_Terms(availableList, null); } - public void setAvailable_MatchPhrasePrefix(Collection availableList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("available", availableList); + public void setAvailable_Terms(Collection availableList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("available", availableList); if (opLambda != null) { opLambda.callback(builder); } } public void setAvailable_InScope(Collection availableList) { - setAvailable_MatchPhrasePrefix(availableList, null); + setAvailable_Terms(availableList, null); } public void setAvailable_InScope(Collection availableList, ConditionOptionCall opLambda) { - setAvailable_MatchPhrasePrefix(availableList, opLambda); + setAvailable_Terms(availableList, opLambda); } public void setAvailable_Match(Boolean available) { @@ -96,7 +97,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setAvailable_Match(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("available", available); + MatchQueryBuilder builder = regMatchQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setAvailable_MatchPhrase(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("available", available); + MatchQueryBuilder builder = regMatchPhraseQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setAvailable_MatchPhrasePrefix(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("available", available); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setAvailable_Fuzzy(Boolean available, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("available", available); + FuzzyQueryBuilder builder = regFuzzyQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_GREATER_THAN, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_GREATER_THAN, available); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setAvailable_LessThan(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_LESS_THAN, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_LESS_THAN, available); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_GREATER_EQUAL, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_GREATER_EQUAL, available); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setAvailable_LessEqual(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_LESS_EQUAL, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_LESS_EQUAL, available); if (opLambda != null) { opLambda.callback(builder); } @@ -194,29 +195,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setBoost_Term(Float boost, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("boost", boost); + TermQueryBuilder builder = regTermQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } } public void setBoost_Terms(Collection boostList) { - setBoost_MatchPhrasePrefix(boostList, null); + setBoost_Terms(boostList, null); } - public void setBoost_MatchPhrasePrefix(Collection boostList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("boost", boostList); + public void setBoost_Terms(Collection boostList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("boost", boostList); if (opLambda != null) { opLambda.callback(builder); } } public void setBoost_InScope(Collection boostList) { - setBoost_MatchPhrasePrefix(boostList, null); + setBoost_Terms(boostList, null); } public void setBoost_InScope(Collection boostList, ConditionOptionCall opLambda) { - setBoost_MatchPhrasePrefix(boostList, opLambda); + setBoost_Terms(boostList, opLambda); } public void setBoost_Match(Float boost) { @@ -224,7 +225,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setBoost_Match(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("boost", boost); + MatchQueryBuilder builder = regMatchQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -235,7 +236,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setBoost_MatchPhrase(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("boost", boost); + MatchQueryBuilder builder = regMatchPhraseQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setBoost_MatchPhrasePrefix(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("boost", boost); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setBoost_Fuzzy(Float boost, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("boost", boost); + FuzzyQueryBuilder builder = regFuzzyQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setBoost_GreaterThan(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setBoost_LessThan(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_THAN, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_THAN, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setBoost_GreaterEqual(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setBoost_LessEqual(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -322,29 +323,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -352,7 +353,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -363,7 +364,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -461,29 +462,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -491,7 +492,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -502,7 +503,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -589,29 +590,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerName_Term(String handlerName, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("handlerName", handlerName); + TermQueryBuilder builder = regTermQ("handlerName", handlerName); if (opLambda != null) { opLambda.callback(builder); } } public void setHandlerName_Terms(Collection handlerNameList) { - setHandlerName_MatchPhrasePrefix(handlerNameList, null); + setHandlerName_Terms(handlerNameList, null); } - public void setHandlerName_MatchPhrasePrefix(Collection handlerNameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("handlerName", handlerNameList); + public void setHandlerName_Terms(Collection handlerNameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("handlerName", handlerNameList); if (opLambda != null) { opLambda.callback(builder); } } public void setHandlerName_InScope(Collection handlerNameList) { - setHandlerName_MatchPhrasePrefix(handlerNameList, null); + setHandlerName_Terms(handlerNameList, null); } public void setHandlerName_InScope(Collection handlerNameList, ConditionOptionCall opLambda) { - setHandlerName_MatchPhrasePrefix(handlerNameList, opLambda); + setHandlerName_Terms(handlerNameList, opLambda); } public void setHandlerName_Match(String handlerName) { @@ -619,7 +620,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerName_Match(String handlerName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("handlerName", handlerName); + MatchQueryBuilder builder = regMatchQ("handlerName", handlerName); if (opLambda != null) { opLambda.callback(builder); } @@ -630,7 +631,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerName_MatchPhrase(String handlerName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("handlerName", handlerName); + MatchQueryBuilder builder = regMatchPhraseQ("handlerName", handlerName); if (opLambda != null) { opLambda.callback(builder); } @@ -641,7 +642,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerName_MatchPhrasePrefix(String handlerName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("handlerName", handlerName); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("handlerName", handlerName); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerName_Fuzzy(String handlerName, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("handlerName", handlerName); + FuzzyQueryBuilder builder = regFuzzyQ("handlerName", handlerName); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerName_Prefix(String handlerName, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("handlerName", handlerName); + PrefixQueryBuilder builder = regPrefixQ("handlerName", handlerName); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerName_GreaterThan(String handlerName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerName", ConditionKey.CK_GREATER_THAN, handlerName); + RangeQueryBuilder builder = regRangeQ("handlerName", ConditionKey.CK_GREATER_THAN, handlerName); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerName_LessThan(String handlerName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerName", ConditionKey.CK_LESS_THAN, handlerName); + RangeQueryBuilder builder = regRangeQ("handlerName", ConditionKey.CK_LESS_THAN, handlerName); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerName_GreaterEqual(String handlerName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerName", ConditionKey.CK_GREATER_EQUAL, handlerName); + RangeQueryBuilder builder = regRangeQ("handlerName", ConditionKey.CK_GREATER_EQUAL, handlerName); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerName_LessEqual(String handlerName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerName", ConditionKey.CK_LESS_EQUAL, handlerName); + RangeQueryBuilder builder = regRangeQ("handlerName", ConditionKey.CK_LESS_EQUAL, handlerName); if (opLambda != null) { opLambda.callback(builder); } @@ -728,30 +729,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerParameter_Term(String handlerParameter, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("handlerParameter", handlerParameter); + TermQueryBuilder builder = regTermQ("handlerParameter", handlerParameter); if (opLambda != null) { opLambda.callback(builder); } } public void setHandlerParameter_Terms(Collection handlerParameterList) { - setHandlerParameter_MatchPhrasePrefix(handlerParameterList, null); + setHandlerParameter_Terms(handlerParameterList, null); } - public void setHandlerParameter_MatchPhrasePrefix(Collection handlerParameterList, - ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("handlerParameter", handlerParameterList); + public void setHandlerParameter_Terms(Collection handlerParameterList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("handlerParameter", handlerParameterList); if (opLambda != null) { opLambda.callback(builder); } } public void setHandlerParameter_InScope(Collection handlerParameterList) { - setHandlerParameter_MatchPhrasePrefix(handlerParameterList, null); + setHandlerParameter_Terms(handlerParameterList, null); } public void setHandlerParameter_InScope(Collection handlerParameterList, ConditionOptionCall opLambda) { - setHandlerParameter_MatchPhrasePrefix(handlerParameterList, opLambda); + setHandlerParameter_Terms(handlerParameterList, opLambda); } public void setHandlerParameter_Match(String handlerParameter) { @@ -759,7 +759,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerParameter_Match(String handlerParameter, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("handlerParameter", handlerParameter); + MatchQueryBuilder builder = regMatchQ("handlerParameter", handlerParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -770,7 +770,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerParameter_MatchPhrase(String handlerParameter, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("handlerParameter", handlerParameter); + MatchQueryBuilder builder = regMatchPhraseQ("handlerParameter", handlerParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -781,7 +781,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerParameter_MatchPhrasePrefix(String handlerParameter, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("handlerParameter", handlerParameter); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("handlerParameter", handlerParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -792,7 +792,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerParameter_Fuzzy(String handlerParameter, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("handlerParameter", handlerParameter); + FuzzyQueryBuilder builder = regFuzzyQ("handlerParameter", handlerParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -803,7 +803,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerParameter_Prefix(String handlerParameter, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("handlerParameter", handlerParameter); + PrefixQueryBuilder builder = regPrefixQ("handlerParameter", handlerParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -814,7 +814,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerParameter_GreaterThan(String handlerParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerParameter", ConditionKey.CK_GREATER_THAN, handlerParameter); + RangeQueryBuilder builder = regRangeQ("handlerParameter", ConditionKey.CK_GREATER_THAN, handlerParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -825,7 +825,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerParameter_LessThan(String handlerParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerParameter", ConditionKey.CK_LESS_THAN, handlerParameter); + RangeQueryBuilder builder = regRangeQ("handlerParameter", ConditionKey.CK_LESS_THAN, handlerParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -836,7 +836,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerParameter_GreaterEqual(String handlerParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerParameter", ConditionKey.CK_GREATER_EQUAL, handlerParameter); + RangeQueryBuilder builder = regRangeQ("handlerParameter", ConditionKey.CK_GREATER_EQUAL, handlerParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -847,7 +847,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerParameter_LessEqual(String handlerParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerParameter", ConditionKey.CK_LESS_EQUAL, handlerParameter); + RangeQueryBuilder builder = regRangeQ("handlerParameter", ConditionKey.CK_LESS_EQUAL, handlerParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -868,29 +868,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerScript_Term(String handlerScript, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("handlerScript", handlerScript); + TermQueryBuilder builder = regTermQ("handlerScript", handlerScript); if (opLambda != null) { opLambda.callback(builder); } } public void setHandlerScript_Terms(Collection handlerScriptList) { - setHandlerScript_MatchPhrasePrefix(handlerScriptList, null); + setHandlerScript_Terms(handlerScriptList, null); } - public void setHandlerScript_MatchPhrasePrefix(Collection handlerScriptList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("handlerScript", handlerScriptList); + public void setHandlerScript_Terms(Collection handlerScriptList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("handlerScript", handlerScriptList); if (opLambda != null) { opLambda.callback(builder); } } public void setHandlerScript_InScope(Collection handlerScriptList) { - setHandlerScript_MatchPhrasePrefix(handlerScriptList, null); + setHandlerScript_Terms(handlerScriptList, null); } public void setHandlerScript_InScope(Collection handlerScriptList, ConditionOptionCall opLambda) { - setHandlerScript_MatchPhrasePrefix(handlerScriptList, opLambda); + setHandlerScript_Terms(handlerScriptList, opLambda); } public void setHandlerScript_Match(String handlerScript) { @@ -898,7 +898,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerScript_Match(String handlerScript, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("handlerScript", handlerScript); + MatchQueryBuilder builder = regMatchQ("handlerScript", handlerScript); if (opLambda != null) { opLambda.callback(builder); } @@ -909,7 +909,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerScript_MatchPhrase(String handlerScript, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("handlerScript", handlerScript); + MatchQueryBuilder builder = regMatchPhraseQ("handlerScript", handlerScript); if (opLambda != null) { opLambda.callback(builder); } @@ -920,7 +920,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerScript_MatchPhrasePrefix(String handlerScript, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("handlerScript", handlerScript); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("handlerScript", handlerScript); if (opLambda != null) { opLambda.callback(builder); } @@ -931,7 +931,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerScript_Fuzzy(String handlerScript, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("handlerScript", handlerScript); + FuzzyQueryBuilder builder = regFuzzyQ("handlerScript", handlerScript); if (opLambda != null) { opLambda.callback(builder); } @@ -942,7 +942,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerScript_Prefix(String handlerScript, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("handlerScript", handlerScript); + PrefixQueryBuilder builder = regPrefixQ("handlerScript", handlerScript); if (opLambda != null) { opLambda.callback(builder); } @@ -953,7 +953,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerScript_GreaterThan(String handlerScript, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerScript", ConditionKey.CK_GREATER_THAN, handlerScript); + RangeQueryBuilder builder = regRangeQ("handlerScript", ConditionKey.CK_GREATER_THAN, handlerScript); if (opLambda != null) { opLambda.callback(builder); } @@ -964,7 +964,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerScript_LessThan(String handlerScript, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerScript", ConditionKey.CK_LESS_THAN, handlerScript); + RangeQueryBuilder builder = regRangeQ("handlerScript", ConditionKey.CK_LESS_THAN, handlerScript); if (opLambda != null) { opLambda.callback(builder); } @@ -975,7 +975,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerScript_GreaterEqual(String handlerScript, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerScript", ConditionKey.CK_GREATER_EQUAL, handlerScript); + RangeQueryBuilder builder = regRangeQ("handlerScript", ConditionKey.CK_GREATER_EQUAL, handlerScript); if (opLambda != null) { opLambda.callback(builder); } @@ -986,7 +986,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setHandlerScript_LessEqual(String handlerScript, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("handlerScript", ConditionKey.CK_LESS_EQUAL, handlerScript); + RangeQueryBuilder builder = regRangeQ("handlerScript", ConditionKey.CK_LESS_EQUAL, handlerScript); if (opLambda != null) { opLambda.callback(builder); } @@ -1007,29 +1007,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -1037,7 +1037,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1048,7 +1048,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1059,7 +1059,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1070,7 +1070,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1081,7 +1081,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1092,7 +1092,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1103,7 +1103,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1114,7 +1114,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1125,7 +1125,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1146,29 +1146,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setName_Term(String name, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("name", name); + TermQueryBuilder builder = regTermQ("name", name); if (opLambda != null) { opLambda.callback(builder); } } public void setName_Terms(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } - public void setName_MatchPhrasePrefix(Collection nameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("name", nameList); + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("name", nameList); if (opLambda != null) { opLambda.callback(builder); } } public void setName_InScope(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { - setName_MatchPhrasePrefix(nameList, opLambda); + setName_Terms(nameList, opLambda); } public void setName_Match(String name) { @@ -1176,7 +1176,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setName_Match(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("name", name); + MatchQueryBuilder builder = regMatchQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1187,7 +1187,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setName_MatchPhrase(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("name", name); + MatchQueryBuilder builder = regMatchPhraseQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1198,7 +1198,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setName_MatchPhrasePrefix(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1209,7 +1209,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setName_Fuzzy(String name, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("name", name); + FuzzyQueryBuilder builder = regFuzzyQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1220,7 +1220,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setName_Prefix(String name, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("name", name); + PrefixQueryBuilder builder = regPrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1231,7 +1231,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1242,7 +1242,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setName_LessThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1253,7 +1253,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1264,7 +1264,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setName_LessEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1285,29 +1285,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder); + TermQueryBuilder builder = regTermQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_Terms(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } - public void setSortOrder_MatchPhrasePrefix(Collection sortOrderList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList); + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_InScope(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { - setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda); + setSortOrder_Terms(sortOrderList, opLambda); } public void setSortOrder_Match(Integer sortOrder) { @@ -1315,7 +1315,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1326,7 +1326,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1337,7 +1337,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1348,7 +1348,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder); + FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1359,7 +1359,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1370,7 +1370,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1381,7 +1381,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1392,7 +1392,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1413,29 +1413,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -1443,7 +1443,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1454,7 +1454,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1465,7 +1465,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1476,7 +1476,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1487,7 +1487,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1498,7 +1498,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1509,7 +1509,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1520,7 +1520,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1531,7 +1531,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1552,29 +1552,29 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -1582,7 +1582,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1593,7 +1593,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1604,7 +1604,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1615,7 +1615,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1626,7 +1626,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1637,7 +1637,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1648,7 +1648,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1659,7 +1659,7 @@ public abstract class BsDataConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigToLabelCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigToLabelCQ.java index 42796f9fc..3ae9f6bf1 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigToLabelCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigToLabelCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.DataConfigToLabelCQ; +import org.codelibs.fess.es.cbean.cf.DataConfigToLabelCF; 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 BsDataConfigToLabelCQ extends AbstractConditionQuery { return "data_config_to_label"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { DataConfigToLabelCQ query = new DataConfigToLabelCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + DataConfigToLabelCF filter = new DataConfigToLabelCF(); + 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 BsDataConfigToLabelCQ extends AbstractConditionQuery { DataConfigToLabelCQ shouldQuery = new DataConfigToLabelCQ(); DataConfigToLabelCQ mustNotQuery = new DataConfigToLabelCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setDataConfigId_Term(String dataConfigId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("dataConfigId", dataConfigId); + TermQueryBuilder builder = regTermQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } } public void setDataConfigId_Terms(Collection dataConfigIdList) { - setDataConfigId_MatchPhrasePrefix(dataConfigIdList, null); + setDataConfigId_Terms(dataConfigIdList, null); } - public void setDataConfigId_MatchPhrasePrefix(Collection dataConfigIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("dataConfigId", dataConfigIdList); + public void setDataConfigId_Terms(Collection dataConfigIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("dataConfigId", dataConfigIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setDataConfigId_InScope(Collection dataConfigIdList) { - setDataConfigId_MatchPhrasePrefix(dataConfigIdList, null); + setDataConfigId_Terms(dataConfigIdList, null); } public void setDataConfigId_InScope(Collection dataConfigIdList, ConditionOptionCall opLambda) { - setDataConfigId_MatchPhrasePrefix(dataConfigIdList, opLambda); + setDataConfigId_Terms(dataConfigIdList, opLambda); } public void setDataConfigId_Match(String dataConfigId) { @@ -96,7 +98,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setDataConfigId_Match(String dataConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("dataConfigId", dataConfigId); + MatchQueryBuilder builder = regMatchQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setDataConfigId_MatchPhrase(String dataConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("dataConfigId", dataConfigId); + MatchQueryBuilder builder = regMatchPhraseQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setDataConfigId_MatchPhrasePrefix(String dataConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("dataConfigId", dataConfigId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setDataConfigId_Fuzzy(String dataConfigId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("dataConfigId", dataConfigId); + FuzzyQueryBuilder builder = regFuzzyQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setDataConfigId_Prefix(String dataConfigId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("dataConfigId", dataConfigId); + PrefixQueryBuilder builder = regPrefixQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setDataConfigId_GreaterThan(String dataConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId); + RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setDataConfigId_LessThan(String dataConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId); + RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setDataConfigId_GreaterEqual(String dataConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId); + RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +186,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setDataConfigId_LessEqual(String dataConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId); + RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +207,29 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -235,7 +237,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +314,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -323,7 +325,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -344,29 +346,29 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("labelTypeId", labelTypeId); + TermQueryBuilder builder = regTermQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } } public void setLabelTypeId_Terms(Collection labelTypeIdList) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null); + setLabelTypeId_Terms(labelTypeIdList, null); } - public void setLabelTypeId_MatchPhrasePrefix(Collection labelTypeIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("labelTypeId", labelTypeIdList); + public void setLabelTypeId_Terms(Collection labelTypeIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("labelTypeId", labelTypeIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setLabelTypeId_InScope(Collection labelTypeIdList) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null); + setLabelTypeId_Terms(labelTypeIdList, null); } public void setLabelTypeId_InScope(Collection labelTypeIdList, ConditionOptionCall opLambda) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, opLambda); + setLabelTypeId_Terms(labelTypeIdList, opLambda); } public void setLabelTypeId_Match(String labelTypeId) { @@ -374,7 +376,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Match(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_MatchPhrase(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchPhraseQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_MatchPhrasePrefix(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Fuzzy(String labelTypeId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("labelTypeId", labelTypeId); + FuzzyQueryBuilder builder = regFuzzyQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("labelTypeId", labelTypeId); + PrefixQueryBuilder builder = regPrefixQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +453,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -462,7 +464,7 @@ public abstract class BsDataConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigToRoleCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigToRoleCQ.java index 85cec23d6..58bc52ef6 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigToRoleCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsDataConfigToRoleCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.DataConfigToRoleCQ; +import org.codelibs.fess.es.cbean.cf.DataConfigToRoleCF; 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 BsDataConfigToRoleCQ extends AbstractConditionQuery { return "data_config_to_role"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { DataConfigToRoleCQ query = new DataConfigToRoleCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + DataConfigToRoleCF filter = new DataConfigToRoleCF(); + 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 BsDataConfigToRoleCQ extends AbstractConditionQuery { DataConfigToRoleCQ shouldQuery = new DataConfigToRoleCQ(); DataConfigToRoleCQ mustNotQuery = new DataConfigToRoleCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setDataConfigId_Term(String dataConfigId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("dataConfigId", dataConfigId); + TermQueryBuilder builder = regTermQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } } public void setDataConfigId_Terms(Collection dataConfigIdList) { - setDataConfigId_MatchPhrasePrefix(dataConfigIdList, null); + setDataConfigId_Terms(dataConfigIdList, null); } - public void setDataConfigId_MatchPhrasePrefix(Collection dataConfigIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("dataConfigId", dataConfigIdList); + public void setDataConfigId_Terms(Collection dataConfigIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("dataConfigId", dataConfigIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setDataConfigId_InScope(Collection dataConfigIdList) { - setDataConfigId_MatchPhrasePrefix(dataConfigIdList, null); + setDataConfigId_Terms(dataConfigIdList, null); } public void setDataConfigId_InScope(Collection dataConfigIdList, ConditionOptionCall opLambda) { - setDataConfigId_MatchPhrasePrefix(dataConfigIdList, opLambda); + setDataConfigId_Terms(dataConfigIdList, opLambda); } public void setDataConfigId_Match(String dataConfigId) { @@ -96,7 +98,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setDataConfigId_Match(String dataConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("dataConfigId", dataConfigId); + MatchQueryBuilder builder = regMatchQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setDataConfigId_MatchPhrase(String dataConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("dataConfigId", dataConfigId); + MatchQueryBuilder builder = regMatchPhraseQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setDataConfigId_MatchPhrasePrefix(String dataConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("dataConfigId", dataConfigId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setDataConfigId_Fuzzy(String dataConfigId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("dataConfigId", dataConfigId); + FuzzyQueryBuilder builder = regFuzzyQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setDataConfigId_Prefix(String dataConfigId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("dataConfigId", dataConfigId); + PrefixQueryBuilder builder = regPrefixQ("dataConfigId", dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setDataConfigId_GreaterThan(String dataConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId); + RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_GREATER_THAN, dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setDataConfigId_LessThan(String dataConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId); + RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_LESS_THAN, dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setDataConfigId_GreaterEqual(String dataConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId); + RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_GREATER_EQUAL, dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +186,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setDataConfigId_LessEqual(String dataConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId); + RangeQueryBuilder builder = regRangeQ("dataConfigId", ConditionKey.CK_LESS_EQUAL, dataConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +207,29 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -235,7 +237,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +314,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -323,7 +325,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -344,29 +346,29 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("roleTypeId", roleTypeId); + TermQueryBuilder builder = regTermQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } } public void setRoleTypeId_Terms(Collection roleTypeIdList) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null); + setRoleTypeId_Terms(roleTypeIdList, null); } - public void setRoleTypeId_MatchPhrasePrefix(Collection roleTypeIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("roleTypeId", roleTypeIdList); + public void setRoleTypeId_Terms(Collection roleTypeIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("roleTypeId", roleTypeIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setRoleTypeId_InScope(Collection roleTypeIdList) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null); + setRoleTypeId_Terms(roleTypeIdList, null); } public void setRoleTypeId_InScope(Collection roleTypeIdList, ConditionOptionCall opLambda) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, opLambda); + setRoleTypeId_Terms(roleTypeIdList, opLambda); } public void setRoleTypeId_Match(String roleTypeId) { @@ -374,7 +376,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Match(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_MatchPhrase(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchPhraseQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_MatchPhrasePrefix(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Fuzzy(String roleTypeId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("roleTypeId", roleTypeId); + FuzzyQueryBuilder builder = regFuzzyQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("roleTypeId", roleTypeId); + PrefixQueryBuilder builder = regPrefixQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +453,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -462,7 +464,7 @@ public abstract class BsDataConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFailureUrlCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFailureUrlCQ.java index 2afbbffe8..99d52a8be 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFailureUrlCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFailureUrlCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.FailureUrlCQ; +import org.codelibs.fess.es.cbean.cf.FailureUrlCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { return "failure_url"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { FailureUrlCQ query = new FailureUrlCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + FailureUrlCF filter = new FailureUrlCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { FailureUrlCQ shouldQuery = new FailureUrlCQ(); FailureUrlCQ mustNotQuery = new FailureUrlCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setConfigId_Term(String configId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("configId", configId); + TermQueryBuilder builder = regTermQ("configId", configId); if (opLambda != null) { opLambda.callback(builder); } } public void setConfigId_Terms(Collection configIdList) { - setConfigId_MatchPhrasePrefix(configIdList, null); + setConfigId_Terms(configIdList, null); } - public void setConfigId_MatchPhrasePrefix(Collection configIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("configId", configIdList); + public void setConfigId_Terms(Collection configIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("configId", configIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setConfigId_InScope(Collection configIdList) { - setConfigId_MatchPhrasePrefix(configIdList, null); + setConfigId_Terms(configIdList, null); } public void setConfigId_InScope(Collection configIdList, ConditionOptionCall opLambda) { - setConfigId_MatchPhrasePrefix(configIdList, opLambda); + setConfigId_Terms(configIdList, opLambda); } public void setConfigId_Match(String configId) { @@ -96,7 +97,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setConfigId_Match(String configId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("configId", configId); + MatchQueryBuilder builder = regMatchQ("configId", configId); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setConfigId_MatchPhrase(String configId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("configId", configId); + MatchQueryBuilder builder = regMatchPhraseQ("configId", configId); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setConfigId_MatchPhrasePrefix(String configId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("configId", configId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("configId", configId); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setConfigId_Fuzzy(String configId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("configId", configId); + FuzzyQueryBuilder builder = regFuzzyQ("configId", configId); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setConfigId_Prefix(String configId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("configId", configId); + PrefixQueryBuilder builder = regPrefixQ("configId", configId); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setConfigId_GreaterThan(String configId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configId", ConditionKey.CK_GREATER_THAN, configId); + RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_GREATER_THAN, configId); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setConfigId_LessThan(String configId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configId", ConditionKey.CK_LESS_THAN, configId); + RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_LESS_THAN, configId); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setConfigId_GreaterEqual(String configId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configId", ConditionKey.CK_GREATER_EQUAL, configId); + RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_GREATER_EQUAL, configId); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +185,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setConfigId_LessEqual(String configId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configId", ConditionKey.CK_LESS_EQUAL, configId); + RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_LESS_EQUAL, configId); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +206,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorCount_Term(Integer errorCount, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("errorCount", errorCount); + TermQueryBuilder builder = regTermQ("errorCount", errorCount); if (opLambda != null) { opLambda.callback(builder); } } public void setErrorCount_Terms(Collection errorCountList) { - setErrorCount_MatchPhrasePrefix(errorCountList, null); + setErrorCount_Terms(errorCountList, null); } - public void setErrorCount_MatchPhrasePrefix(Collection errorCountList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("errorCount", errorCountList); + public void setErrorCount_Terms(Collection errorCountList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("errorCount", errorCountList); if (opLambda != null) { opLambda.callback(builder); } } public void setErrorCount_InScope(Collection errorCountList) { - setErrorCount_MatchPhrasePrefix(errorCountList, null); + setErrorCount_Terms(errorCountList, null); } public void setErrorCount_InScope(Collection errorCountList, ConditionOptionCall opLambda) { - setErrorCount_MatchPhrasePrefix(errorCountList, opLambda); + setErrorCount_Terms(errorCountList, opLambda); } public void setErrorCount_Match(Integer errorCount) { @@ -235,7 +236,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorCount_Match(Integer errorCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("errorCount", errorCount); + MatchQueryBuilder builder = regMatchQ("errorCount", errorCount); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorCount_MatchPhrase(Integer errorCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("errorCount", errorCount); + MatchQueryBuilder builder = regMatchPhraseQ("errorCount", errorCount); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorCount_MatchPhrasePrefix(Integer errorCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("errorCount", errorCount); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("errorCount", errorCount); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorCount_Fuzzy(Integer errorCount, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("errorCount", errorCount); + FuzzyQueryBuilder builder = regFuzzyQ("errorCount", errorCount); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorCount_GreaterThan(Integer errorCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorCount", ConditionKey.CK_GREATER_THAN, errorCount); + RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_GREATER_THAN, errorCount); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorCount_LessThan(Integer errorCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorCount", ConditionKey.CK_LESS_THAN, errorCount); + RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_LESS_THAN, errorCount); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorCount_GreaterEqual(Integer errorCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorCount", ConditionKey.CK_GREATER_EQUAL, errorCount); + RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_GREATER_EQUAL, errorCount); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorCount_LessEqual(Integer errorCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorCount", ConditionKey.CK_LESS_EQUAL, errorCount); + RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_LESS_EQUAL, errorCount); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorLog_Term(String errorLog, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("errorLog", errorLog); + TermQueryBuilder builder = regTermQ("errorLog", errorLog); if (opLambda != null) { opLambda.callback(builder); } } public void setErrorLog_Terms(Collection errorLogList) { - setErrorLog_MatchPhrasePrefix(errorLogList, null); + setErrorLog_Terms(errorLogList, null); } - public void setErrorLog_MatchPhrasePrefix(Collection errorLogList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("errorLog", errorLogList); + public void setErrorLog_Terms(Collection errorLogList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("errorLog", errorLogList); if (opLambda != null) { opLambda.callback(builder); } } public void setErrorLog_InScope(Collection errorLogList) { - setErrorLog_MatchPhrasePrefix(errorLogList, null); + setErrorLog_Terms(errorLogList, null); } public void setErrorLog_InScope(Collection errorLogList, ConditionOptionCall opLambda) { - setErrorLog_MatchPhrasePrefix(errorLogList, opLambda); + setErrorLog_Terms(errorLogList, opLambda); } public void setErrorLog_Match(String errorLog) { @@ -363,7 +364,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorLog_Match(String errorLog, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("errorLog", errorLog); + MatchQueryBuilder builder = regMatchQ("errorLog", errorLog); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorLog_MatchPhrase(String errorLog, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("errorLog", errorLog); + MatchQueryBuilder builder = regMatchPhraseQ("errorLog", errorLog); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorLog_MatchPhrasePrefix(String errorLog, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("errorLog", errorLog); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("errorLog", errorLog); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorLog_Fuzzy(String errorLog, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("errorLog", errorLog); + FuzzyQueryBuilder builder = regFuzzyQ("errorLog", errorLog); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorLog_Prefix(String errorLog, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("errorLog", errorLog); + PrefixQueryBuilder builder = regPrefixQ("errorLog", errorLog); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorLog_GreaterThan(String errorLog, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorLog", ConditionKey.CK_GREATER_THAN, errorLog); + RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_GREATER_THAN, errorLog); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorLog_LessThan(String errorLog, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorLog", ConditionKey.CK_LESS_THAN, errorLog); + RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_LESS_THAN, errorLog); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorLog_GreaterEqual(String errorLog, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorLog", ConditionKey.CK_GREATER_EQUAL, errorLog); + RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_GREATER_EQUAL, errorLog); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorLog_LessEqual(String errorLog, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorLog", ConditionKey.CK_LESS_EQUAL, errorLog); + RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_LESS_EQUAL, errorLog); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorName_Term(String errorName, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("errorName", errorName); + TermQueryBuilder builder = regTermQ("errorName", errorName); if (opLambda != null) { opLambda.callback(builder); } } public void setErrorName_Terms(Collection errorNameList) { - setErrorName_MatchPhrasePrefix(errorNameList, null); + setErrorName_Terms(errorNameList, null); } - public void setErrorName_MatchPhrasePrefix(Collection errorNameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("errorName", errorNameList); + public void setErrorName_Terms(Collection errorNameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("errorName", errorNameList); if (opLambda != null) { opLambda.callback(builder); } } public void setErrorName_InScope(Collection errorNameList) { - setErrorName_MatchPhrasePrefix(errorNameList, null); + setErrorName_Terms(errorNameList, null); } public void setErrorName_InScope(Collection errorNameList, ConditionOptionCall opLambda) { - setErrorName_MatchPhrasePrefix(errorNameList, opLambda); + setErrorName_Terms(errorNameList, opLambda); } public void setErrorName_Match(String errorName) { @@ -502,7 +503,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorName_Match(String errorName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("errorName", errorName); + MatchQueryBuilder builder = regMatchQ("errorName", errorName); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorName_MatchPhrase(String errorName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("errorName", errorName); + MatchQueryBuilder builder = regMatchPhraseQ("errorName", errorName); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorName_MatchPhrasePrefix(String errorName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("errorName", errorName); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("errorName", errorName); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorName_Fuzzy(String errorName, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("errorName", errorName); + FuzzyQueryBuilder builder = regFuzzyQ("errorName", errorName); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorName_Prefix(String errorName, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("errorName", errorName); + PrefixQueryBuilder builder = regPrefixQ("errorName", errorName); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorName_GreaterThan(String errorName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorName", ConditionKey.CK_GREATER_THAN, errorName); + RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_GREATER_THAN, errorName); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorName_LessThan(String errorName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorName", ConditionKey.CK_LESS_THAN, errorName); + RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_LESS_THAN, errorName); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorName_GreaterEqual(String errorName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorName", ConditionKey.CK_GREATER_EQUAL, errorName); + RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_GREATER_EQUAL, errorName); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +591,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setErrorName_LessEqual(String errorName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("errorName", ConditionKey.CK_LESS_EQUAL, errorName); + RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_LESS_EQUAL, errorName); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +612,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -641,7 +642,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +719,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -729,7 +730,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -750,29 +751,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setLastAccessTime_Term(Long lastAccessTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("lastAccessTime", lastAccessTime); + TermQueryBuilder builder = regTermQ("lastAccessTime", lastAccessTime); if (opLambda != null) { opLambda.callback(builder); } } public void setLastAccessTime_Terms(Collection lastAccessTimeList) { - setLastAccessTime_MatchPhrasePrefix(lastAccessTimeList, null); + setLastAccessTime_Terms(lastAccessTimeList, null); } - public void setLastAccessTime_MatchPhrasePrefix(Collection lastAccessTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("lastAccessTime", lastAccessTimeList); + public void setLastAccessTime_Terms(Collection lastAccessTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("lastAccessTime", lastAccessTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setLastAccessTime_InScope(Collection lastAccessTimeList) { - setLastAccessTime_MatchPhrasePrefix(lastAccessTimeList, null); + setLastAccessTime_Terms(lastAccessTimeList, null); } public void setLastAccessTime_InScope(Collection lastAccessTimeList, ConditionOptionCall opLambda) { - setLastAccessTime_MatchPhrasePrefix(lastAccessTimeList, opLambda); + setLastAccessTime_Terms(lastAccessTimeList, opLambda); } public void setLastAccessTime_Match(Long lastAccessTime) { @@ -780,7 +781,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setLastAccessTime_Match(Long lastAccessTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("lastAccessTime", lastAccessTime); + MatchQueryBuilder builder = regMatchQ("lastAccessTime", lastAccessTime); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setLastAccessTime_MatchPhrase(Long lastAccessTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("lastAccessTime", lastAccessTime); + MatchQueryBuilder builder = regMatchPhraseQ("lastAccessTime", lastAccessTime); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setLastAccessTime_MatchPhrasePrefix(Long lastAccessTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("lastAccessTime", lastAccessTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("lastAccessTime", lastAccessTime); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setLastAccessTime_Fuzzy(Long lastAccessTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("lastAccessTime", lastAccessTime); + FuzzyQueryBuilder builder = regFuzzyQ("lastAccessTime", lastAccessTime); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setLastAccessTime_GreaterThan(Long lastAccessTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("lastAccessTime", ConditionKey.CK_GREATER_THAN, lastAccessTime); + RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_GREATER_THAN, lastAccessTime); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setLastAccessTime_LessThan(Long lastAccessTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("lastAccessTime", ConditionKey.CK_LESS_THAN, lastAccessTime); + RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_LESS_THAN, lastAccessTime); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +847,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setLastAccessTime_GreaterEqual(Long lastAccessTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("lastAccessTime", ConditionKey.CK_GREATER_EQUAL, lastAccessTime); + RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_GREATER_EQUAL, lastAccessTime); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +858,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setLastAccessTime_LessEqual(Long lastAccessTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("lastAccessTime", ConditionKey.CK_LESS_EQUAL, lastAccessTime); + RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_LESS_EQUAL, lastAccessTime); if (opLambda != null) { opLambda.callback(builder); } @@ -878,29 +879,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setThreadName_Term(String threadName, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("threadName", threadName); + TermQueryBuilder builder = regTermQ("threadName", threadName); if (opLambda != null) { opLambda.callback(builder); } } public void setThreadName_Terms(Collection threadNameList) { - setThreadName_MatchPhrasePrefix(threadNameList, null); + setThreadName_Terms(threadNameList, null); } - public void setThreadName_MatchPhrasePrefix(Collection threadNameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("threadName", threadNameList); + public void setThreadName_Terms(Collection threadNameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("threadName", threadNameList); if (opLambda != null) { opLambda.callback(builder); } } public void setThreadName_InScope(Collection threadNameList) { - setThreadName_MatchPhrasePrefix(threadNameList, null); + setThreadName_Terms(threadNameList, null); } public void setThreadName_InScope(Collection threadNameList, ConditionOptionCall opLambda) { - setThreadName_MatchPhrasePrefix(threadNameList, opLambda); + setThreadName_Terms(threadNameList, opLambda); } public void setThreadName_Match(String threadName) { @@ -908,7 +909,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setThreadName_Match(String threadName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("threadName", threadName); + MatchQueryBuilder builder = regMatchQ("threadName", threadName); if (opLambda != null) { opLambda.callback(builder); } @@ -919,7 +920,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setThreadName_MatchPhrase(String threadName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("threadName", threadName); + MatchQueryBuilder builder = regMatchPhraseQ("threadName", threadName); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +931,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setThreadName_MatchPhrasePrefix(String threadName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("threadName", threadName); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("threadName", threadName); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +942,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setThreadName_Fuzzy(String threadName, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("threadName", threadName); + FuzzyQueryBuilder builder = regFuzzyQ("threadName", threadName); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +953,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setThreadName_Prefix(String threadName, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("threadName", threadName); + PrefixQueryBuilder builder = regPrefixQ("threadName", threadName); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +964,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setThreadName_GreaterThan(String threadName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("threadName", ConditionKey.CK_GREATER_THAN, threadName); + RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_GREATER_THAN, threadName); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +975,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setThreadName_LessThan(String threadName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("threadName", ConditionKey.CK_LESS_THAN, threadName); + RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_LESS_THAN, threadName); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +986,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setThreadName_GreaterEqual(String threadName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("threadName", ConditionKey.CK_GREATER_EQUAL, threadName); + RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_GREATER_EQUAL, threadName); if (opLambda != null) { opLambda.callback(builder); } @@ -996,7 +997,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setThreadName_LessEqual(String threadName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("threadName", ConditionKey.CK_LESS_EQUAL, threadName); + RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_LESS_EQUAL, threadName); if (opLambda != null) { opLambda.callback(builder); } @@ -1017,29 +1018,29 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setUrl_Term(String url, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("url", url); + TermQueryBuilder builder = regTermQ("url", url); if (opLambda != null) { opLambda.callback(builder); } } public void setUrl_Terms(Collection urlList) { - setUrl_MatchPhrasePrefix(urlList, null); + setUrl_Terms(urlList, null); } - public void setUrl_MatchPhrasePrefix(Collection urlList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("url", urlList); + public void setUrl_Terms(Collection urlList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("url", urlList); if (opLambda != null) { opLambda.callback(builder); } } public void setUrl_InScope(Collection urlList) { - setUrl_MatchPhrasePrefix(urlList, null); + setUrl_Terms(urlList, null); } public void setUrl_InScope(Collection urlList, ConditionOptionCall opLambda) { - setUrl_MatchPhrasePrefix(urlList, opLambda); + setUrl_Terms(urlList, opLambda); } public void setUrl_Match(String url) { @@ -1047,7 +1048,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setUrl_Match(String url, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("url", url); + MatchQueryBuilder builder = regMatchQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1059,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setUrl_MatchPhrase(String url, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("url", url); + MatchQueryBuilder builder = regMatchPhraseQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1070,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setUrl_MatchPhrasePrefix(String url, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("url", url); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1081,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setUrl_Fuzzy(String url, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("url", url); + FuzzyQueryBuilder builder = regFuzzyQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1092,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setUrl_Prefix(String url, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("url", url); + PrefixQueryBuilder builder = regPrefixQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1103,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setUrl_GreaterThan(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_THAN, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_THAN, url); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1114,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setUrl_LessThan(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_THAN, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_THAN, url); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1125,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setUrl_GreaterEqual(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url); if (opLambda != null) { opLambda.callback(builder); } @@ -1135,7 +1136,7 @@ public abstract class BsFailureUrlCQ extends AbstractConditionQuery { } public void setUrl_LessEqual(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_EQUAL, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_EQUAL, url); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFavoriteLogCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFavoriteLogCQ.java index be395cac2..262225563 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFavoriteLogCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFavoriteLogCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.FavoriteLogCQ; +import org.codelibs.fess.es.cbean.cf.FavoriteLogCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { return "favorite_log"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { FavoriteLogCQ query = new FavoriteLogCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + FavoriteLogCF filter = new FavoriteLogCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { FavoriteLogCQ shouldQuery = new FavoriteLogCQ(); FavoriteLogCQ mustNotQuery = new FavoriteLogCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -96,7 +97,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -194,29 +195,29 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -224,7 +225,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -235,7 +236,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUrl_Term(String url, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("url", url); + TermQueryBuilder builder = regTermQ("url", url); if (opLambda != null) { opLambda.callback(builder); } } public void setUrl_Terms(Collection urlList) { - setUrl_MatchPhrasePrefix(urlList, null); + setUrl_Terms(urlList, null); } - public void setUrl_MatchPhrasePrefix(Collection urlList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("url", urlList); + public void setUrl_Terms(Collection urlList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("url", urlList); if (opLambda != null) { opLambda.callback(builder); } } public void setUrl_InScope(Collection urlList) { - setUrl_MatchPhrasePrefix(urlList, null); + setUrl_Terms(urlList, null); } public void setUrl_InScope(Collection urlList, ConditionOptionCall opLambda) { - setUrl_MatchPhrasePrefix(urlList, opLambda); + setUrl_Terms(urlList, opLambda); } public void setUrl_Match(String url) { @@ -363,7 +364,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUrl_Match(String url, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("url", url); + MatchQueryBuilder builder = regMatchQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUrl_MatchPhrase(String url, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("url", url); + MatchQueryBuilder builder = regMatchPhraseQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUrl_MatchPhrasePrefix(String url, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("url", url); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUrl_Fuzzy(String url, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("url", url); + FuzzyQueryBuilder builder = regFuzzyQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUrl_Prefix(String url, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("url", url); + PrefixQueryBuilder builder = regPrefixQ("url", url); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUrl_GreaterThan(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_THAN, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_THAN, url); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUrl_LessThan(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_THAN, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_THAN, url); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUrl_GreaterEqual(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_EQUAL, url); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUrl_LessEqual(String url, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("url", ConditionKey.CK_LESS_EQUAL, url); + RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_EQUAL, url); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUserInfoId_Term(String userInfoId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("userInfoId", userInfoId); + TermQueryBuilder builder = regTermQ("userInfoId", userInfoId); if (opLambda != null) { opLambda.callback(builder); } } public void setUserInfoId_Terms(Collection userInfoIdList) { - setUserInfoId_MatchPhrasePrefix(userInfoIdList, null); + setUserInfoId_Terms(userInfoIdList, null); } - public void setUserInfoId_MatchPhrasePrefix(Collection userInfoIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("userInfoId", userInfoIdList); + public void setUserInfoId_Terms(Collection userInfoIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("userInfoId", userInfoIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setUserInfoId_InScope(Collection userInfoIdList) { - setUserInfoId_MatchPhrasePrefix(userInfoIdList, null); + setUserInfoId_Terms(userInfoIdList, null); } public void setUserInfoId_InScope(Collection userInfoIdList, ConditionOptionCall opLambda) { - setUserInfoId_MatchPhrasePrefix(userInfoIdList, opLambda); + setUserInfoId_Terms(userInfoIdList, opLambda); } public void setUserInfoId_Match(String userInfoId) { @@ -502,7 +503,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUserInfoId_Match(String userInfoId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("userInfoId", userInfoId); + MatchQueryBuilder builder = regMatchQ("userInfoId", userInfoId); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUserInfoId_MatchPhrase(String userInfoId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("userInfoId", userInfoId); + MatchQueryBuilder builder = regMatchPhraseQ("userInfoId", userInfoId); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUserInfoId_MatchPhrasePrefix(String userInfoId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("userInfoId", userInfoId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("userInfoId", userInfoId); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUserInfoId_Fuzzy(String userInfoId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("userInfoId", userInfoId); + FuzzyQueryBuilder builder = regFuzzyQ("userInfoId", userInfoId); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUserInfoId_Prefix(String userInfoId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("userInfoId", userInfoId); + PrefixQueryBuilder builder = regPrefixQ("userInfoId", userInfoId); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUserInfoId_GreaterThan(String userInfoId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userInfoId", ConditionKey.CK_GREATER_THAN, userInfoId); + RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_GREATER_THAN, userInfoId); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUserInfoId_LessThan(String userInfoId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userInfoId", ConditionKey.CK_LESS_THAN, userInfoId); + RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_LESS_THAN, userInfoId); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUserInfoId_GreaterEqual(String userInfoId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userInfoId", ConditionKey.CK_GREATER_EQUAL, userInfoId); + RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_GREATER_EQUAL, userInfoId); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +591,7 @@ public abstract class BsFavoriteLogCQ extends AbstractConditionQuery { } public void setUserInfoId_LessEqual(String userInfoId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userInfoId", ConditionKey.CK_LESS_EQUAL, userInfoId); + RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_LESS_EQUAL, userInfoId); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileAuthenticationCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileAuthenticationCQ.java index aed4736c3..aca7fb176 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileAuthenticationCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileAuthenticationCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.FileAuthenticationCQ; +import org.codelibs.fess.es.cbean.cf.FileAuthenticationCF; 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 BsFileAuthenticationCQ extends AbstractConditionQuery { return "file_authentication"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { FileAuthenticationCQ query = new FileAuthenticationCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + FileAuthenticationCF filter = new FileAuthenticationCF(); + 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 BsFileAuthenticationCQ extends AbstractConditionQuery { FileAuthenticationCQ shouldQuery = new FileAuthenticationCQ(); FileAuthenticationCQ mustNotQuery = new FileAuthenticationCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -96,7 +98,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +186,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +207,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -235,7 +237,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +314,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +335,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setFileConfigId_Term(String fileConfigId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("fileConfigId", fileConfigId); + TermQueryBuilder builder = regTermQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } } public void setFileConfigId_Terms(Collection fileConfigIdList) { - setFileConfigId_MatchPhrasePrefix(fileConfigIdList, null); + setFileConfigId_Terms(fileConfigIdList, null); } - public void setFileConfigId_MatchPhrasePrefix(Collection fileConfigIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("fileConfigId", fileConfigIdList); + public void setFileConfigId_Terms(Collection fileConfigIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("fileConfigId", fileConfigIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setFileConfigId_InScope(Collection fileConfigIdList) { - setFileConfigId_MatchPhrasePrefix(fileConfigIdList, null); + setFileConfigId_Terms(fileConfigIdList, null); } public void setFileConfigId_InScope(Collection fileConfigIdList, ConditionOptionCall opLambda) { - setFileConfigId_MatchPhrasePrefix(fileConfigIdList, opLambda); + setFileConfigId_Terms(fileConfigIdList, opLambda); } public void setFileConfigId_Match(String fileConfigId) { @@ -363,7 +365,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setFileConfigId_Match(String fileConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("fileConfigId", fileConfigId); + MatchQueryBuilder builder = regMatchQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +376,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setFileConfigId_MatchPhrase(String fileConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("fileConfigId", fileConfigId); + MatchQueryBuilder builder = regMatchPhraseQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setFileConfigId_MatchPhrasePrefix(String fileConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("fileConfigId", fileConfigId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setFileConfigId_Fuzzy(String fileConfigId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("fileConfigId", fileConfigId); + FuzzyQueryBuilder builder = regFuzzyQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setFileConfigId_Prefix(String fileConfigId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("fileConfigId", fileConfigId); + PrefixQueryBuilder builder = regPrefixQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setFileConfigId_GreaterThan(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setFileConfigId_LessThan(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setFileConfigId_GreaterEqual(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +453,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setFileConfigId_LessEqual(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +474,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_Term(String hostname, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("hostname", hostname); + TermQueryBuilder builder = regTermQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } } public void setHostname_Terms(Collection hostnameList) { - setHostname_MatchPhrasePrefix(hostnameList, null); + setHostname_Terms(hostnameList, null); } - public void setHostname_MatchPhrasePrefix(Collection hostnameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("hostname", hostnameList); + public void setHostname_Terms(Collection hostnameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("hostname", hostnameList); if (opLambda != null) { opLambda.callback(builder); } } public void setHostname_InScope(Collection hostnameList) { - setHostname_MatchPhrasePrefix(hostnameList, null); + setHostname_Terms(hostnameList, null); } public void setHostname_InScope(Collection hostnameList, ConditionOptionCall opLambda) { - setHostname_MatchPhrasePrefix(hostnameList, opLambda); + setHostname_Terms(hostnameList, opLambda); } public void setHostname_Match(String hostname) { @@ -502,7 +504,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_Match(String hostname, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("hostname", hostname); + MatchQueryBuilder builder = regMatchQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +515,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_MatchPhrase(String hostname, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("hostname", hostname); + MatchQueryBuilder builder = regMatchPhraseQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +526,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_MatchPhrasePrefix(String hostname, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("hostname", hostname); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +537,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_Fuzzy(String hostname, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("hostname", hostname); + FuzzyQueryBuilder builder = regFuzzyQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +548,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_Prefix(String hostname, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("hostname", hostname); + PrefixQueryBuilder builder = regPrefixQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +559,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_GreaterThan(String hostname, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hostname", ConditionKey.CK_GREATER_THAN, hostname); + RangeQueryBuilder builder = regRangeQ("hostname", ConditionKey.CK_GREATER_THAN, hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +570,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_LessThan(String hostname, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hostname", ConditionKey.CK_LESS_THAN, hostname); + RangeQueryBuilder builder = regRangeQ("hostname", ConditionKey.CK_LESS_THAN, hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +581,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_GreaterEqual(String hostname, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hostname", ConditionKey.CK_GREATER_EQUAL, hostname); + RangeQueryBuilder builder = regRangeQ("hostname", ConditionKey.CK_GREATER_EQUAL, hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +592,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_LessEqual(String hostname, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hostname", ConditionKey.CK_LESS_EQUAL, hostname); + RangeQueryBuilder builder = regRangeQ("hostname", ConditionKey.CK_LESS_EQUAL, hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +613,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -641,7 +643,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +654,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +665,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +676,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +687,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +698,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +709,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +720,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -729,7 +731,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -750,29 +752,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_Term(String parameters, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("parameters", parameters); + TermQueryBuilder builder = regTermQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } } public void setParameters_Terms(Collection parametersList) { - setParameters_MatchPhrasePrefix(parametersList, null); + setParameters_Terms(parametersList, null); } - public void setParameters_MatchPhrasePrefix(Collection parametersList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("parameters", parametersList); + public void setParameters_Terms(Collection parametersList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("parameters", parametersList); if (opLambda != null) { opLambda.callback(builder); } } public void setParameters_InScope(Collection parametersList) { - setParameters_MatchPhrasePrefix(parametersList, null); + setParameters_Terms(parametersList, null); } public void setParameters_InScope(Collection parametersList, ConditionOptionCall opLambda) { - setParameters_MatchPhrasePrefix(parametersList, opLambda); + setParameters_Terms(parametersList, opLambda); } public void setParameters_Match(String parameters) { @@ -780,7 +782,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_Match(String parameters, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("parameters", parameters); + MatchQueryBuilder builder = regMatchQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +793,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_MatchPhrase(String parameters, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("parameters", parameters); + MatchQueryBuilder builder = regMatchPhraseQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +804,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_MatchPhrasePrefix(String parameters, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("parameters", parameters); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +815,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_Fuzzy(String parameters, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("parameters", parameters); + FuzzyQueryBuilder builder = regFuzzyQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +826,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_Prefix(String parameters, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("parameters", parameters); + PrefixQueryBuilder builder = regPrefixQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +837,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_GreaterThan(String parameters, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("parameters", ConditionKey.CK_GREATER_THAN, parameters); + RangeQueryBuilder builder = regRangeQ("parameters", ConditionKey.CK_GREATER_THAN, parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +848,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_LessThan(String parameters, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("parameters", ConditionKey.CK_LESS_THAN, parameters); + RangeQueryBuilder builder = regRangeQ("parameters", ConditionKey.CK_LESS_THAN, parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +859,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_GreaterEqual(String parameters, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("parameters", ConditionKey.CK_GREATER_EQUAL, parameters); + RangeQueryBuilder builder = regRangeQ("parameters", ConditionKey.CK_GREATER_EQUAL, parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -868,7 +870,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_LessEqual(String parameters, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("parameters", ConditionKey.CK_LESS_EQUAL, parameters); + RangeQueryBuilder builder = regRangeQ("parameters", ConditionKey.CK_LESS_EQUAL, parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -889,29 +891,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_Term(String password, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("password", password); + TermQueryBuilder builder = regTermQ("password", password); if (opLambda != null) { opLambda.callback(builder); } } public void setPassword_Terms(Collection passwordList) { - setPassword_MatchPhrasePrefix(passwordList, null); + setPassword_Terms(passwordList, null); } - public void setPassword_MatchPhrasePrefix(Collection passwordList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("password", passwordList); + public void setPassword_Terms(Collection passwordList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("password", passwordList); if (opLambda != null) { opLambda.callback(builder); } } public void setPassword_InScope(Collection passwordList) { - setPassword_MatchPhrasePrefix(passwordList, null); + setPassword_Terms(passwordList, null); } public void setPassword_InScope(Collection passwordList, ConditionOptionCall opLambda) { - setPassword_MatchPhrasePrefix(passwordList, opLambda); + setPassword_Terms(passwordList, opLambda); } public void setPassword_Match(String password) { @@ -919,7 +921,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_Match(String password, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("password", password); + MatchQueryBuilder builder = regMatchQ("password", password); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +932,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_MatchPhrase(String password, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("password", password); + MatchQueryBuilder builder = regMatchPhraseQ("password", password); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +943,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_MatchPhrasePrefix(String password, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("password", password); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("password", password); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +954,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_Fuzzy(String password, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("password", password); + FuzzyQueryBuilder builder = regFuzzyQ("password", password); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +965,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_Prefix(String password, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("password", password); + PrefixQueryBuilder builder = regPrefixQ("password", password); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +976,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_GreaterThan(String password, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("password", ConditionKey.CK_GREATER_THAN, password); + RangeQueryBuilder builder = regRangeQ("password", ConditionKey.CK_GREATER_THAN, password); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +987,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_LessThan(String password, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("password", ConditionKey.CK_LESS_THAN, password); + RangeQueryBuilder builder = regRangeQ("password", ConditionKey.CK_LESS_THAN, password); if (opLambda != null) { opLambda.callback(builder); } @@ -996,7 +998,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_GreaterEqual(String password, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("password", ConditionKey.CK_GREATER_EQUAL, password); + RangeQueryBuilder builder = regRangeQ("password", ConditionKey.CK_GREATER_EQUAL, password); if (opLambda != null) { opLambda.callback(builder); } @@ -1007,7 +1009,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_LessEqual(String password, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("password", ConditionKey.CK_LESS_EQUAL, password); + RangeQueryBuilder builder = regRangeQ("password", ConditionKey.CK_LESS_EQUAL, password); if (opLambda != null) { opLambda.callback(builder); } @@ -1028,29 +1030,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPort_Term(Integer port, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("port", port); + TermQueryBuilder builder = regTermQ("port", port); if (opLambda != null) { opLambda.callback(builder); } } public void setPort_Terms(Collection portList) { - setPort_MatchPhrasePrefix(portList, null); + setPort_Terms(portList, null); } - public void setPort_MatchPhrasePrefix(Collection portList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("port", portList); + public void setPort_Terms(Collection portList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("port", portList); if (opLambda != null) { opLambda.callback(builder); } } public void setPort_InScope(Collection portList) { - setPort_MatchPhrasePrefix(portList, null); + setPort_Terms(portList, null); } public void setPort_InScope(Collection portList, ConditionOptionCall opLambda) { - setPort_MatchPhrasePrefix(portList, opLambda); + setPort_Terms(portList, opLambda); } public void setPort_Match(Integer port) { @@ -1058,7 +1060,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPort_Match(Integer port, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("port", port); + MatchQueryBuilder builder = regMatchQ("port", port); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1071,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPort_MatchPhrase(Integer port, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("port", port); + MatchQueryBuilder builder = regMatchPhraseQ("port", port); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1082,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPort_MatchPhrasePrefix(Integer port, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("port", port); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("port", port); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1093,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPort_Fuzzy(Integer port, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("port", port); + FuzzyQueryBuilder builder = regFuzzyQ("port", port); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1104,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPort_GreaterThan(Integer port, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("port", ConditionKey.CK_GREATER_THAN, port); + RangeQueryBuilder builder = regRangeQ("port", ConditionKey.CK_GREATER_THAN, port); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1115,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPort_LessThan(Integer port, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("port", ConditionKey.CK_LESS_THAN, port); + RangeQueryBuilder builder = regRangeQ("port", ConditionKey.CK_LESS_THAN, port); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1126,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPort_GreaterEqual(Integer port, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("port", ConditionKey.CK_GREATER_EQUAL, port); + RangeQueryBuilder builder = regRangeQ("port", ConditionKey.CK_GREATER_EQUAL, port); if (opLambda != null) { opLambda.callback(builder); } @@ -1135,7 +1137,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setPort_LessEqual(Integer port, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("port", ConditionKey.CK_LESS_EQUAL, port); + RangeQueryBuilder builder = regRangeQ("port", ConditionKey.CK_LESS_EQUAL, port); if (opLambda != null) { opLambda.callback(builder); } @@ -1156,29 +1158,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_Term(String protocolScheme, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("protocolScheme", protocolScheme); + TermQueryBuilder builder = regTermQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } } public void setProtocolScheme_Terms(Collection protocolSchemeList) { - setProtocolScheme_MatchPhrasePrefix(protocolSchemeList, null); + setProtocolScheme_Terms(protocolSchemeList, null); } - public void setProtocolScheme_MatchPhrasePrefix(Collection protocolSchemeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("protocolScheme", protocolSchemeList); + public void setProtocolScheme_Terms(Collection protocolSchemeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("protocolScheme", protocolSchemeList); if (opLambda != null) { opLambda.callback(builder); } } public void setProtocolScheme_InScope(Collection protocolSchemeList) { - setProtocolScheme_MatchPhrasePrefix(protocolSchemeList, null); + setProtocolScheme_Terms(protocolSchemeList, null); } public void setProtocolScheme_InScope(Collection protocolSchemeList, ConditionOptionCall opLambda) { - setProtocolScheme_MatchPhrasePrefix(protocolSchemeList, opLambda); + setProtocolScheme_Terms(protocolSchemeList, opLambda); } public void setProtocolScheme_Match(String protocolScheme) { @@ -1186,7 +1188,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_Match(String protocolScheme, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("protocolScheme", protocolScheme); + MatchQueryBuilder builder = regMatchQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1197,7 +1199,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_MatchPhrase(String protocolScheme, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("protocolScheme", protocolScheme); + MatchQueryBuilder builder = regMatchPhraseQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1208,7 +1210,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_MatchPhrasePrefix(String protocolScheme, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("protocolScheme", protocolScheme); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1219,7 +1221,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_Fuzzy(String protocolScheme, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("protocolScheme", protocolScheme); + FuzzyQueryBuilder builder = regFuzzyQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1230,7 +1232,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_Prefix(String protocolScheme, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("protocolScheme", protocolScheme); + PrefixQueryBuilder builder = regPrefixQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1241,7 +1243,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_GreaterThan(String protocolScheme, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("protocolScheme", ConditionKey.CK_GREATER_THAN, protocolScheme); + RangeQueryBuilder builder = regRangeQ("protocolScheme", ConditionKey.CK_GREATER_THAN, protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1252,7 +1254,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_LessThan(String protocolScheme, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("protocolScheme", ConditionKey.CK_LESS_THAN, protocolScheme); + RangeQueryBuilder builder = regRangeQ("protocolScheme", ConditionKey.CK_LESS_THAN, protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1263,7 +1265,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_GreaterEqual(String protocolScheme, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("protocolScheme", ConditionKey.CK_GREATER_EQUAL, protocolScheme); + RangeQueryBuilder builder = regRangeQ("protocolScheme", ConditionKey.CK_GREATER_EQUAL, protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1274,7 +1276,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_LessEqual(String protocolScheme, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("protocolScheme", ConditionKey.CK_LESS_EQUAL, protocolScheme); + RangeQueryBuilder builder = regRangeQ("protocolScheme", ConditionKey.CK_LESS_EQUAL, protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1295,29 +1297,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -1325,7 +1327,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1336,7 +1338,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1347,7 +1349,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1358,7 +1360,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1369,7 +1371,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1380,7 +1382,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1391,7 +1393,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1402,7 +1404,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1413,7 +1415,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1434,29 +1436,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -1464,7 +1466,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1475,7 +1477,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1486,7 +1488,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1497,7 +1499,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1508,7 +1510,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1519,7 +1521,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1530,7 +1532,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1541,7 +1543,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1562,29 +1564,29 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_Term(String username, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("username", username); + TermQueryBuilder builder = regTermQ("username", username); if (opLambda != null) { opLambda.callback(builder); } } public void setUsername_Terms(Collection usernameList) { - setUsername_MatchPhrasePrefix(usernameList, null); + setUsername_Terms(usernameList, null); } - public void setUsername_MatchPhrasePrefix(Collection usernameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("username", usernameList); + public void setUsername_Terms(Collection usernameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("username", usernameList); if (opLambda != null) { opLambda.callback(builder); } } public void setUsername_InScope(Collection usernameList) { - setUsername_MatchPhrasePrefix(usernameList, null); + setUsername_Terms(usernameList, null); } public void setUsername_InScope(Collection usernameList, ConditionOptionCall opLambda) { - setUsername_MatchPhrasePrefix(usernameList, opLambda); + setUsername_Terms(usernameList, opLambda); } public void setUsername_Match(String username) { @@ -1592,7 +1594,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_Match(String username, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("username", username); + MatchQueryBuilder builder = regMatchQ("username", username); if (opLambda != null) { opLambda.callback(builder); } @@ -1603,7 +1605,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_MatchPhrase(String username, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("username", username); + MatchQueryBuilder builder = regMatchPhraseQ("username", username); if (opLambda != null) { opLambda.callback(builder); } @@ -1614,7 +1616,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_MatchPhrasePrefix(String username, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("username", username); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("username", username); if (opLambda != null) { opLambda.callback(builder); } @@ -1625,7 +1627,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_Fuzzy(String username, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("username", username); + FuzzyQueryBuilder builder = regFuzzyQ("username", username); if (opLambda != null) { opLambda.callback(builder); } @@ -1636,7 +1638,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_Prefix(String username, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("username", username); + PrefixQueryBuilder builder = regPrefixQ("username", username); if (opLambda != null) { opLambda.callback(builder); } @@ -1647,7 +1649,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_GreaterThan(String username, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("username", ConditionKey.CK_GREATER_THAN, username); + RangeQueryBuilder builder = regRangeQ("username", ConditionKey.CK_GREATER_THAN, username); if (opLambda != null) { opLambda.callback(builder); } @@ -1658,7 +1660,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_LessThan(String username, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("username", ConditionKey.CK_LESS_THAN, username); + RangeQueryBuilder builder = regRangeQ("username", ConditionKey.CK_LESS_THAN, username); if (opLambda != null) { opLambda.callback(builder); } @@ -1669,7 +1671,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_GreaterEqual(String username, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("username", ConditionKey.CK_GREATER_EQUAL, username); + RangeQueryBuilder builder = regRangeQ("username", ConditionKey.CK_GREATER_EQUAL, username); if (opLambda != null) { opLambda.callback(builder); } @@ -1680,7 +1682,7 @@ public abstract class BsFileAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_LessEqual(String username, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("username", ConditionKey.CK_LESS_EQUAL, username); + RangeQueryBuilder builder = regRangeQ("username", ConditionKey.CK_LESS_EQUAL, username); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigCQ.java index f558a5cc4..ceca04cd7 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.FileConfigCQ; +import org.codelibs.fess.es.cbean.cf.FileConfigCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { return "file_config"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { FileConfigCQ query = new FileConfigCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + FileConfigCF filter = new FileConfigCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { FileConfigCQ shouldQuery = new FileConfigCQ(); FileConfigCQ mustNotQuery = new FileConfigCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setAvailable_Term(Boolean available, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("available", available); + TermQueryBuilder builder = regTermQ("available", available); if (opLambda != null) { opLambda.callback(builder); } } public void setAvailable_Terms(Collection availableList) { - setAvailable_MatchPhrasePrefix(availableList, null); + setAvailable_Terms(availableList, null); } - public void setAvailable_MatchPhrasePrefix(Collection availableList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("available", availableList); + public void setAvailable_Terms(Collection availableList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("available", availableList); if (opLambda != null) { opLambda.callback(builder); } } public void setAvailable_InScope(Collection availableList) { - setAvailable_MatchPhrasePrefix(availableList, null); + setAvailable_Terms(availableList, null); } public void setAvailable_InScope(Collection availableList, ConditionOptionCall opLambda) { - setAvailable_MatchPhrasePrefix(availableList, opLambda); + setAvailable_Terms(availableList, opLambda); } public void setAvailable_Match(Boolean available) { @@ -96,7 +97,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setAvailable_Match(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("available", available); + MatchQueryBuilder builder = regMatchQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setAvailable_MatchPhrase(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("available", available); + MatchQueryBuilder builder = regMatchPhraseQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setAvailable_MatchPhrasePrefix(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("available", available); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setAvailable_Fuzzy(Boolean available, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("available", available); + FuzzyQueryBuilder builder = regFuzzyQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_GREATER_THAN, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_GREATER_THAN, available); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setAvailable_LessThan(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_LESS_THAN, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_LESS_THAN, available); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_GREATER_EQUAL, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_GREATER_EQUAL, available); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setAvailable_LessEqual(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_LESS_EQUAL, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_LESS_EQUAL, available); if (opLambda != null) { opLambda.callback(builder); } @@ -194,29 +195,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setBoost_Term(Float boost, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("boost", boost); + TermQueryBuilder builder = regTermQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } } public void setBoost_Terms(Collection boostList) { - setBoost_MatchPhrasePrefix(boostList, null); + setBoost_Terms(boostList, null); } - public void setBoost_MatchPhrasePrefix(Collection boostList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("boost", boostList); + public void setBoost_Terms(Collection boostList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("boost", boostList); if (opLambda != null) { opLambda.callback(builder); } } public void setBoost_InScope(Collection boostList) { - setBoost_MatchPhrasePrefix(boostList, null); + setBoost_Terms(boostList, null); } public void setBoost_InScope(Collection boostList, ConditionOptionCall opLambda) { - setBoost_MatchPhrasePrefix(boostList, opLambda); + setBoost_Terms(boostList, opLambda); } public void setBoost_Match(Float boost) { @@ -224,7 +225,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setBoost_Match(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("boost", boost); + MatchQueryBuilder builder = regMatchQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -235,7 +236,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setBoost_MatchPhrase(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("boost", boost); + MatchQueryBuilder builder = regMatchPhraseQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setBoost_MatchPhrasePrefix(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("boost", boost); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setBoost_Fuzzy(Float boost, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("boost", boost); + FuzzyQueryBuilder builder = regFuzzyQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setBoost_GreaterThan(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setBoost_LessThan(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_THAN, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_THAN, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setBoost_GreaterEqual(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setBoost_LessEqual(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -322,29 +323,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_Term(String configParameter, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("configParameter", configParameter); + TermQueryBuilder builder = regTermQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } } public void setConfigParameter_Terms(Collection configParameterList) { - setConfigParameter_MatchPhrasePrefix(configParameterList, null); + setConfigParameter_Terms(configParameterList, null); } - public void setConfigParameter_MatchPhrasePrefix(Collection configParameterList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("configParameter", configParameterList); + public void setConfigParameter_Terms(Collection configParameterList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("configParameter", configParameterList); if (opLambda != null) { opLambda.callback(builder); } } public void setConfigParameter_InScope(Collection configParameterList) { - setConfigParameter_MatchPhrasePrefix(configParameterList, null); + setConfigParameter_Terms(configParameterList, null); } public void setConfigParameter_InScope(Collection configParameterList, ConditionOptionCall opLambda) { - setConfigParameter_MatchPhrasePrefix(configParameterList, opLambda); + setConfigParameter_Terms(configParameterList, opLambda); } public void setConfigParameter_Match(String configParameter) { @@ -352,7 +353,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_Match(String configParameter, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("configParameter", configParameter); + MatchQueryBuilder builder = regMatchQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -363,7 +364,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_MatchPhrase(String configParameter, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("configParameter", configParameter); + MatchQueryBuilder builder = regMatchPhraseQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_MatchPhrasePrefix(String configParameter, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("configParameter", configParameter); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_Fuzzy(String configParameter, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("configParameter", configParameter); + FuzzyQueryBuilder builder = regFuzzyQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_Prefix(String configParameter, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("configParameter", configParameter); + PrefixQueryBuilder builder = regPrefixQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_GreaterThan(String configParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configParameter", ConditionKey.CK_GREATER_THAN, configParameter); + RangeQueryBuilder builder = regRangeQ("configParameter", ConditionKey.CK_GREATER_THAN, configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_LessThan(String configParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configParameter", ConditionKey.CK_LESS_THAN, configParameter); + RangeQueryBuilder builder = regRangeQ("configParameter", ConditionKey.CK_LESS_THAN, configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_GreaterEqual(String configParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configParameter", ConditionKey.CK_GREATER_EQUAL, configParameter); + RangeQueryBuilder builder = regRangeQ("configParameter", ConditionKey.CK_GREATER_EQUAL, configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_LessEqual(String configParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configParameter", ConditionKey.CK_LESS_EQUAL, configParameter); + RangeQueryBuilder builder = regRangeQ("configParameter", ConditionKey.CK_LESS_EQUAL, configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -461,29 +462,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -491,7 +492,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -502,7 +503,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -600,29 +601,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -630,7 +631,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -641,7 +642,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -728,29 +729,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setDepth_Term(Integer depth, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("depth", depth); + TermQueryBuilder builder = regTermQ("depth", depth); if (opLambda != null) { opLambda.callback(builder); } } public void setDepth_Terms(Collection depthList) { - setDepth_MatchPhrasePrefix(depthList, null); + setDepth_Terms(depthList, null); } - public void setDepth_MatchPhrasePrefix(Collection depthList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("depth", depthList); + public void setDepth_Terms(Collection depthList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("depth", depthList); if (opLambda != null) { opLambda.callback(builder); } } public void setDepth_InScope(Collection depthList) { - setDepth_MatchPhrasePrefix(depthList, null); + setDepth_Terms(depthList, null); } public void setDepth_InScope(Collection depthList, ConditionOptionCall opLambda) { - setDepth_MatchPhrasePrefix(depthList, opLambda); + setDepth_Terms(depthList, opLambda); } public void setDepth_Match(Integer depth) { @@ -758,7 +759,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setDepth_Match(Integer depth, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("depth", depth); + MatchQueryBuilder builder = regMatchQ("depth", depth); if (opLambda != null) { opLambda.callback(builder); } @@ -769,7 +770,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setDepth_MatchPhrase(Integer depth, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("depth", depth); + MatchQueryBuilder builder = regMatchPhraseQ("depth", depth); if (opLambda != null) { opLambda.callback(builder); } @@ -780,7 +781,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setDepth_MatchPhrasePrefix(Integer depth, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("depth", depth); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("depth", depth); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setDepth_Fuzzy(Integer depth, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("depth", depth); + FuzzyQueryBuilder builder = regFuzzyQ("depth", depth); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setDepth_GreaterThan(Integer depth, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("depth", ConditionKey.CK_GREATER_THAN, depth); + RangeQueryBuilder builder = regRangeQ("depth", ConditionKey.CK_GREATER_THAN, depth); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setDepth_LessThan(Integer depth, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("depth", ConditionKey.CK_LESS_THAN, depth); + RangeQueryBuilder builder = regRangeQ("depth", ConditionKey.CK_LESS_THAN, depth); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setDepth_GreaterEqual(Integer depth, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("depth", ConditionKey.CK_GREATER_EQUAL, depth); + RangeQueryBuilder builder = regRangeQ("depth", ConditionKey.CK_GREATER_EQUAL, depth); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setDepth_LessEqual(Integer depth, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("depth", ConditionKey.CK_LESS_EQUAL, depth); + RangeQueryBuilder builder = regRangeQ("depth", ConditionKey.CK_LESS_EQUAL, depth); if (opLambda != null) { opLambda.callback(builder); } @@ -856,30 +857,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedDocPaths_Term(String excludedDocPaths, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("excludedDocPaths", excludedDocPaths); + TermQueryBuilder builder = regTermQ("excludedDocPaths", excludedDocPaths); if (opLambda != null) { opLambda.callback(builder); } } public void setExcludedDocPaths_Terms(Collection excludedDocPathsList) { - setExcludedDocPaths_MatchPhrasePrefix(excludedDocPathsList, null); + setExcludedDocPaths_Terms(excludedDocPathsList, null); } - public void setExcludedDocPaths_MatchPhrasePrefix(Collection excludedDocPathsList, - ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("excludedDocPaths", excludedDocPathsList); + public void setExcludedDocPaths_Terms(Collection excludedDocPathsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("excludedDocPaths", excludedDocPathsList); if (opLambda != null) { opLambda.callback(builder); } } public void setExcludedDocPaths_InScope(Collection excludedDocPathsList) { - setExcludedDocPaths_MatchPhrasePrefix(excludedDocPathsList, null); + setExcludedDocPaths_Terms(excludedDocPathsList, null); } public void setExcludedDocPaths_InScope(Collection excludedDocPathsList, ConditionOptionCall opLambda) { - setExcludedDocPaths_MatchPhrasePrefix(excludedDocPathsList, opLambda); + setExcludedDocPaths_Terms(excludedDocPathsList, opLambda); } public void setExcludedDocPaths_Match(String excludedDocPaths) { @@ -887,7 +887,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedDocPaths_Match(String excludedDocPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("excludedDocPaths", excludedDocPaths); + MatchQueryBuilder builder = regMatchQ("excludedDocPaths", excludedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -898,7 +898,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedDocPaths_MatchPhrase(String excludedDocPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("excludedDocPaths", excludedDocPaths); + MatchQueryBuilder builder = regMatchPhraseQ("excludedDocPaths", excludedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -909,7 +909,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedDocPaths_MatchPhrasePrefix(String excludedDocPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("excludedDocPaths", excludedDocPaths); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("excludedDocPaths", excludedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -920,7 +920,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedDocPaths_Fuzzy(String excludedDocPaths, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("excludedDocPaths", excludedDocPaths); + FuzzyQueryBuilder builder = regFuzzyQ("excludedDocPaths", excludedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -931,7 +931,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedDocPaths_Prefix(String excludedDocPaths, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("excludedDocPaths", excludedDocPaths); + PrefixQueryBuilder builder = regPrefixQ("excludedDocPaths", excludedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -942,7 +942,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedDocPaths_GreaterThan(String excludedDocPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedDocPaths", ConditionKey.CK_GREATER_THAN, excludedDocPaths); + RangeQueryBuilder builder = regRangeQ("excludedDocPaths", ConditionKey.CK_GREATER_THAN, excludedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -953,7 +953,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedDocPaths_LessThan(String excludedDocPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedDocPaths", ConditionKey.CK_LESS_THAN, excludedDocPaths); + RangeQueryBuilder builder = regRangeQ("excludedDocPaths", ConditionKey.CK_LESS_THAN, excludedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -964,7 +964,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedDocPaths_GreaterEqual(String excludedDocPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedDocPaths", ConditionKey.CK_GREATER_EQUAL, excludedDocPaths); + RangeQueryBuilder builder = regRangeQ("excludedDocPaths", ConditionKey.CK_GREATER_EQUAL, excludedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -975,7 +975,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedDocPaths_LessEqual(String excludedDocPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedDocPaths", ConditionKey.CK_LESS_EQUAL, excludedDocPaths); + RangeQueryBuilder builder = regRangeQ("excludedDocPaths", ConditionKey.CK_LESS_EQUAL, excludedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -996,29 +996,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedPaths_Term(String excludedPaths, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("excludedPaths", excludedPaths); + TermQueryBuilder builder = regTermQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } } public void setExcludedPaths_Terms(Collection excludedPathsList) { - setExcludedPaths_MatchPhrasePrefix(excludedPathsList, null); + setExcludedPaths_Terms(excludedPathsList, null); } - public void setExcludedPaths_MatchPhrasePrefix(Collection excludedPathsList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("excludedPaths", excludedPathsList); + public void setExcludedPaths_Terms(Collection excludedPathsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("excludedPaths", excludedPathsList); if (opLambda != null) { opLambda.callback(builder); } } public void setExcludedPaths_InScope(Collection excludedPathsList) { - setExcludedPaths_MatchPhrasePrefix(excludedPathsList, null); + setExcludedPaths_Terms(excludedPathsList, null); } public void setExcludedPaths_InScope(Collection excludedPathsList, ConditionOptionCall opLambda) { - setExcludedPaths_MatchPhrasePrefix(excludedPathsList, opLambda); + setExcludedPaths_Terms(excludedPathsList, opLambda); } public void setExcludedPaths_Match(String excludedPaths) { @@ -1026,7 +1026,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedPaths_Match(String excludedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("excludedPaths", excludedPaths); + MatchQueryBuilder builder = regMatchQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1037,7 +1037,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedPaths_MatchPhrase(String excludedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("excludedPaths", excludedPaths); + MatchQueryBuilder builder = regMatchPhraseQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1048,7 +1048,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedPaths_MatchPhrasePrefix(String excludedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("excludedPaths", excludedPaths); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1059,7 +1059,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedPaths_Fuzzy(String excludedPaths, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("excludedPaths", excludedPaths); + FuzzyQueryBuilder builder = regFuzzyQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1070,7 +1070,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedPaths_Prefix(String excludedPaths, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("excludedPaths", excludedPaths); + PrefixQueryBuilder builder = regPrefixQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1081,7 +1081,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedPaths_GreaterThan(String excludedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedPaths", ConditionKey.CK_GREATER_THAN, excludedPaths); + RangeQueryBuilder builder = regRangeQ("excludedPaths", ConditionKey.CK_GREATER_THAN, excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1092,7 +1092,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedPaths_LessThan(String excludedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedPaths", ConditionKey.CK_LESS_THAN, excludedPaths); + RangeQueryBuilder builder = regRangeQ("excludedPaths", ConditionKey.CK_LESS_THAN, excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1103,7 +1103,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedPaths_GreaterEqual(String excludedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedPaths", ConditionKey.CK_GREATER_EQUAL, excludedPaths); + RangeQueryBuilder builder = regRangeQ("excludedPaths", ConditionKey.CK_GREATER_EQUAL, excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1114,7 +1114,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setExcludedPaths_LessEqual(String excludedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedPaths", ConditionKey.CK_LESS_EQUAL, excludedPaths); + RangeQueryBuilder builder = regRangeQ("excludedPaths", ConditionKey.CK_LESS_EQUAL, excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1135,29 +1135,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -1165,7 +1165,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1176,7 +1176,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1187,7 +1187,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1198,7 +1198,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1209,7 +1209,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1220,7 +1220,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1231,7 +1231,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1242,7 +1242,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1253,7 +1253,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1274,30 +1274,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedDocPaths_Term(String includedDocPaths, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("includedDocPaths", includedDocPaths); + TermQueryBuilder builder = regTermQ("includedDocPaths", includedDocPaths); if (opLambda != null) { opLambda.callback(builder); } } public void setIncludedDocPaths_Terms(Collection includedDocPathsList) { - setIncludedDocPaths_MatchPhrasePrefix(includedDocPathsList, null); + setIncludedDocPaths_Terms(includedDocPathsList, null); } - public void setIncludedDocPaths_MatchPhrasePrefix(Collection includedDocPathsList, - ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("includedDocPaths", includedDocPathsList); + public void setIncludedDocPaths_Terms(Collection includedDocPathsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("includedDocPaths", includedDocPathsList); if (opLambda != null) { opLambda.callback(builder); } } public void setIncludedDocPaths_InScope(Collection includedDocPathsList) { - setIncludedDocPaths_MatchPhrasePrefix(includedDocPathsList, null); + setIncludedDocPaths_Terms(includedDocPathsList, null); } public void setIncludedDocPaths_InScope(Collection includedDocPathsList, ConditionOptionCall opLambda) { - setIncludedDocPaths_MatchPhrasePrefix(includedDocPathsList, opLambda); + setIncludedDocPaths_Terms(includedDocPathsList, opLambda); } public void setIncludedDocPaths_Match(String includedDocPaths) { @@ -1305,7 +1304,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedDocPaths_Match(String includedDocPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("includedDocPaths", includedDocPaths); + MatchQueryBuilder builder = regMatchQ("includedDocPaths", includedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1316,7 +1315,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedDocPaths_MatchPhrase(String includedDocPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("includedDocPaths", includedDocPaths); + MatchQueryBuilder builder = regMatchPhraseQ("includedDocPaths", includedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1327,7 +1326,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedDocPaths_MatchPhrasePrefix(String includedDocPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("includedDocPaths", includedDocPaths); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("includedDocPaths", includedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1338,7 +1337,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedDocPaths_Fuzzy(String includedDocPaths, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("includedDocPaths", includedDocPaths); + FuzzyQueryBuilder builder = regFuzzyQ("includedDocPaths", includedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1349,7 +1348,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedDocPaths_Prefix(String includedDocPaths, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("includedDocPaths", includedDocPaths); + PrefixQueryBuilder builder = regPrefixQ("includedDocPaths", includedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1360,7 +1359,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedDocPaths_GreaterThan(String includedDocPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedDocPaths", ConditionKey.CK_GREATER_THAN, includedDocPaths); + RangeQueryBuilder builder = regRangeQ("includedDocPaths", ConditionKey.CK_GREATER_THAN, includedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1371,7 +1370,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedDocPaths_LessThan(String includedDocPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedDocPaths", ConditionKey.CK_LESS_THAN, includedDocPaths); + RangeQueryBuilder builder = regRangeQ("includedDocPaths", ConditionKey.CK_LESS_THAN, includedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1382,7 +1381,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedDocPaths_GreaterEqual(String includedDocPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedDocPaths", ConditionKey.CK_GREATER_EQUAL, includedDocPaths); + RangeQueryBuilder builder = regRangeQ("includedDocPaths", ConditionKey.CK_GREATER_EQUAL, includedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1393,7 +1392,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedDocPaths_LessEqual(String includedDocPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedDocPaths", ConditionKey.CK_LESS_EQUAL, includedDocPaths); + RangeQueryBuilder builder = regRangeQ("includedDocPaths", ConditionKey.CK_LESS_EQUAL, includedDocPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1414,29 +1413,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedPaths_Term(String includedPaths, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("includedPaths", includedPaths); + TermQueryBuilder builder = regTermQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } } public void setIncludedPaths_Terms(Collection includedPathsList) { - setIncludedPaths_MatchPhrasePrefix(includedPathsList, null); + setIncludedPaths_Terms(includedPathsList, null); } - public void setIncludedPaths_MatchPhrasePrefix(Collection includedPathsList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("includedPaths", includedPathsList); + public void setIncludedPaths_Terms(Collection includedPathsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("includedPaths", includedPathsList); if (opLambda != null) { opLambda.callback(builder); } } public void setIncludedPaths_InScope(Collection includedPathsList) { - setIncludedPaths_MatchPhrasePrefix(includedPathsList, null); + setIncludedPaths_Terms(includedPathsList, null); } public void setIncludedPaths_InScope(Collection includedPathsList, ConditionOptionCall opLambda) { - setIncludedPaths_MatchPhrasePrefix(includedPathsList, opLambda); + setIncludedPaths_Terms(includedPathsList, opLambda); } public void setIncludedPaths_Match(String includedPaths) { @@ -1444,7 +1443,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedPaths_Match(String includedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("includedPaths", includedPaths); + MatchQueryBuilder builder = regMatchQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1455,7 +1454,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedPaths_MatchPhrase(String includedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("includedPaths", includedPaths); + MatchQueryBuilder builder = regMatchPhraseQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1466,7 +1465,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedPaths_MatchPhrasePrefix(String includedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("includedPaths", includedPaths); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1477,7 +1476,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedPaths_Fuzzy(String includedPaths, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("includedPaths", includedPaths); + FuzzyQueryBuilder builder = regFuzzyQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1488,7 +1487,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedPaths_Prefix(String includedPaths, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("includedPaths", includedPaths); + PrefixQueryBuilder builder = regPrefixQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1499,7 +1498,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedPaths_GreaterThan(String includedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedPaths", ConditionKey.CK_GREATER_THAN, includedPaths); + RangeQueryBuilder builder = regRangeQ("includedPaths", ConditionKey.CK_GREATER_THAN, includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1510,7 +1509,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedPaths_LessThan(String includedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedPaths", ConditionKey.CK_LESS_THAN, includedPaths); + RangeQueryBuilder builder = regRangeQ("includedPaths", ConditionKey.CK_LESS_THAN, includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1521,7 +1520,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedPaths_GreaterEqual(String includedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedPaths", ConditionKey.CK_GREATER_EQUAL, includedPaths); + RangeQueryBuilder builder = regRangeQ("includedPaths", ConditionKey.CK_GREATER_EQUAL, includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1532,7 +1531,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIncludedPaths_LessEqual(String includedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedPaths", ConditionKey.CK_LESS_EQUAL, includedPaths); + RangeQueryBuilder builder = regRangeQ("includedPaths", ConditionKey.CK_LESS_EQUAL, includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -1553,29 +1552,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_Term(Integer intervalTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("intervalTime", intervalTime); + TermQueryBuilder builder = regTermQ("intervalTime", intervalTime); if (opLambda != null) { opLambda.callback(builder); } } public void setIntervalTime_Terms(Collection intervalTimeList) { - setIntervalTime_MatchPhrasePrefix(intervalTimeList, null); + setIntervalTime_Terms(intervalTimeList, null); } - public void setIntervalTime_MatchPhrasePrefix(Collection intervalTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("intervalTime", intervalTimeList); + public void setIntervalTime_Terms(Collection intervalTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("intervalTime", intervalTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setIntervalTime_InScope(Collection intervalTimeList) { - setIntervalTime_MatchPhrasePrefix(intervalTimeList, null); + setIntervalTime_Terms(intervalTimeList, null); } public void setIntervalTime_InScope(Collection intervalTimeList, ConditionOptionCall opLambda) { - setIntervalTime_MatchPhrasePrefix(intervalTimeList, opLambda); + setIntervalTime_Terms(intervalTimeList, opLambda); } public void setIntervalTime_Match(Integer intervalTime) { @@ -1583,7 +1582,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_Match(Integer intervalTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("intervalTime", intervalTime); + MatchQueryBuilder builder = regMatchQ("intervalTime", intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1594,7 +1593,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_MatchPhrase(Integer intervalTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("intervalTime", intervalTime); + MatchQueryBuilder builder = regMatchPhraseQ("intervalTime", intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1605,7 +1604,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_MatchPhrasePrefix(Integer intervalTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("intervalTime", intervalTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("intervalTime", intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1616,7 +1615,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_Fuzzy(Integer intervalTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("intervalTime", intervalTime); + FuzzyQueryBuilder builder = regFuzzyQ("intervalTime", intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1627,7 +1626,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_GreaterThan(Integer intervalTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("intervalTime", ConditionKey.CK_GREATER_THAN, intervalTime); + RangeQueryBuilder builder = regRangeQ("intervalTime", ConditionKey.CK_GREATER_THAN, intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1638,7 +1637,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_LessThan(Integer intervalTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("intervalTime", ConditionKey.CK_LESS_THAN, intervalTime); + RangeQueryBuilder builder = regRangeQ("intervalTime", ConditionKey.CK_LESS_THAN, intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1649,7 +1648,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_GreaterEqual(Integer intervalTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("intervalTime", ConditionKey.CK_GREATER_EQUAL, intervalTime); + RangeQueryBuilder builder = regRangeQ("intervalTime", ConditionKey.CK_GREATER_EQUAL, intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1660,7 +1659,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_LessEqual(Integer intervalTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("intervalTime", ConditionKey.CK_LESS_EQUAL, intervalTime); + RangeQueryBuilder builder = regRangeQ("intervalTime", ConditionKey.CK_LESS_EQUAL, intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1681,29 +1680,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_Term(Long maxAccessCount, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("maxAccessCount", maxAccessCount); + TermQueryBuilder builder = regTermQ("maxAccessCount", maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } } public void setMaxAccessCount_Terms(Collection maxAccessCountList) { - setMaxAccessCount_MatchPhrasePrefix(maxAccessCountList, null); + setMaxAccessCount_Terms(maxAccessCountList, null); } - public void setMaxAccessCount_MatchPhrasePrefix(Collection maxAccessCountList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("maxAccessCount", maxAccessCountList); + public void setMaxAccessCount_Terms(Collection maxAccessCountList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("maxAccessCount", maxAccessCountList); if (opLambda != null) { opLambda.callback(builder); } } public void setMaxAccessCount_InScope(Collection maxAccessCountList) { - setMaxAccessCount_MatchPhrasePrefix(maxAccessCountList, null); + setMaxAccessCount_Terms(maxAccessCountList, null); } public void setMaxAccessCount_InScope(Collection maxAccessCountList, ConditionOptionCall opLambda) { - setMaxAccessCount_MatchPhrasePrefix(maxAccessCountList, opLambda); + setMaxAccessCount_Terms(maxAccessCountList, opLambda); } public void setMaxAccessCount_Match(Long maxAccessCount) { @@ -1711,7 +1710,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_Match(Long maxAccessCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("maxAccessCount", maxAccessCount); + MatchQueryBuilder builder = regMatchQ("maxAccessCount", maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1722,7 +1721,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_MatchPhrase(Long maxAccessCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("maxAccessCount", maxAccessCount); + MatchQueryBuilder builder = regMatchPhraseQ("maxAccessCount", maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1733,7 +1732,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_MatchPhrasePrefix(Long maxAccessCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("maxAccessCount", maxAccessCount); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("maxAccessCount", maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1744,7 +1743,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_Fuzzy(Long maxAccessCount, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("maxAccessCount", maxAccessCount); + FuzzyQueryBuilder builder = regFuzzyQ("maxAccessCount", maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1755,7 +1754,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_GreaterThan(Long maxAccessCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxAccessCount", ConditionKey.CK_GREATER_THAN, maxAccessCount); + RangeQueryBuilder builder = regRangeQ("maxAccessCount", ConditionKey.CK_GREATER_THAN, maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1766,7 +1765,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_LessThan(Long maxAccessCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxAccessCount", ConditionKey.CK_LESS_THAN, maxAccessCount); + RangeQueryBuilder builder = regRangeQ("maxAccessCount", ConditionKey.CK_LESS_THAN, maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1777,7 +1776,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_GreaterEqual(Long maxAccessCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxAccessCount", ConditionKey.CK_GREATER_EQUAL, maxAccessCount); + RangeQueryBuilder builder = regRangeQ("maxAccessCount", ConditionKey.CK_GREATER_EQUAL, maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1788,7 +1787,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_LessEqual(Long maxAccessCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxAccessCount", ConditionKey.CK_LESS_EQUAL, maxAccessCount); + RangeQueryBuilder builder = regRangeQ("maxAccessCount", ConditionKey.CK_LESS_EQUAL, maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1809,29 +1808,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setName_Term(String name, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("name", name); + TermQueryBuilder builder = regTermQ("name", name); if (opLambda != null) { opLambda.callback(builder); } } public void setName_Terms(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } - public void setName_MatchPhrasePrefix(Collection nameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("name", nameList); + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("name", nameList); if (opLambda != null) { opLambda.callback(builder); } } public void setName_InScope(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { - setName_MatchPhrasePrefix(nameList, opLambda); + setName_Terms(nameList, opLambda); } public void setName_Match(String name) { @@ -1839,7 +1838,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setName_Match(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("name", name); + MatchQueryBuilder builder = regMatchQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1850,7 +1849,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setName_MatchPhrase(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("name", name); + MatchQueryBuilder builder = regMatchPhraseQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1861,7 +1860,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setName_MatchPhrasePrefix(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1872,7 +1871,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setName_Fuzzy(String name, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("name", name); + FuzzyQueryBuilder builder = regFuzzyQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1883,7 +1882,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setName_Prefix(String name, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("name", name); + PrefixQueryBuilder builder = regPrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1894,7 +1893,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1905,7 +1904,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setName_LessThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1916,7 +1915,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1927,7 +1926,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setName_LessEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1948,29 +1947,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_Term(Integer numOfThread, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("numOfThread", numOfThread); + TermQueryBuilder builder = regTermQ("numOfThread", numOfThread); if (opLambda != null) { opLambda.callback(builder); } } public void setNumOfThread_Terms(Collection numOfThreadList) { - setNumOfThread_MatchPhrasePrefix(numOfThreadList, null); + setNumOfThread_Terms(numOfThreadList, null); } - public void setNumOfThread_MatchPhrasePrefix(Collection numOfThreadList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("numOfThread", numOfThreadList); + public void setNumOfThread_Terms(Collection numOfThreadList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("numOfThread", numOfThreadList); if (opLambda != null) { opLambda.callback(builder); } } public void setNumOfThread_InScope(Collection numOfThreadList) { - setNumOfThread_MatchPhrasePrefix(numOfThreadList, null); + setNumOfThread_Terms(numOfThreadList, null); } public void setNumOfThread_InScope(Collection numOfThreadList, ConditionOptionCall opLambda) { - setNumOfThread_MatchPhrasePrefix(numOfThreadList, opLambda); + setNumOfThread_Terms(numOfThreadList, opLambda); } public void setNumOfThread_Match(Integer numOfThread) { @@ -1978,7 +1977,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_Match(Integer numOfThread, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("numOfThread", numOfThread); + MatchQueryBuilder builder = regMatchQ("numOfThread", numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -1989,7 +1988,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_MatchPhrase(Integer numOfThread, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("numOfThread", numOfThread); + MatchQueryBuilder builder = regMatchPhraseQ("numOfThread", numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2000,7 +1999,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_MatchPhrasePrefix(Integer numOfThread, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("numOfThread", numOfThread); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("numOfThread", numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2011,7 +2010,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_Fuzzy(Integer numOfThread, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("numOfThread", numOfThread); + FuzzyQueryBuilder builder = regFuzzyQ("numOfThread", numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2022,7 +2021,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_GreaterThan(Integer numOfThread, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("numOfThread", ConditionKey.CK_GREATER_THAN, numOfThread); + RangeQueryBuilder builder = regRangeQ("numOfThread", ConditionKey.CK_GREATER_THAN, numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2033,7 +2032,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_LessThan(Integer numOfThread, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("numOfThread", ConditionKey.CK_LESS_THAN, numOfThread); + RangeQueryBuilder builder = regRangeQ("numOfThread", ConditionKey.CK_LESS_THAN, numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2044,7 +2043,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_GreaterEqual(Integer numOfThread, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("numOfThread", ConditionKey.CK_GREATER_EQUAL, numOfThread); + RangeQueryBuilder builder = regRangeQ("numOfThread", ConditionKey.CK_GREATER_EQUAL, numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2055,7 +2054,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_LessEqual(Integer numOfThread, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("numOfThread", ConditionKey.CK_LESS_EQUAL, numOfThread); + RangeQueryBuilder builder = regRangeQ("numOfThread", ConditionKey.CK_LESS_EQUAL, numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2076,29 +2075,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setPaths_Term(String paths, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("paths", paths); + TermQueryBuilder builder = regTermQ("paths", paths); if (opLambda != null) { opLambda.callback(builder); } } public void setPaths_Terms(Collection pathsList) { - setPaths_MatchPhrasePrefix(pathsList, null); + setPaths_Terms(pathsList, null); } - public void setPaths_MatchPhrasePrefix(Collection pathsList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("paths", pathsList); + public void setPaths_Terms(Collection pathsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("paths", pathsList); if (opLambda != null) { opLambda.callback(builder); } } public void setPaths_InScope(Collection pathsList) { - setPaths_MatchPhrasePrefix(pathsList, null); + setPaths_Terms(pathsList, null); } public void setPaths_InScope(Collection pathsList, ConditionOptionCall opLambda) { - setPaths_MatchPhrasePrefix(pathsList, opLambda); + setPaths_Terms(pathsList, opLambda); } public void setPaths_Match(String paths) { @@ -2106,7 +2105,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setPaths_Match(String paths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("paths", paths); + MatchQueryBuilder builder = regMatchQ("paths", paths); if (opLambda != null) { opLambda.callback(builder); } @@ -2117,7 +2116,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setPaths_MatchPhrase(String paths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("paths", paths); + MatchQueryBuilder builder = regMatchPhraseQ("paths", paths); if (opLambda != null) { opLambda.callback(builder); } @@ -2128,7 +2127,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setPaths_MatchPhrasePrefix(String paths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("paths", paths); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("paths", paths); if (opLambda != null) { opLambda.callback(builder); } @@ -2139,7 +2138,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setPaths_Fuzzy(String paths, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("paths", paths); + FuzzyQueryBuilder builder = regFuzzyQ("paths", paths); if (opLambda != null) { opLambda.callback(builder); } @@ -2150,7 +2149,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setPaths_Prefix(String paths, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("paths", paths); + PrefixQueryBuilder builder = regPrefixQ("paths", paths); if (opLambda != null) { opLambda.callback(builder); } @@ -2161,7 +2160,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setPaths_GreaterThan(String paths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("paths", ConditionKey.CK_GREATER_THAN, paths); + RangeQueryBuilder builder = regRangeQ("paths", ConditionKey.CK_GREATER_THAN, paths); if (opLambda != null) { opLambda.callback(builder); } @@ -2172,7 +2171,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setPaths_LessThan(String paths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("paths", ConditionKey.CK_LESS_THAN, paths); + RangeQueryBuilder builder = regRangeQ("paths", ConditionKey.CK_LESS_THAN, paths); if (opLambda != null) { opLambda.callback(builder); } @@ -2183,7 +2182,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setPaths_GreaterEqual(String paths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("paths", ConditionKey.CK_GREATER_EQUAL, paths); + RangeQueryBuilder builder = regRangeQ("paths", ConditionKey.CK_GREATER_EQUAL, paths); if (opLambda != null) { opLambda.callback(builder); } @@ -2194,7 +2193,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setPaths_LessEqual(String paths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("paths", ConditionKey.CK_LESS_EQUAL, paths); + RangeQueryBuilder builder = regRangeQ("paths", ConditionKey.CK_LESS_EQUAL, paths); if (opLambda != null) { opLambda.callback(builder); } @@ -2215,29 +2214,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder); + TermQueryBuilder builder = regTermQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_Terms(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } - public void setSortOrder_MatchPhrasePrefix(Collection sortOrderList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList); + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_InScope(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { - setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda); + setSortOrder_Terms(sortOrderList, opLambda); } public void setSortOrder_Match(Integer sortOrder) { @@ -2245,7 +2244,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2256,7 +2255,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2267,7 +2266,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2278,7 +2277,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder); + FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2289,7 +2288,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2300,7 +2299,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2311,7 +2310,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2322,7 +2321,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2343,29 +2342,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -2373,7 +2372,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2384,7 +2383,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2395,7 +2394,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2406,7 +2405,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2417,7 +2416,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2428,7 +2427,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2439,7 +2438,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2450,7 +2449,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2461,7 +2460,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2482,29 +2481,29 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -2512,7 +2511,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2523,7 +2522,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2534,7 +2533,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2545,7 +2544,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2556,7 +2555,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2567,7 +2566,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2578,7 +2577,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2589,7 +2588,7 @@ public abstract class BsFileConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigToLabelCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigToLabelCQ.java index 804e423d7..9edcc8f96 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigToLabelCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigToLabelCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.FileConfigToLabelCQ; +import org.codelibs.fess.es.cbean.cf.FileConfigToLabelCF; 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 BsFileConfigToLabelCQ extends AbstractConditionQuery { return "file_config_to_label"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { FileConfigToLabelCQ query = new FileConfigToLabelCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + FileConfigToLabelCF filter = new FileConfigToLabelCF(); + 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 BsFileConfigToLabelCQ extends AbstractConditionQuery { FileConfigToLabelCQ shouldQuery = new FileConfigToLabelCQ(); FileConfigToLabelCQ mustNotQuery = new FileConfigToLabelCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setFileConfigId_Term(String fileConfigId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("fileConfigId", fileConfigId); + TermQueryBuilder builder = regTermQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } } public void setFileConfigId_Terms(Collection fileConfigIdList) { - setFileConfigId_MatchPhrasePrefix(fileConfigIdList, null); + setFileConfigId_Terms(fileConfigIdList, null); } - public void setFileConfigId_MatchPhrasePrefix(Collection fileConfigIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("fileConfigId", fileConfigIdList); + public void setFileConfigId_Terms(Collection fileConfigIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("fileConfigId", fileConfigIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setFileConfigId_InScope(Collection fileConfigIdList) { - setFileConfigId_MatchPhrasePrefix(fileConfigIdList, null); + setFileConfigId_Terms(fileConfigIdList, null); } public void setFileConfigId_InScope(Collection fileConfigIdList, ConditionOptionCall opLambda) { - setFileConfigId_MatchPhrasePrefix(fileConfigIdList, opLambda); + setFileConfigId_Terms(fileConfigIdList, opLambda); } public void setFileConfigId_Match(String fileConfigId) { @@ -96,7 +98,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setFileConfigId_Match(String fileConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("fileConfigId", fileConfigId); + MatchQueryBuilder builder = regMatchQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setFileConfigId_MatchPhrase(String fileConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("fileConfigId", fileConfigId); + MatchQueryBuilder builder = regMatchPhraseQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setFileConfigId_MatchPhrasePrefix(String fileConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("fileConfigId", fileConfigId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setFileConfigId_Fuzzy(String fileConfigId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("fileConfigId", fileConfigId); + FuzzyQueryBuilder builder = regFuzzyQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setFileConfigId_Prefix(String fileConfigId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("fileConfigId", fileConfigId); + PrefixQueryBuilder builder = regPrefixQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setFileConfigId_GreaterThan(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setFileConfigId_LessThan(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setFileConfigId_GreaterEqual(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +186,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setFileConfigId_LessEqual(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +207,29 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -235,7 +237,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +314,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -323,7 +325,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -344,29 +346,29 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("labelTypeId", labelTypeId); + TermQueryBuilder builder = regTermQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } } public void setLabelTypeId_Terms(Collection labelTypeIdList) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null); + setLabelTypeId_Terms(labelTypeIdList, null); } - public void setLabelTypeId_MatchPhrasePrefix(Collection labelTypeIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("labelTypeId", labelTypeIdList); + public void setLabelTypeId_Terms(Collection labelTypeIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("labelTypeId", labelTypeIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setLabelTypeId_InScope(Collection labelTypeIdList) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null); + setLabelTypeId_Terms(labelTypeIdList, null); } public void setLabelTypeId_InScope(Collection labelTypeIdList, ConditionOptionCall opLambda) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, opLambda); + setLabelTypeId_Terms(labelTypeIdList, opLambda); } public void setLabelTypeId_Match(String labelTypeId) { @@ -374,7 +376,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Match(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_MatchPhrase(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchPhraseQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_MatchPhrasePrefix(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Fuzzy(String labelTypeId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("labelTypeId", labelTypeId); + FuzzyQueryBuilder builder = regFuzzyQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("labelTypeId", labelTypeId); + PrefixQueryBuilder builder = regPrefixQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +453,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -462,7 +464,7 @@ public abstract class BsFileConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigToRoleCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigToRoleCQ.java index b72a06616..631bb67d3 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigToRoleCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsFileConfigToRoleCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.FileConfigToRoleCQ; +import org.codelibs.fess.es.cbean.cf.FileConfigToRoleCF; 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 BsFileConfigToRoleCQ extends AbstractConditionQuery { return "file_config_to_role"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { FileConfigToRoleCQ query = new FileConfigToRoleCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + FileConfigToRoleCF filter = new FileConfigToRoleCF(); + 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 BsFileConfigToRoleCQ extends AbstractConditionQuery { FileConfigToRoleCQ shouldQuery = new FileConfigToRoleCQ(); FileConfigToRoleCQ mustNotQuery = new FileConfigToRoleCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setFileConfigId_Term(String fileConfigId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("fileConfigId", fileConfigId); + TermQueryBuilder builder = regTermQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } } public void setFileConfigId_Terms(Collection fileConfigIdList) { - setFileConfigId_MatchPhrasePrefix(fileConfigIdList, null); + setFileConfigId_Terms(fileConfigIdList, null); } - public void setFileConfigId_MatchPhrasePrefix(Collection fileConfigIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("fileConfigId", fileConfigIdList); + public void setFileConfigId_Terms(Collection fileConfigIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("fileConfigId", fileConfigIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setFileConfigId_InScope(Collection fileConfigIdList) { - setFileConfigId_MatchPhrasePrefix(fileConfigIdList, null); + setFileConfigId_Terms(fileConfigIdList, null); } public void setFileConfigId_InScope(Collection fileConfigIdList, ConditionOptionCall opLambda) { - setFileConfigId_MatchPhrasePrefix(fileConfigIdList, opLambda); + setFileConfigId_Terms(fileConfigIdList, opLambda); } public void setFileConfigId_Match(String fileConfigId) { @@ -96,7 +98,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setFileConfigId_Match(String fileConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("fileConfigId", fileConfigId); + MatchQueryBuilder builder = regMatchQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setFileConfigId_MatchPhrase(String fileConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("fileConfigId", fileConfigId); + MatchQueryBuilder builder = regMatchPhraseQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setFileConfigId_MatchPhrasePrefix(String fileConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("fileConfigId", fileConfigId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setFileConfigId_Fuzzy(String fileConfigId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("fileConfigId", fileConfigId); + FuzzyQueryBuilder builder = regFuzzyQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setFileConfigId_Prefix(String fileConfigId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("fileConfigId", fileConfigId); + PrefixQueryBuilder builder = regPrefixQ("fileConfigId", fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setFileConfigId_GreaterThan(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_GREATER_THAN, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setFileConfigId_LessThan(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_LESS_THAN, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setFileConfigId_GreaterEqual(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_GREATER_EQUAL, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +186,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setFileConfigId_LessEqual(String fileConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId); + RangeQueryBuilder builder = regRangeQ("fileConfigId", ConditionKey.CK_LESS_EQUAL, fileConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +207,29 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -235,7 +237,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +314,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -323,7 +325,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -344,29 +346,29 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("roleTypeId", roleTypeId); + TermQueryBuilder builder = regTermQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } } public void setRoleTypeId_Terms(Collection roleTypeIdList) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null); + setRoleTypeId_Terms(roleTypeIdList, null); } - public void setRoleTypeId_MatchPhrasePrefix(Collection roleTypeIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("roleTypeId", roleTypeIdList); + public void setRoleTypeId_Terms(Collection roleTypeIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("roleTypeId", roleTypeIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setRoleTypeId_InScope(Collection roleTypeIdList) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null); + setRoleTypeId_Terms(roleTypeIdList, null); } public void setRoleTypeId_InScope(Collection roleTypeIdList, ConditionOptionCall opLambda) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, opLambda); + setRoleTypeId_Terms(roleTypeIdList, opLambda); } public void setRoleTypeId_Match(String roleTypeId) { @@ -374,7 +376,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Match(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_MatchPhrase(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchPhraseQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_MatchPhrasePrefix(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Fuzzy(String roleTypeId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("roleTypeId", roleTypeId); + FuzzyQueryBuilder builder = regFuzzyQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("roleTypeId", roleTypeId); + PrefixQueryBuilder builder = regPrefixQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +453,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -462,7 +464,7 @@ public abstract class BsFileConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsJobLogCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsJobLogCQ.java index a584bbb81..689ba0f96 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsJobLogCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsJobLogCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.JobLogCQ; +import org.codelibs.fess.es.cbean.cf.JobLogCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { return "job_log"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { JobLogCQ query = new JobLogCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + JobLogCF filter = new JobLogCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { JobLogCQ shouldQuery = new JobLogCQ(); JobLogCQ mustNotQuery = new JobLogCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setEndTime_Term(Long endTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("endTime", endTime); + TermQueryBuilder builder = regTermQ("endTime", endTime); if (opLambda != null) { opLambda.callback(builder); } } public void setEndTime_Terms(Collection endTimeList) { - setEndTime_MatchPhrasePrefix(endTimeList, null); + setEndTime_Terms(endTimeList, null); } - public void setEndTime_MatchPhrasePrefix(Collection endTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("endTime", endTimeList); + public void setEndTime_Terms(Collection endTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("endTime", endTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setEndTime_InScope(Collection endTimeList) { - setEndTime_MatchPhrasePrefix(endTimeList, null); + setEndTime_Terms(endTimeList, null); } public void setEndTime_InScope(Collection endTimeList, ConditionOptionCall opLambda) { - setEndTime_MatchPhrasePrefix(endTimeList, opLambda); + setEndTime_Terms(endTimeList, opLambda); } public void setEndTime_Match(Long endTime) { @@ -96,7 +97,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setEndTime_Match(Long endTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("endTime", endTime); + MatchQueryBuilder builder = regMatchQ("endTime", endTime); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setEndTime_MatchPhrase(Long endTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("endTime", endTime); + MatchQueryBuilder builder = regMatchPhraseQ("endTime", endTime); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setEndTime_MatchPhrasePrefix(Long endTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("endTime", endTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("endTime", endTime); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setEndTime_Fuzzy(Long endTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("endTime", endTime); + FuzzyQueryBuilder builder = regFuzzyQ("endTime", endTime); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setEndTime_GreaterThan(Long endTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("endTime", ConditionKey.CK_GREATER_THAN, endTime); + RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_GREATER_THAN, endTime); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setEndTime_LessThan(Long endTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("endTime", ConditionKey.CK_LESS_THAN, endTime); + RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_LESS_THAN, endTime); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setEndTime_GreaterEqual(Long endTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("endTime", ConditionKey.CK_GREATER_EQUAL, endTime); + RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_GREATER_EQUAL, endTime); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setEndTime_LessEqual(Long endTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("endTime", ConditionKey.CK_LESS_EQUAL, endTime); + RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_LESS_EQUAL, endTime); if (opLambda != null) { opLambda.callback(builder); } @@ -194,29 +195,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -224,7 +225,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -235,7 +236,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobName_Term(String jobName, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("jobName", jobName); + TermQueryBuilder builder = regTermQ("jobName", jobName); if (opLambda != null) { opLambda.callback(builder); } } public void setJobName_Terms(Collection jobNameList) { - setJobName_MatchPhrasePrefix(jobNameList, null); + setJobName_Terms(jobNameList, null); } - public void setJobName_MatchPhrasePrefix(Collection jobNameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("jobName", jobNameList); + public void setJobName_Terms(Collection jobNameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("jobName", jobNameList); if (opLambda != null) { opLambda.callback(builder); } } public void setJobName_InScope(Collection jobNameList) { - setJobName_MatchPhrasePrefix(jobNameList, null); + setJobName_Terms(jobNameList, null); } public void setJobName_InScope(Collection jobNameList, ConditionOptionCall opLambda) { - setJobName_MatchPhrasePrefix(jobNameList, opLambda); + setJobName_Terms(jobNameList, opLambda); } public void setJobName_Match(String jobName) { @@ -363,7 +364,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobName_Match(String jobName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("jobName", jobName); + MatchQueryBuilder builder = regMatchQ("jobName", jobName); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobName_MatchPhrase(String jobName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("jobName", jobName); + MatchQueryBuilder builder = regMatchPhraseQ("jobName", jobName); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobName_MatchPhrasePrefix(String jobName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("jobName", jobName); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("jobName", jobName); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobName_Fuzzy(String jobName, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("jobName", jobName); + FuzzyQueryBuilder builder = regFuzzyQ("jobName", jobName); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobName_Prefix(String jobName, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("jobName", jobName); + PrefixQueryBuilder builder = regPrefixQ("jobName", jobName); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobName_GreaterThan(String jobName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobName", ConditionKey.CK_GREATER_THAN, jobName); + RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_GREATER_THAN, jobName); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobName_LessThan(String jobName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobName", ConditionKey.CK_LESS_THAN, jobName); + RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_LESS_THAN, jobName); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobName_GreaterEqual(String jobName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobName", ConditionKey.CK_GREATER_EQUAL, jobName); + RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_GREATER_EQUAL, jobName); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobName_LessEqual(String jobName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobName", ConditionKey.CK_LESS_EQUAL, jobName); + RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_LESS_EQUAL, jobName); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobStatus_Term(String jobStatus, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("jobStatus", jobStatus); + TermQueryBuilder builder = regTermQ("jobStatus", jobStatus); if (opLambda != null) { opLambda.callback(builder); } } public void setJobStatus_Terms(Collection jobStatusList) { - setJobStatus_MatchPhrasePrefix(jobStatusList, null); + setJobStatus_Terms(jobStatusList, null); } - public void setJobStatus_MatchPhrasePrefix(Collection jobStatusList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("jobStatus", jobStatusList); + public void setJobStatus_Terms(Collection jobStatusList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("jobStatus", jobStatusList); if (opLambda != null) { opLambda.callback(builder); } } public void setJobStatus_InScope(Collection jobStatusList) { - setJobStatus_MatchPhrasePrefix(jobStatusList, null); + setJobStatus_Terms(jobStatusList, null); } public void setJobStatus_InScope(Collection jobStatusList, ConditionOptionCall opLambda) { - setJobStatus_MatchPhrasePrefix(jobStatusList, opLambda); + setJobStatus_Terms(jobStatusList, opLambda); } public void setJobStatus_Match(String jobStatus) { @@ -502,7 +503,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobStatus_Match(String jobStatus, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("jobStatus", jobStatus); + MatchQueryBuilder builder = regMatchQ("jobStatus", jobStatus); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobStatus_MatchPhrase(String jobStatus, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("jobStatus", jobStatus); + MatchQueryBuilder builder = regMatchPhraseQ("jobStatus", jobStatus); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobStatus_MatchPhrasePrefix(String jobStatus, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("jobStatus", jobStatus); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("jobStatus", jobStatus); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobStatus_Fuzzy(String jobStatus, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("jobStatus", jobStatus); + FuzzyQueryBuilder builder = regFuzzyQ("jobStatus", jobStatus); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobStatus_Prefix(String jobStatus, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("jobStatus", jobStatus); + PrefixQueryBuilder builder = regPrefixQ("jobStatus", jobStatus); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobStatus_GreaterThan(String jobStatus, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobStatus", ConditionKey.CK_GREATER_THAN, jobStatus); + RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_GREATER_THAN, jobStatus); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobStatus_LessThan(String jobStatus, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobStatus", ConditionKey.CK_LESS_THAN, jobStatus); + RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_LESS_THAN, jobStatus); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobStatus_GreaterEqual(String jobStatus, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobStatus", ConditionKey.CK_GREATER_EQUAL, jobStatus); + RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_GREATER_EQUAL, jobStatus); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +591,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setJobStatus_LessEqual(String jobStatus, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobStatus", ConditionKey.CK_LESS_EQUAL, jobStatus); + RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_LESS_EQUAL, jobStatus); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +612,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptData_Term(String scriptData, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("scriptData", scriptData); + TermQueryBuilder builder = regTermQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } } public void setScriptData_Terms(Collection scriptDataList) { - setScriptData_MatchPhrasePrefix(scriptDataList, null); + setScriptData_Terms(scriptDataList, null); } - public void setScriptData_MatchPhrasePrefix(Collection scriptDataList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("scriptData", scriptDataList); + public void setScriptData_Terms(Collection scriptDataList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("scriptData", scriptDataList); if (opLambda != null) { opLambda.callback(builder); } } public void setScriptData_InScope(Collection scriptDataList) { - setScriptData_MatchPhrasePrefix(scriptDataList, null); + setScriptData_Terms(scriptDataList, null); } public void setScriptData_InScope(Collection scriptDataList, ConditionOptionCall opLambda) { - setScriptData_MatchPhrasePrefix(scriptDataList, opLambda); + setScriptData_Terms(scriptDataList, opLambda); } public void setScriptData_Match(String scriptData) { @@ -641,7 +642,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptData_Match(String scriptData, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("scriptData", scriptData); + MatchQueryBuilder builder = regMatchQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptData_MatchPhrase(String scriptData, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("scriptData", scriptData); + MatchQueryBuilder builder = regMatchPhraseQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptData_MatchPhrasePrefix(String scriptData, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("scriptData", scriptData); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptData_Fuzzy(String scriptData, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("scriptData", scriptData); + FuzzyQueryBuilder builder = regFuzzyQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptData_Prefix(String scriptData, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("scriptData", scriptData); + PrefixQueryBuilder builder = regPrefixQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptData_GreaterThan(String scriptData, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_GREATER_THAN, scriptData); + RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_GREATER_THAN, scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptData_LessThan(String scriptData, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_LESS_THAN, scriptData); + RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_LESS_THAN, scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +719,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptData_GreaterEqual(String scriptData, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_GREATER_EQUAL, scriptData); + RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_GREATER_EQUAL, scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -729,7 +730,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptData_LessEqual(String scriptData, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_LESS_EQUAL, scriptData); + RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_LESS_EQUAL, scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -750,29 +751,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptResult_Term(String scriptResult, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("scriptResult", scriptResult); + TermQueryBuilder builder = regTermQ("scriptResult", scriptResult); if (opLambda != null) { opLambda.callback(builder); } } public void setScriptResult_Terms(Collection scriptResultList) { - setScriptResult_MatchPhrasePrefix(scriptResultList, null); + setScriptResult_Terms(scriptResultList, null); } - public void setScriptResult_MatchPhrasePrefix(Collection scriptResultList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("scriptResult", scriptResultList); + public void setScriptResult_Terms(Collection scriptResultList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("scriptResult", scriptResultList); if (opLambda != null) { opLambda.callback(builder); } } public void setScriptResult_InScope(Collection scriptResultList) { - setScriptResult_MatchPhrasePrefix(scriptResultList, null); + setScriptResult_Terms(scriptResultList, null); } public void setScriptResult_InScope(Collection scriptResultList, ConditionOptionCall opLambda) { - setScriptResult_MatchPhrasePrefix(scriptResultList, opLambda); + setScriptResult_Terms(scriptResultList, opLambda); } public void setScriptResult_Match(String scriptResult) { @@ -780,7 +781,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptResult_Match(String scriptResult, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("scriptResult", scriptResult); + MatchQueryBuilder builder = regMatchQ("scriptResult", scriptResult); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptResult_MatchPhrase(String scriptResult, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("scriptResult", scriptResult); + MatchQueryBuilder builder = regMatchPhraseQ("scriptResult", scriptResult); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptResult_MatchPhrasePrefix(String scriptResult, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("scriptResult", scriptResult); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("scriptResult", scriptResult); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptResult_Fuzzy(String scriptResult, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("scriptResult", scriptResult); + FuzzyQueryBuilder builder = regFuzzyQ("scriptResult", scriptResult); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptResult_Prefix(String scriptResult, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("scriptResult", scriptResult); + PrefixQueryBuilder builder = regPrefixQ("scriptResult", scriptResult); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptResult_GreaterThan(String scriptResult, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptResult", ConditionKey.CK_GREATER_THAN, scriptResult); + RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_GREATER_THAN, scriptResult); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +847,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptResult_LessThan(String scriptResult, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptResult", ConditionKey.CK_LESS_THAN, scriptResult); + RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_LESS_THAN, scriptResult); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +858,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptResult_GreaterEqual(String scriptResult, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptResult", ConditionKey.CK_GREATER_EQUAL, scriptResult); + RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_GREATER_EQUAL, scriptResult); if (opLambda != null) { opLambda.callback(builder); } @@ -868,7 +869,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptResult_LessEqual(String scriptResult, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptResult", ConditionKey.CK_LESS_EQUAL, scriptResult); + RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_LESS_EQUAL, scriptResult); if (opLambda != null) { opLambda.callback(builder); } @@ -889,29 +890,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptType_Term(String scriptType, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("scriptType", scriptType); + TermQueryBuilder builder = regTermQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } } public void setScriptType_Terms(Collection scriptTypeList) { - setScriptType_MatchPhrasePrefix(scriptTypeList, null); + setScriptType_Terms(scriptTypeList, null); } - public void setScriptType_MatchPhrasePrefix(Collection scriptTypeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("scriptType", scriptTypeList); + public void setScriptType_Terms(Collection scriptTypeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("scriptType", scriptTypeList); if (opLambda != null) { opLambda.callback(builder); } } public void setScriptType_InScope(Collection scriptTypeList) { - setScriptType_MatchPhrasePrefix(scriptTypeList, null); + setScriptType_Terms(scriptTypeList, null); } public void setScriptType_InScope(Collection scriptTypeList, ConditionOptionCall opLambda) { - setScriptType_MatchPhrasePrefix(scriptTypeList, opLambda); + setScriptType_Terms(scriptTypeList, opLambda); } public void setScriptType_Match(String scriptType) { @@ -919,7 +920,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptType_Match(String scriptType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("scriptType", scriptType); + MatchQueryBuilder builder = regMatchQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +931,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptType_MatchPhrase(String scriptType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("scriptType", scriptType); + MatchQueryBuilder builder = regMatchPhraseQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +942,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptType_MatchPhrasePrefix(String scriptType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("scriptType", scriptType); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +953,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptType_Fuzzy(String scriptType, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("scriptType", scriptType); + FuzzyQueryBuilder builder = regFuzzyQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +964,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptType_Prefix(String scriptType, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("scriptType", scriptType); + PrefixQueryBuilder builder = regPrefixQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +975,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptType_GreaterThan(String scriptType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_GREATER_THAN, scriptType); + RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_GREATER_THAN, scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +986,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptType_LessThan(String scriptType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_LESS_THAN, scriptType); + RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_LESS_THAN, scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -996,7 +997,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptType_GreaterEqual(String scriptType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_GREATER_EQUAL, scriptType); + RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_GREATER_EQUAL, scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -1007,7 +1008,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setScriptType_LessEqual(String scriptType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_LESS_EQUAL, scriptType); + RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_LESS_EQUAL, scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -1028,29 +1029,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setStartTime_Term(Long startTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("startTime", startTime); + TermQueryBuilder builder = regTermQ("startTime", startTime); if (opLambda != null) { opLambda.callback(builder); } } public void setStartTime_Terms(Collection startTimeList) { - setStartTime_MatchPhrasePrefix(startTimeList, null); + setStartTime_Terms(startTimeList, null); } - public void setStartTime_MatchPhrasePrefix(Collection startTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("startTime", startTimeList); + public void setStartTime_Terms(Collection startTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("startTime", startTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setStartTime_InScope(Collection startTimeList) { - setStartTime_MatchPhrasePrefix(startTimeList, null); + setStartTime_Terms(startTimeList, null); } public void setStartTime_InScope(Collection startTimeList, ConditionOptionCall opLambda) { - setStartTime_MatchPhrasePrefix(startTimeList, opLambda); + setStartTime_Terms(startTimeList, opLambda); } public void setStartTime_Match(Long startTime) { @@ -1058,7 +1059,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setStartTime_Match(Long startTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("startTime", startTime); + MatchQueryBuilder builder = regMatchQ("startTime", startTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1070,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setStartTime_MatchPhrase(Long startTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("startTime", startTime); + MatchQueryBuilder builder = regMatchPhraseQ("startTime", startTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1081,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setStartTime_MatchPhrasePrefix(Long startTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("startTime", startTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("startTime", startTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1092,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setStartTime_Fuzzy(Long startTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("startTime", startTime); + FuzzyQueryBuilder builder = regFuzzyQ("startTime", startTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1103,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setStartTime_GreaterThan(Long startTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("startTime", ConditionKey.CK_GREATER_THAN, startTime); + RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_GREATER_THAN, startTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1114,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setStartTime_LessThan(Long startTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("startTime", ConditionKey.CK_LESS_THAN, startTime); + RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_LESS_THAN, startTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1125,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setStartTime_GreaterEqual(Long startTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("startTime", ConditionKey.CK_GREATER_EQUAL, startTime); + RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_GREATER_EQUAL, startTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1135,7 +1136,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setStartTime_LessEqual(Long startTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("startTime", ConditionKey.CK_LESS_EQUAL, startTime); + RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_LESS_EQUAL, startTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1156,29 +1157,29 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setTarget_Term(String target, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("target", target); + TermQueryBuilder builder = regTermQ("target", target); if (opLambda != null) { opLambda.callback(builder); } } public void setTarget_Terms(Collection targetList) { - setTarget_MatchPhrasePrefix(targetList, null); + setTarget_Terms(targetList, null); } - public void setTarget_MatchPhrasePrefix(Collection targetList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("target", targetList); + public void setTarget_Terms(Collection targetList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("target", targetList); if (opLambda != null) { opLambda.callback(builder); } } public void setTarget_InScope(Collection targetList) { - setTarget_MatchPhrasePrefix(targetList, null); + setTarget_Terms(targetList, null); } public void setTarget_InScope(Collection targetList, ConditionOptionCall opLambda) { - setTarget_MatchPhrasePrefix(targetList, opLambda); + setTarget_Terms(targetList, opLambda); } public void setTarget_Match(String target) { @@ -1186,7 +1187,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setTarget_Match(String target, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("target", target); + MatchQueryBuilder builder = regMatchQ("target", target); if (opLambda != null) { opLambda.callback(builder); } @@ -1197,7 +1198,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setTarget_MatchPhrase(String target, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("target", target); + MatchQueryBuilder builder = regMatchPhraseQ("target", target); if (opLambda != null) { opLambda.callback(builder); } @@ -1208,7 +1209,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setTarget_MatchPhrasePrefix(String target, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("target", target); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("target", target); if (opLambda != null) { opLambda.callback(builder); } @@ -1219,7 +1220,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setTarget_Fuzzy(String target, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("target", target); + FuzzyQueryBuilder builder = regFuzzyQ("target", target); if (opLambda != null) { opLambda.callback(builder); } @@ -1230,7 +1231,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setTarget_Prefix(String target, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("target", target); + PrefixQueryBuilder builder = regPrefixQ("target", target); if (opLambda != null) { opLambda.callback(builder); } @@ -1241,7 +1242,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setTarget_GreaterThan(String target, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_GREATER_THAN, target); + RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_GREATER_THAN, target); if (opLambda != null) { opLambda.callback(builder); } @@ -1252,7 +1253,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setTarget_LessThan(String target, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_LESS_THAN, target); + RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_LESS_THAN, target); if (opLambda != null) { opLambda.callback(builder); } @@ -1263,7 +1264,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setTarget_GreaterEqual(String target, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_GREATER_EQUAL, target); + RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_GREATER_EQUAL, target); if (opLambda != null) { opLambda.callback(builder); } @@ -1274,7 +1275,7 @@ public abstract class BsJobLogCQ extends AbstractConditionQuery { } public void setTarget_LessEqual(String target, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_LESS_EQUAL, target); + RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_LESS_EQUAL, target); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsKeyMatchCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsKeyMatchCQ.java index 1cec9e226..b9a028559 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsKeyMatchCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsKeyMatchCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.KeyMatchCQ; +import org.codelibs.fess.es.cbean.cf.KeyMatchCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { return "key_match"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { KeyMatchCQ query = new KeyMatchCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + KeyMatchCF filter = new KeyMatchCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { KeyMatchCQ shouldQuery = new KeyMatchCQ(); KeyMatchCQ mustNotQuery = new KeyMatchCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setBoost_Term(Float boost, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("boost", boost); + TermQueryBuilder builder = regTermQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } } public void setBoost_Terms(Collection boostList) { - setBoost_MatchPhrasePrefix(boostList, null); + setBoost_Terms(boostList, null); } - public void setBoost_MatchPhrasePrefix(Collection boostList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("boost", boostList); + public void setBoost_Terms(Collection boostList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("boost", boostList); if (opLambda != null) { opLambda.callback(builder); } } public void setBoost_InScope(Collection boostList) { - setBoost_MatchPhrasePrefix(boostList, null); + setBoost_Terms(boostList, null); } public void setBoost_InScope(Collection boostList, ConditionOptionCall opLambda) { - setBoost_MatchPhrasePrefix(boostList, opLambda); + setBoost_Terms(boostList, opLambda); } public void setBoost_Match(Float boost) { @@ -96,7 +97,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setBoost_Match(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("boost", boost); + MatchQueryBuilder builder = regMatchQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setBoost_MatchPhrase(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("boost", boost); + MatchQueryBuilder builder = regMatchPhraseQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setBoost_MatchPhrasePrefix(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("boost", boost); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setBoost_Fuzzy(Float boost, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("boost", boost); + FuzzyQueryBuilder builder = regFuzzyQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setBoost_GreaterThan(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setBoost_LessThan(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_THAN, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_THAN, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setBoost_GreaterEqual(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setBoost_LessEqual(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -194,29 +195,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -224,7 +225,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -235,7 +236,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -363,7 +364,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -461,29 +462,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -491,7 +492,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -502,7 +503,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -600,29 +601,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setMaxSize_Term(Integer maxSize, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("maxSize", maxSize); + TermQueryBuilder builder = regTermQ("maxSize", maxSize); if (opLambda != null) { opLambda.callback(builder); } } public void setMaxSize_Terms(Collection maxSizeList) { - setMaxSize_MatchPhrasePrefix(maxSizeList, null); + setMaxSize_Terms(maxSizeList, null); } - public void setMaxSize_MatchPhrasePrefix(Collection maxSizeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("maxSize", maxSizeList); + public void setMaxSize_Terms(Collection maxSizeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("maxSize", maxSizeList); if (opLambda != null) { opLambda.callback(builder); } } public void setMaxSize_InScope(Collection maxSizeList) { - setMaxSize_MatchPhrasePrefix(maxSizeList, null); + setMaxSize_Terms(maxSizeList, null); } public void setMaxSize_InScope(Collection maxSizeList, ConditionOptionCall opLambda) { - setMaxSize_MatchPhrasePrefix(maxSizeList, opLambda); + setMaxSize_Terms(maxSizeList, opLambda); } public void setMaxSize_Match(Integer maxSize) { @@ -630,7 +631,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setMaxSize_Match(Integer maxSize, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("maxSize", maxSize); + MatchQueryBuilder builder = regMatchQ("maxSize", maxSize); if (opLambda != null) { opLambda.callback(builder); } @@ -641,7 +642,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setMaxSize_MatchPhrase(Integer maxSize, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("maxSize", maxSize); + MatchQueryBuilder builder = regMatchPhraseQ("maxSize", maxSize); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setMaxSize_MatchPhrasePrefix(Integer maxSize, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("maxSize", maxSize); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("maxSize", maxSize); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setMaxSize_Fuzzy(Integer maxSize, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("maxSize", maxSize); + FuzzyQueryBuilder builder = regFuzzyQ("maxSize", maxSize); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setMaxSize_GreaterThan(Integer maxSize, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxSize", ConditionKey.CK_GREATER_THAN, maxSize); + RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_GREATER_THAN, maxSize); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setMaxSize_LessThan(Integer maxSize, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxSize", ConditionKey.CK_LESS_THAN, maxSize); + RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_LESS_THAN, maxSize); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setMaxSize_GreaterEqual(Integer maxSize, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxSize", ConditionKey.CK_GREATER_EQUAL, maxSize); + RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_GREATER_EQUAL, maxSize); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setMaxSize_LessEqual(Integer maxSize, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxSize", ConditionKey.CK_LESS_EQUAL, maxSize); + RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_LESS_EQUAL, maxSize); if (opLambda != null) { opLambda.callback(builder); } @@ -728,29 +729,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setQuery_Term(String query, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("query", query); + TermQueryBuilder builder = regTermQ("query", query); if (opLambda != null) { opLambda.callback(builder); } } public void setQuery_Terms(Collection queryList) { - setQuery_MatchPhrasePrefix(queryList, null); + setQuery_Terms(queryList, null); } - public void setQuery_MatchPhrasePrefix(Collection queryList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("query", queryList); + public void setQuery_Terms(Collection queryList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("query", queryList); if (opLambda != null) { opLambda.callback(builder); } } public void setQuery_InScope(Collection queryList) { - setQuery_MatchPhrasePrefix(queryList, null); + setQuery_Terms(queryList, null); } public void setQuery_InScope(Collection queryList, ConditionOptionCall opLambda) { - setQuery_MatchPhrasePrefix(queryList, opLambda); + setQuery_Terms(queryList, opLambda); } public void setQuery_Match(String query) { @@ -758,7 +759,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setQuery_Match(String query, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("query", query); + MatchQueryBuilder builder = regMatchQ("query", query); if (opLambda != null) { opLambda.callback(builder); } @@ -769,7 +770,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setQuery_MatchPhrase(String query, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("query", query); + MatchQueryBuilder builder = regMatchPhraseQ("query", query); if (opLambda != null) { opLambda.callback(builder); } @@ -780,7 +781,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setQuery_MatchPhrasePrefix(String query, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("query", query); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("query", query); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setQuery_Fuzzy(String query, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("query", query); + FuzzyQueryBuilder builder = regFuzzyQ("query", query); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setQuery_Prefix(String query, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("query", query); + PrefixQueryBuilder builder = regPrefixQ("query", query); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setQuery_GreaterThan(String query, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("query", ConditionKey.CK_GREATER_THAN, query); + RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_GREATER_THAN, query); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setQuery_LessThan(String query, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("query", ConditionKey.CK_LESS_THAN, query); + RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_LESS_THAN, query); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setQuery_GreaterEqual(String query, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("query", ConditionKey.CK_GREATER_EQUAL, query); + RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_GREATER_EQUAL, query); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +847,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setQuery_LessEqual(String query, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("query", ConditionKey.CK_LESS_EQUAL, query); + RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_LESS_EQUAL, query); if (opLambda != null) { opLambda.callback(builder); } @@ -867,29 +868,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setTerm_Term(String term, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("term", term); + TermQueryBuilder builder = regTermQ("term", term); if (opLambda != null) { opLambda.callback(builder); } } public void setTerm_Terms(Collection termList) { - setTerm_MatchPhrasePrefix(termList, null); + setTerm_Terms(termList, null); } - public void setTerm_MatchPhrasePrefix(Collection termList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("term", termList); + public void setTerm_Terms(Collection termList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("term", termList); if (opLambda != null) { opLambda.callback(builder); } } public void setTerm_InScope(Collection termList) { - setTerm_MatchPhrasePrefix(termList, null); + setTerm_Terms(termList, null); } public void setTerm_InScope(Collection termList, ConditionOptionCall opLambda) { - setTerm_MatchPhrasePrefix(termList, opLambda); + setTerm_Terms(termList, opLambda); } public void setTerm_Match(String term) { @@ -897,7 +898,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setTerm_Match(String term, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("term", term); + MatchQueryBuilder builder = regMatchQ("term", term); if (opLambda != null) { opLambda.callback(builder); } @@ -908,7 +909,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setTerm_MatchPhrase(String term, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("term", term); + MatchQueryBuilder builder = regMatchPhraseQ("term", term); if (opLambda != null) { opLambda.callback(builder); } @@ -919,7 +920,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setTerm_MatchPhrasePrefix(String term, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("term", term); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("term", term); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +931,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setTerm_Fuzzy(String term, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("term", term); + FuzzyQueryBuilder builder = regFuzzyQ("term", term); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +942,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setTerm_Prefix(String term, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("term", term); + PrefixQueryBuilder builder = regPrefixQ("term", term); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +953,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setTerm_GreaterThan(String term, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("term", ConditionKey.CK_GREATER_THAN, term); + RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_GREATER_THAN, term); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +964,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setTerm_LessThan(String term, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("term", ConditionKey.CK_LESS_THAN, term); + RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_LESS_THAN, term); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +975,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setTerm_GreaterEqual(String term, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("term", ConditionKey.CK_GREATER_EQUAL, term); + RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_GREATER_EQUAL, term); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +986,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setTerm_LessEqual(String term, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("term", ConditionKey.CK_LESS_EQUAL, term); + RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_LESS_EQUAL, term); if (opLambda != null) { opLambda.callback(builder); } @@ -1006,29 +1007,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -1036,7 +1037,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1047,7 +1048,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1059,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1070,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1081,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1092,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1103,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1114,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1125,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1145,29 +1146,29 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -1175,7 +1176,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1186,7 +1187,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1197,7 +1198,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1208,7 +1209,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1219,7 +1220,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1230,7 +1231,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1241,7 +1242,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1252,7 +1253,7 @@ public abstract class BsKeyMatchCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsLabelToRoleCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsLabelToRoleCQ.java index 4246144ec..5db32c411 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsLabelToRoleCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsLabelToRoleCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.LabelToRoleCQ; +import org.codelibs.fess.es.cbean.cf.LabelToRoleCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { return "label_to_role"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { LabelToRoleCQ query = new LabelToRoleCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + LabelToRoleCF filter = new LabelToRoleCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { LabelToRoleCQ shouldQuery = new LabelToRoleCQ(); LabelToRoleCQ mustNotQuery = new LabelToRoleCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -96,7 +97,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +185,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +206,29 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("labelTypeId", labelTypeId); + TermQueryBuilder builder = regTermQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } } public void setLabelTypeId_Terms(Collection labelTypeIdList) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null); + setLabelTypeId_Terms(labelTypeIdList, null); } - public void setLabelTypeId_MatchPhrasePrefix(Collection labelTypeIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("labelTypeId", labelTypeIdList); + public void setLabelTypeId_Terms(Collection labelTypeIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("labelTypeId", labelTypeIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setLabelTypeId_InScope(Collection labelTypeIdList) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null); + setLabelTypeId_Terms(labelTypeIdList, null); } public void setLabelTypeId_InScope(Collection labelTypeIdList, ConditionOptionCall opLambda) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, opLambda); + setLabelTypeId_Terms(labelTypeIdList, opLambda); } public void setLabelTypeId_Match(String labelTypeId) { @@ -235,7 +236,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setLabelTypeId_Match(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setLabelTypeId_MatchPhrase(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchPhraseQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setLabelTypeId_MatchPhrasePrefix(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setLabelTypeId_Fuzzy(String labelTypeId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("labelTypeId", labelTypeId); + FuzzyQueryBuilder builder = regFuzzyQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("labelTypeId", labelTypeId); + PrefixQueryBuilder builder = regPrefixQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -323,7 +324,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -344,29 +345,29 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("roleTypeId", roleTypeId); + TermQueryBuilder builder = regTermQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } } public void setRoleTypeId_Terms(Collection roleTypeIdList) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null); + setRoleTypeId_Terms(roleTypeIdList, null); } - public void setRoleTypeId_MatchPhrasePrefix(Collection roleTypeIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("roleTypeId", roleTypeIdList); + public void setRoleTypeId_Terms(Collection roleTypeIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("roleTypeId", roleTypeIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setRoleTypeId_InScope(Collection roleTypeIdList) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null); + setRoleTypeId_Terms(roleTypeIdList, null); } public void setRoleTypeId_InScope(Collection roleTypeIdList, ConditionOptionCall opLambda) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, opLambda); + setRoleTypeId_Terms(roleTypeIdList, opLambda); } public void setRoleTypeId_Match(String roleTypeId) { @@ -374,7 +375,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Match(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_MatchPhrase(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchPhraseQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_MatchPhrasePrefix(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Fuzzy(String roleTypeId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("roleTypeId", roleTypeId); + FuzzyQueryBuilder builder = regFuzzyQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("roleTypeId", roleTypeId); + PrefixQueryBuilder builder = regPrefixQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -462,7 +463,7 @@ public abstract class BsLabelToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsLabelTypeCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsLabelTypeCQ.java index e5f225c2f..bf87e7648 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsLabelTypeCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsLabelTypeCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.LabelTypeCQ; +import org.codelibs.fess.es.cbean.cf.LabelTypeCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { return "label_type"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { LabelTypeCQ query = new LabelTypeCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + LabelTypeCF filter = new LabelTypeCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { LabelTypeCQ shouldQuery = new LabelTypeCQ(); LabelTypeCQ mustNotQuery = new LabelTypeCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -96,7 +97,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +185,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +206,29 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -235,7 +236,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setExcludedPaths_Term(String excludedPaths, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("excludedPaths", excludedPaths); + TermQueryBuilder builder = regTermQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } } public void setExcludedPaths_Terms(Collection excludedPathsList) { - setExcludedPaths_MatchPhrasePrefix(excludedPathsList, null); + setExcludedPaths_Terms(excludedPathsList, null); } - public void setExcludedPaths_MatchPhrasePrefix(Collection excludedPathsList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("excludedPaths", excludedPathsList); + public void setExcludedPaths_Terms(Collection excludedPathsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("excludedPaths", excludedPathsList); if (opLambda != null) { opLambda.callback(builder); } } public void setExcludedPaths_InScope(Collection excludedPathsList) { - setExcludedPaths_MatchPhrasePrefix(excludedPathsList, null); + setExcludedPaths_Terms(excludedPathsList, null); } public void setExcludedPaths_InScope(Collection excludedPathsList, ConditionOptionCall opLambda) { - setExcludedPaths_MatchPhrasePrefix(excludedPathsList, opLambda); + setExcludedPaths_Terms(excludedPathsList, opLambda); } public void setExcludedPaths_Match(String excludedPaths) { @@ -363,7 +364,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setExcludedPaths_Match(String excludedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("excludedPaths", excludedPaths); + MatchQueryBuilder builder = regMatchQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setExcludedPaths_MatchPhrase(String excludedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("excludedPaths", excludedPaths); + MatchQueryBuilder builder = regMatchPhraseQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setExcludedPaths_MatchPhrasePrefix(String excludedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("excludedPaths", excludedPaths); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setExcludedPaths_Fuzzy(String excludedPaths, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("excludedPaths", excludedPaths); + FuzzyQueryBuilder builder = regFuzzyQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setExcludedPaths_Prefix(String excludedPaths, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("excludedPaths", excludedPaths); + PrefixQueryBuilder builder = regPrefixQ("excludedPaths", excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setExcludedPaths_GreaterThan(String excludedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedPaths", ConditionKey.CK_GREATER_THAN, excludedPaths); + RangeQueryBuilder builder = regRangeQ("excludedPaths", ConditionKey.CK_GREATER_THAN, excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setExcludedPaths_LessThan(String excludedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedPaths", ConditionKey.CK_LESS_THAN, excludedPaths); + RangeQueryBuilder builder = regRangeQ("excludedPaths", ConditionKey.CK_LESS_THAN, excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setExcludedPaths_GreaterEqual(String excludedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedPaths", ConditionKey.CK_GREATER_EQUAL, excludedPaths); + RangeQueryBuilder builder = regRangeQ("excludedPaths", ConditionKey.CK_GREATER_EQUAL, excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setExcludedPaths_LessEqual(String excludedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedPaths", ConditionKey.CK_LESS_EQUAL, excludedPaths); + RangeQueryBuilder builder = regRangeQ("excludedPaths", ConditionKey.CK_LESS_EQUAL, excludedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -502,7 +503,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +591,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +612,29 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setIncludedPaths_Term(String includedPaths, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("includedPaths", includedPaths); + TermQueryBuilder builder = regTermQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } } public void setIncludedPaths_Terms(Collection includedPathsList) { - setIncludedPaths_MatchPhrasePrefix(includedPathsList, null); + setIncludedPaths_Terms(includedPathsList, null); } - public void setIncludedPaths_MatchPhrasePrefix(Collection includedPathsList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("includedPaths", includedPathsList); + public void setIncludedPaths_Terms(Collection includedPathsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("includedPaths", includedPathsList); if (opLambda != null) { opLambda.callback(builder); } } public void setIncludedPaths_InScope(Collection includedPathsList) { - setIncludedPaths_MatchPhrasePrefix(includedPathsList, null); + setIncludedPaths_Terms(includedPathsList, null); } public void setIncludedPaths_InScope(Collection includedPathsList, ConditionOptionCall opLambda) { - setIncludedPaths_MatchPhrasePrefix(includedPathsList, opLambda); + setIncludedPaths_Terms(includedPathsList, opLambda); } public void setIncludedPaths_Match(String includedPaths) { @@ -641,7 +642,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setIncludedPaths_Match(String includedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("includedPaths", includedPaths); + MatchQueryBuilder builder = regMatchQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setIncludedPaths_MatchPhrase(String includedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("includedPaths", includedPaths); + MatchQueryBuilder builder = regMatchPhraseQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setIncludedPaths_MatchPhrasePrefix(String includedPaths, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("includedPaths", includedPaths); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setIncludedPaths_Fuzzy(String includedPaths, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("includedPaths", includedPaths); + FuzzyQueryBuilder builder = regFuzzyQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setIncludedPaths_Prefix(String includedPaths, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("includedPaths", includedPaths); + PrefixQueryBuilder builder = regPrefixQ("includedPaths", includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setIncludedPaths_GreaterThan(String includedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedPaths", ConditionKey.CK_GREATER_THAN, includedPaths); + RangeQueryBuilder builder = regRangeQ("includedPaths", ConditionKey.CK_GREATER_THAN, includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setIncludedPaths_LessThan(String includedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedPaths", ConditionKey.CK_LESS_THAN, includedPaths); + RangeQueryBuilder builder = regRangeQ("includedPaths", ConditionKey.CK_LESS_THAN, includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +719,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setIncludedPaths_GreaterEqual(String includedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedPaths", ConditionKey.CK_GREATER_EQUAL, includedPaths); + RangeQueryBuilder builder = regRangeQ("includedPaths", ConditionKey.CK_GREATER_EQUAL, includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -729,7 +730,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setIncludedPaths_LessEqual(String includedPaths, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedPaths", ConditionKey.CK_LESS_EQUAL, includedPaths); + RangeQueryBuilder builder = regRangeQ("includedPaths", ConditionKey.CK_LESS_EQUAL, includedPaths); if (opLambda != null) { opLambda.callback(builder); } @@ -750,29 +751,29 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setName_Term(String name, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("name", name); + TermQueryBuilder builder = regTermQ("name", name); if (opLambda != null) { opLambda.callback(builder); } } public void setName_Terms(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } - public void setName_MatchPhrasePrefix(Collection nameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("name", nameList); + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("name", nameList); if (opLambda != null) { opLambda.callback(builder); } } public void setName_InScope(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { - setName_MatchPhrasePrefix(nameList, opLambda); + setName_Terms(nameList, opLambda); } public void setName_Match(String name) { @@ -780,7 +781,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setName_Match(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("name", name); + MatchQueryBuilder builder = regMatchQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setName_MatchPhrase(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("name", name); + MatchQueryBuilder builder = regMatchPhraseQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setName_MatchPhrasePrefix(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setName_Fuzzy(String name, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("name", name); + FuzzyQueryBuilder builder = regFuzzyQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setName_Prefix(String name, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("name", name); + PrefixQueryBuilder builder = regPrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +847,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setName_LessThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +858,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -868,7 +869,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setName_LessEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -889,29 +890,29 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder); + TermQueryBuilder builder = regTermQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_Terms(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } - public void setSortOrder_MatchPhrasePrefix(Collection sortOrderList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList); + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_InScope(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { - setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda); + setSortOrder_Terms(sortOrderList, opLambda); } public void setSortOrder_Match(Integer sortOrder) { @@ -919,7 +920,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +931,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +942,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +953,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder); + FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +964,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +975,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +986,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -996,7 +997,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1017,29 +1018,29 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -1047,7 +1048,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1059,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1070,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1081,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1092,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1103,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1114,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1125,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1135,7 +1136,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1156,29 +1157,29 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -1186,7 +1187,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1197,7 +1198,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1208,7 +1209,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1219,7 +1220,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1230,7 +1231,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1241,7 +1242,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1252,7 +1253,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1263,7 +1264,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1284,29 +1285,29 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setValue_Term(String value, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("value", value); + TermQueryBuilder builder = regTermQ("value", value); if (opLambda != null) { opLambda.callback(builder); } } public void setValue_Terms(Collection valueList) { - setValue_MatchPhrasePrefix(valueList, null); + setValue_Terms(valueList, null); } - public void setValue_MatchPhrasePrefix(Collection valueList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("value", valueList); + public void setValue_Terms(Collection valueList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("value", valueList); if (opLambda != null) { opLambda.callback(builder); } } public void setValue_InScope(Collection valueList) { - setValue_MatchPhrasePrefix(valueList, null); + setValue_Terms(valueList, null); } public void setValue_InScope(Collection valueList, ConditionOptionCall opLambda) { - setValue_MatchPhrasePrefix(valueList, opLambda); + setValue_Terms(valueList, opLambda); } public void setValue_Match(String value) { @@ -1314,7 +1315,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setValue_Match(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("value", value); + MatchQueryBuilder builder = regMatchQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -1325,7 +1326,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setValue_MatchPhrase(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("value", value); + MatchQueryBuilder builder = regMatchPhraseQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -1336,7 +1337,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setValue_MatchPhrasePrefix(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("value", value); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -1347,7 +1348,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setValue_Fuzzy(String value, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("value", value); + FuzzyQueryBuilder builder = regFuzzyQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -1358,7 +1359,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setValue_Prefix(String value, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("value", value); + PrefixQueryBuilder builder = regPrefixQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -1369,7 +1370,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setValue_GreaterThan(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_THAN, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_THAN, value); if (opLambda != null) { opLambda.callback(builder); } @@ -1380,7 +1381,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setValue_LessThan(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_THAN, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_THAN, value); if (opLambda != null) { opLambda.callback(builder); } @@ -1391,7 +1392,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setValue_GreaterEqual(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value); if (opLambda != null) { opLambda.callback(builder); } @@ -1402,7 +1403,7 @@ public abstract class BsLabelTypeCQ extends AbstractConditionQuery { } public void setValue_LessEqual(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_EQUAL, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_EQUAL, value); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsOverlappingHostCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsOverlappingHostCQ.java index c131855a4..e533c1c26 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsOverlappingHostCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsOverlappingHostCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.OverlappingHostCQ; +import org.codelibs.fess.es.cbean.cf.OverlappingHostCF; 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 BsOverlappingHostCQ extends AbstractConditionQuery { return "overlapping_host"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { OverlappingHostCQ query = new OverlappingHostCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + OverlappingHostCF filter = new OverlappingHostCF(); + 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 BsOverlappingHostCQ extends AbstractConditionQuery { OverlappingHostCQ shouldQuery = new OverlappingHostCQ(); OverlappingHostCQ mustNotQuery = new OverlappingHostCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -96,7 +98,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +186,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +207,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -235,7 +237,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +314,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +335,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -363,7 +365,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +376,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +453,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +474,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setOverlappingName_Term(String overlappingName, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("overlappingName", overlappingName); + TermQueryBuilder builder = regTermQ("overlappingName", overlappingName); if (opLambda != null) { opLambda.callback(builder); } } public void setOverlappingName_Terms(Collection overlappingNameList) { - setOverlappingName_MatchPhrasePrefix(overlappingNameList, null); + setOverlappingName_Terms(overlappingNameList, null); } - public void setOverlappingName_MatchPhrasePrefix(Collection overlappingNameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("overlappingName", overlappingNameList); + public void setOverlappingName_Terms(Collection overlappingNameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("overlappingName", overlappingNameList); if (opLambda != null) { opLambda.callback(builder); } } public void setOverlappingName_InScope(Collection overlappingNameList) { - setOverlappingName_MatchPhrasePrefix(overlappingNameList, null); + setOverlappingName_Terms(overlappingNameList, null); } public void setOverlappingName_InScope(Collection overlappingNameList, ConditionOptionCall opLambda) { - setOverlappingName_MatchPhrasePrefix(overlappingNameList, opLambda); + setOverlappingName_Terms(overlappingNameList, opLambda); } public void setOverlappingName_Match(String overlappingName) { @@ -502,7 +504,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setOverlappingName_Match(String overlappingName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("overlappingName", overlappingName); + MatchQueryBuilder builder = regMatchQ("overlappingName", overlappingName); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +515,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setOverlappingName_MatchPhrase(String overlappingName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("overlappingName", overlappingName); + MatchQueryBuilder builder = regMatchPhraseQ("overlappingName", overlappingName); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +526,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setOverlappingName_MatchPhrasePrefix(String overlappingName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("overlappingName", overlappingName); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("overlappingName", overlappingName); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +537,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setOverlappingName_Fuzzy(String overlappingName, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("overlappingName", overlappingName); + FuzzyQueryBuilder builder = regFuzzyQ("overlappingName", overlappingName); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +548,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setOverlappingName_Prefix(String overlappingName, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("overlappingName", overlappingName); + PrefixQueryBuilder builder = regPrefixQ("overlappingName", overlappingName); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +559,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setOverlappingName_GreaterThan(String overlappingName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("overlappingName", ConditionKey.CK_GREATER_THAN, overlappingName); + RangeQueryBuilder builder = regRangeQ("overlappingName", ConditionKey.CK_GREATER_THAN, overlappingName); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +570,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setOverlappingName_LessThan(String overlappingName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("overlappingName", ConditionKey.CK_LESS_THAN, overlappingName); + RangeQueryBuilder builder = regRangeQ("overlappingName", ConditionKey.CK_LESS_THAN, overlappingName); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +581,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setOverlappingName_GreaterEqual(String overlappingName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("overlappingName", ConditionKey.CK_GREATER_EQUAL, overlappingName); + RangeQueryBuilder builder = regRangeQ("overlappingName", ConditionKey.CK_GREATER_EQUAL, overlappingName); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +592,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setOverlappingName_LessEqual(String overlappingName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("overlappingName", ConditionKey.CK_LESS_EQUAL, overlappingName); + RangeQueryBuilder builder = regRangeQ("overlappingName", ConditionKey.CK_LESS_EQUAL, overlappingName); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +613,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setRegularName_Term(String regularName, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("regularName", regularName); + TermQueryBuilder builder = regTermQ("regularName", regularName); if (opLambda != null) { opLambda.callback(builder); } } public void setRegularName_Terms(Collection regularNameList) { - setRegularName_MatchPhrasePrefix(regularNameList, null); + setRegularName_Terms(regularNameList, null); } - public void setRegularName_MatchPhrasePrefix(Collection regularNameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("regularName", regularNameList); + public void setRegularName_Terms(Collection regularNameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("regularName", regularNameList); if (opLambda != null) { opLambda.callback(builder); } } public void setRegularName_InScope(Collection regularNameList) { - setRegularName_MatchPhrasePrefix(regularNameList, null); + setRegularName_Terms(regularNameList, null); } public void setRegularName_InScope(Collection regularNameList, ConditionOptionCall opLambda) { - setRegularName_MatchPhrasePrefix(regularNameList, opLambda); + setRegularName_Terms(regularNameList, opLambda); } public void setRegularName_Match(String regularName) { @@ -641,7 +643,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setRegularName_Match(String regularName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("regularName", regularName); + MatchQueryBuilder builder = regMatchQ("regularName", regularName); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +654,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setRegularName_MatchPhrase(String regularName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("regularName", regularName); + MatchQueryBuilder builder = regMatchPhraseQ("regularName", regularName); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +665,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setRegularName_MatchPhrasePrefix(String regularName, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("regularName", regularName); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("regularName", regularName); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +676,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setRegularName_Fuzzy(String regularName, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("regularName", regularName); + FuzzyQueryBuilder builder = regFuzzyQ("regularName", regularName); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +687,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setRegularName_Prefix(String regularName, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("regularName", regularName); + PrefixQueryBuilder builder = regPrefixQ("regularName", regularName); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +698,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setRegularName_GreaterThan(String regularName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("regularName", ConditionKey.CK_GREATER_THAN, regularName); + RangeQueryBuilder builder = regRangeQ("regularName", ConditionKey.CK_GREATER_THAN, regularName); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +709,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setRegularName_LessThan(String regularName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("regularName", ConditionKey.CK_LESS_THAN, regularName); + RangeQueryBuilder builder = regRangeQ("regularName", ConditionKey.CK_LESS_THAN, regularName); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +720,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setRegularName_GreaterEqual(String regularName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("regularName", ConditionKey.CK_GREATER_EQUAL, regularName); + RangeQueryBuilder builder = regRangeQ("regularName", ConditionKey.CK_GREATER_EQUAL, regularName); if (opLambda != null) { opLambda.callback(builder); } @@ -729,7 +731,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setRegularName_LessEqual(String regularName, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("regularName", ConditionKey.CK_LESS_EQUAL, regularName); + RangeQueryBuilder builder = regRangeQ("regularName", ConditionKey.CK_LESS_EQUAL, regularName); if (opLambda != null) { opLambda.callback(builder); } @@ -750,29 +752,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder); + TermQueryBuilder builder = regTermQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_Terms(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } - public void setSortOrder_MatchPhrasePrefix(Collection sortOrderList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList); + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_InScope(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { - setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda); + setSortOrder_Terms(sortOrderList, opLambda); } public void setSortOrder_Match(Integer sortOrder) { @@ -780,7 +782,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +793,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +804,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +815,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder); + FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +826,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +837,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +848,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +859,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -878,29 +880,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -908,7 +910,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -919,7 +921,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +932,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +943,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +954,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +965,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +976,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +987,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -996,7 +998,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1017,29 +1019,29 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -1047,7 +1049,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1060,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1071,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1082,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1093,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1104,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1115,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1126,7 @@ public abstract class BsOverlappingHostCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsPathMappingCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsPathMappingCQ.java index 1bed756d2..edf83326f 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsPathMappingCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsPathMappingCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.PathMappingCQ; +import org.codelibs.fess.es.cbean.cf.PathMappingCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { return "path_mapping"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { PathMappingCQ query = new PathMappingCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + PathMappingCF filter = new PathMappingCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { PathMappingCQ shouldQuery = new PathMappingCQ(); PathMappingCQ mustNotQuery = new PathMappingCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -96,7 +97,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +185,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +206,29 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -235,7 +236,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -363,7 +364,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setProcessType_Term(String processType, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("processType", processType); + TermQueryBuilder builder = regTermQ("processType", processType); if (opLambda != null) { opLambda.callback(builder); } } public void setProcessType_Terms(Collection processTypeList) { - setProcessType_MatchPhrasePrefix(processTypeList, null); + setProcessType_Terms(processTypeList, null); } - public void setProcessType_MatchPhrasePrefix(Collection processTypeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("processType", processTypeList); + public void setProcessType_Terms(Collection processTypeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("processType", processTypeList); if (opLambda != null) { opLambda.callback(builder); } } public void setProcessType_InScope(Collection processTypeList) { - setProcessType_MatchPhrasePrefix(processTypeList, null); + setProcessType_Terms(processTypeList, null); } public void setProcessType_InScope(Collection processTypeList, ConditionOptionCall opLambda) { - setProcessType_MatchPhrasePrefix(processTypeList, opLambda); + setProcessType_Terms(processTypeList, opLambda); } public void setProcessType_Match(String processType) { @@ -502,7 +503,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setProcessType_Match(String processType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("processType", processType); + MatchQueryBuilder builder = regMatchQ("processType", processType); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setProcessType_MatchPhrase(String processType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("processType", processType); + MatchQueryBuilder builder = regMatchPhraseQ("processType", processType); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setProcessType_MatchPhrasePrefix(String processType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("processType", processType); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("processType", processType); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setProcessType_Fuzzy(String processType, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("processType", processType); + FuzzyQueryBuilder builder = regFuzzyQ("processType", processType); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setProcessType_Prefix(String processType, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("processType", processType); + PrefixQueryBuilder builder = regPrefixQ("processType", processType); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setProcessType_GreaterThan(String processType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("processType", ConditionKey.CK_GREATER_THAN, processType); + RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_GREATER_THAN, processType); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setProcessType_LessThan(String processType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("processType", ConditionKey.CK_LESS_THAN, processType); + RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_LESS_THAN, processType); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setProcessType_GreaterEqual(String processType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("processType", ConditionKey.CK_GREATER_EQUAL, processType); + RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_GREATER_EQUAL, processType); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +591,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setProcessType_LessEqual(String processType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("processType", ConditionKey.CK_LESS_EQUAL, processType); + RangeQueryBuilder builder = regRangeQ("processType", ConditionKey.CK_LESS_EQUAL, processType); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +612,29 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setRegex_Term(String regex, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("regex", regex); + TermQueryBuilder builder = regTermQ("regex", regex); if (opLambda != null) { opLambda.callback(builder); } } public void setRegex_Terms(Collection regexList) { - setRegex_MatchPhrasePrefix(regexList, null); + setRegex_Terms(regexList, null); } - public void setRegex_MatchPhrasePrefix(Collection regexList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("regex", regexList); + public void setRegex_Terms(Collection regexList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("regex", regexList); if (opLambda != null) { opLambda.callback(builder); } } public void setRegex_InScope(Collection regexList) { - setRegex_MatchPhrasePrefix(regexList, null); + setRegex_Terms(regexList, null); } public void setRegex_InScope(Collection regexList, ConditionOptionCall opLambda) { - setRegex_MatchPhrasePrefix(regexList, opLambda); + setRegex_Terms(regexList, opLambda); } public void setRegex_Match(String regex) { @@ -641,7 +642,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setRegex_Match(String regex, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("regex", regex); + MatchQueryBuilder builder = regMatchQ("regex", regex); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setRegex_MatchPhrase(String regex, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("regex", regex); + MatchQueryBuilder builder = regMatchPhraseQ("regex", regex); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setRegex_MatchPhrasePrefix(String regex, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("regex", regex); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("regex", regex); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setRegex_Fuzzy(String regex, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("regex", regex); + FuzzyQueryBuilder builder = regFuzzyQ("regex", regex); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setRegex_Prefix(String regex, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("regex", regex); + PrefixQueryBuilder builder = regPrefixQ("regex", regex); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setRegex_GreaterThan(String regex, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("regex", ConditionKey.CK_GREATER_THAN, regex); + RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_GREATER_THAN, regex); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setRegex_LessThan(String regex, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("regex", ConditionKey.CK_LESS_THAN, regex); + RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_LESS_THAN, regex); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +719,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setRegex_GreaterEqual(String regex, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("regex", ConditionKey.CK_GREATER_EQUAL, regex); + RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_GREATER_EQUAL, regex); if (opLambda != null) { opLambda.callback(builder); } @@ -729,7 +730,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setRegex_LessEqual(String regex, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("regex", ConditionKey.CK_LESS_EQUAL, regex); + RangeQueryBuilder builder = regRangeQ("regex", ConditionKey.CK_LESS_EQUAL, regex); if (opLambda != null) { opLambda.callback(builder); } @@ -750,29 +751,29 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setReplacement_Term(String replacement, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("replacement", replacement); + TermQueryBuilder builder = regTermQ("replacement", replacement); if (opLambda != null) { opLambda.callback(builder); } } public void setReplacement_Terms(Collection replacementList) { - setReplacement_MatchPhrasePrefix(replacementList, null); + setReplacement_Terms(replacementList, null); } - public void setReplacement_MatchPhrasePrefix(Collection replacementList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("replacement", replacementList); + public void setReplacement_Terms(Collection replacementList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("replacement", replacementList); if (opLambda != null) { opLambda.callback(builder); } } public void setReplacement_InScope(Collection replacementList) { - setReplacement_MatchPhrasePrefix(replacementList, null); + setReplacement_Terms(replacementList, null); } public void setReplacement_InScope(Collection replacementList, ConditionOptionCall opLambda) { - setReplacement_MatchPhrasePrefix(replacementList, opLambda); + setReplacement_Terms(replacementList, opLambda); } public void setReplacement_Match(String replacement) { @@ -780,7 +781,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setReplacement_Match(String replacement, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("replacement", replacement); + MatchQueryBuilder builder = regMatchQ("replacement", replacement); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setReplacement_MatchPhrase(String replacement, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("replacement", replacement); + MatchQueryBuilder builder = regMatchPhraseQ("replacement", replacement); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setReplacement_MatchPhrasePrefix(String replacement, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("replacement", replacement); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("replacement", replacement); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setReplacement_Fuzzy(String replacement, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("replacement", replacement); + FuzzyQueryBuilder builder = regFuzzyQ("replacement", replacement); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setReplacement_Prefix(String replacement, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("replacement", replacement); + PrefixQueryBuilder builder = regPrefixQ("replacement", replacement); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setReplacement_GreaterThan(String replacement, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("replacement", ConditionKey.CK_GREATER_THAN, replacement); + RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_GREATER_THAN, replacement); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +847,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setReplacement_LessThan(String replacement, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("replacement", ConditionKey.CK_LESS_THAN, replacement); + RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_LESS_THAN, replacement); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +858,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setReplacement_GreaterEqual(String replacement, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("replacement", ConditionKey.CK_GREATER_EQUAL, replacement); + RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_GREATER_EQUAL, replacement); if (opLambda != null) { opLambda.callback(builder); } @@ -868,7 +869,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setReplacement_LessEqual(String replacement, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("replacement", ConditionKey.CK_LESS_EQUAL, replacement); + RangeQueryBuilder builder = regRangeQ("replacement", ConditionKey.CK_LESS_EQUAL, replacement); if (opLambda != null) { opLambda.callback(builder); } @@ -889,29 +890,29 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder); + TermQueryBuilder builder = regTermQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_Terms(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } - public void setSortOrder_MatchPhrasePrefix(Collection sortOrderList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList); + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_InScope(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { - setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda); + setSortOrder_Terms(sortOrderList, opLambda); } public void setSortOrder_Match(Integer sortOrder) { @@ -919,7 +920,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +931,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +942,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +953,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder); + FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +964,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +975,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +986,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -996,7 +997,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1017,29 +1018,29 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -1047,7 +1048,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1059,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1070,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1081,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1092,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1103,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1114,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1125,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1135,7 +1136,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1156,29 +1157,29 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -1186,7 +1187,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1197,7 +1198,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1208,7 +1209,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1219,7 +1220,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1230,7 +1231,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1241,7 +1242,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1252,7 +1253,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1263,7 +1264,7 @@ public abstract class BsPathMappingCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsRequestHeaderCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsRequestHeaderCQ.java index a07921310..48b5af56a 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsRequestHeaderCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsRequestHeaderCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.RequestHeaderCQ; +import org.codelibs.fess.es.cbean.cf.RequestHeaderCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { return "request_header"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { RequestHeaderCQ query = new RequestHeaderCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + RequestHeaderCF filter = new RequestHeaderCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { RequestHeaderCQ shouldQuery = new RequestHeaderCQ(); RequestHeaderCQ mustNotQuery = new RequestHeaderCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -96,7 +97,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +185,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +206,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -235,7 +236,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -363,7 +364,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setName_Term(String name, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("name", name); + TermQueryBuilder builder = regTermQ("name", name); if (opLambda != null) { opLambda.callback(builder); } } public void setName_Terms(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } - public void setName_MatchPhrasePrefix(Collection nameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("name", nameList); + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("name", nameList); if (opLambda != null) { opLambda.callback(builder); } } public void setName_InScope(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { - setName_MatchPhrasePrefix(nameList, opLambda); + setName_Terms(nameList, opLambda); } public void setName_Match(String name) { @@ -502,7 +503,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setName_Match(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("name", name); + MatchQueryBuilder builder = regMatchQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setName_MatchPhrase(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("name", name); + MatchQueryBuilder builder = regMatchPhraseQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setName_MatchPhrasePrefix(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setName_Fuzzy(String name, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("name", name); + FuzzyQueryBuilder builder = regFuzzyQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setName_Prefix(String name, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("name", name); + PrefixQueryBuilder builder = regPrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setName_LessThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +591,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setName_LessEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +612,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -641,7 +642,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +719,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -729,7 +730,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -750,29 +751,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -780,7 +781,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +847,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +858,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -878,29 +879,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setValue_Term(String value, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("value", value); + TermQueryBuilder builder = regTermQ("value", value); if (opLambda != null) { opLambda.callback(builder); } } public void setValue_Terms(Collection valueList) { - setValue_MatchPhrasePrefix(valueList, null); + setValue_Terms(valueList, null); } - public void setValue_MatchPhrasePrefix(Collection valueList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("value", valueList); + public void setValue_Terms(Collection valueList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("value", valueList); if (opLambda != null) { opLambda.callback(builder); } } public void setValue_InScope(Collection valueList) { - setValue_MatchPhrasePrefix(valueList, null); + setValue_Terms(valueList, null); } public void setValue_InScope(Collection valueList, ConditionOptionCall opLambda) { - setValue_MatchPhrasePrefix(valueList, opLambda); + setValue_Terms(valueList, opLambda); } public void setValue_Match(String value) { @@ -908,7 +909,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setValue_Match(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("value", value); + MatchQueryBuilder builder = regMatchQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -919,7 +920,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setValue_MatchPhrase(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("value", value); + MatchQueryBuilder builder = regMatchPhraseQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +931,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setValue_MatchPhrasePrefix(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("value", value); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +942,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setValue_Fuzzy(String value, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("value", value); + FuzzyQueryBuilder builder = regFuzzyQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +953,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setValue_Prefix(String value, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("value", value); + PrefixQueryBuilder builder = regPrefixQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +964,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setValue_GreaterThan(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_THAN, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_THAN, value); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +975,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setValue_LessThan(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_THAN, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_THAN, value); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +986,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setValue_GreaterEqual(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value); if (opLambda != null) { opLambda.callback(builder); } @@ -996,7 +997,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setValue_LessEqual(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_EQUAL, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_EQUAL, value); if (opLambda != null) { opLambda.callback(builder); } @@ -1017,29 +1018,29 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setWebConfigId_Term(String webConfigId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("webConfigId", webConfigId); + TermQueryBuilder builder = regTermQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } } public void setWebConfigId_Terms(Collection webConfigIdList) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, null); + setWebConfigId_Terms(webConfigIdList, null); } - public void setWebConfigId_MatchPhrasePrefix(Collection webConfigIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("webConfigId", webConfigIdList); + public void setWebConfigId_Terms(Collection webConfigIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("webConfigId", webConfigIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setWebConfigId_InScope(Collection webConfigIdList) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, null); + setWebConfigId_Terms(webConfigIdList, null); } public void setWebConfigId_InScope(Collection webConfigIdList, ConditionOptionCall opLambda) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, opLambda); + setWebConfigId_Terms(webConfigIdList, opLambda); } public void setWebConfigId_Match(String webConfigId) { @@ -1047,7 +1048,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setWebConfigId_Match(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1059,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setWebConfigId_MatchPhrase(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchPhraseQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1070,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setWebConfigId_MatchPhrasePrefix(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1081,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setWebConfigId_Fuzzy(String webConfigId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("webConfigId", webConfigId); + FuzzyQueryBuilder builder = regFuzzyQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1092,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("webConfigId", webConfigId); + PrefixQueryBuilder builder = regPrefixQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1103,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1114,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1125,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1135,7 +1136,7 @@ public abstract class BsRequestHeaderCQ extends AbstractConditionQuery { } public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsRoleTypeCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsRoleTypeCQ.java index 685ead027..8c49efe43 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsRoleTypeCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsRoleTypeCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.RoleTypeCQ; +import org.codelibs.fess.es.cbean.cf.RoleTypeCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { return "role_type"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { RoleTypeCQ query = new RoleTypeCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + RoleTypeCF filter = new RoleTypeCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { RoleTypeCQ shouldQuery = new RoleTypeCQ(); RoleTypeCQ mustNotQuery = new RoleTypeCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -96,7 +97,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +185,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +206,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -235,7 +236,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -363,7 +364,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setName_Term(String name, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("name", name); + TermQueryBuilder builder = regTermQ("name", name); if (opLambda != null) { opLambda.callback(builder); } } public void setName_Terms(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } - public void setName_MatchPhrasePrefix(Collection nameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("name", nameList); + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("name", nameList); if (opLambda != null) { opLambda.callback(builder); } } public void setName_InScope(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { - setName_MatchPhrasePrefix(nameList, opLambda); + setName_Terms(nameList, opLambda); } public void setName_Match(String name) { @@ -502,7 +503,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setName_Match(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("name", name); + MatchQueryBuilder builder = regMatchQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setName_MatchPhrase(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("name", name); + MatchQueryBuilder builder = regMatchPhraseQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setName_MatchPhrasePrefix(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setName_Fuzzy(String name, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("name", name); + FuzzyQueryBuilder builder = regFuzzyQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setName_Prefix(String name, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("name", name); + PrefixQueryBuilder builder = regPrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setName_LessThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +591,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setName_LessEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +612,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder); + TermQueryBuilder builder = regTermQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_Terms(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } - public void setSortOrder_MatchPhrasePrefix(Collection sortOrderList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList); + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_InScope(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { - setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda); + setSortOrder_Terms(sortOrderList, opLambda); } public void setSortOrder_Match(Integer sortOrder) { @@ -641,7 +642,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder); + FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +719,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -739,29 +740,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -769,7 +770,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -780,7 +781,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +847,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +858,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -878,29 +879,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -908,7 +909,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -919,7 +920,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +931,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +942,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +953,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +964,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +975,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +986,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1006,29 +1007,29 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setValue_Term(String value, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("value", value); + TermQueryBuilder builder = regTermQ("value", value); if (opLambda != null) { opLambda.callback(builder); } } public void setValue_Terms(Collection valueList) { - setValue_MatchPhrasePrefix(valueList, null); + setValue_Terms(valueList, null); } - public void setValue_MatchPhrasePrefix(Collection valueList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("value", valueList); + public void setValue_Terms(Collection valueList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("value", valueList); if (opLambda != null) { opLambda.callback(builder); } } public void setValue_InScope(Collection valueList) { - setValue_MatchPhrasePrefix(valueList, null); + setValue_Terms(valueList, null); } public void setValue_InScope(Collection valueList, ConditionOptionCall opLambda) { - setValue_MatchPhrasePrefix(valueList, opLambda); + setValue_Terms(valueList, opLambda); } public void setValue_Match(String value) { @@ -1036,7 +1037,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setValue_Match(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("value", value); + MatchQueryBuilder builder = regMatchQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -1047,7 +1048,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setValue_MatchPhrase(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("value", value); + MatchQueryBuilder builder = regMatchPhraseQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1059,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setValue_MatchPhrasePrefix(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("value", value); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1070,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setValue_Fuzzy(String value, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("value", value); + FuzzyQueryBuilder builder = regFuzzyQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1081,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setValue_Prefix(String value, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("value", value); + PrefixQueryBuilder builder = regPrefixQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1092,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setValue_GreaterThan(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_THAN, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_THAN, value); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1103,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setValue_LessThan(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_THAN, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_THAN, value); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1114,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setValue_GreaterEqual(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1125,7 @@ public abstract class BsRoleTypeCQ extends AbstractConditionQuery { } public void setValue_LessEqual(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_EQUAL, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_EQUAL, value); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsScheduledJobCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsScheduledJobCQ.java index 009497c7f..1c7694773 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsScheduledJobCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsScheduledJobCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.ScheduledJobCQ; +import org.codelibs.fess.es.cbean.cf.ScheduledJobCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { return "scheduled_job"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { ScheduledJobCQ query = new ScheduledJobCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + ScheduledJobCF filter = new ScheduledJobCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { ScheduledJobCQ shouldQuery = new ScheduledJobCQ(); ScheduledJobCQ mustNotQuery = new ScheduledJobCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setAvailable_Term(Boolean available, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("available", available); + TermQueryBuilder builder = regTermQ("available", available); if (opLambda != null) { opLambda.callback(builder); } } public void setAvailable_Terms(Collection availableList) { - setAvailable_MatchPhrasePrefix(availableList, null); + setAvailable_Terms(availableList, null); } - public void setAvailable_MatchPhrasePrefix(Collection availableList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("available", availableList); + public void setAvailable_Terms(Collection availableList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("available", availableList); if (opLambda != null) { opLambda.callback(builder); } } public void setAvailable_InScope(Collection availableList) { - setAvailable_MatchPhrasePrefix(availableList, null); + setAvailable_Terms(availableList, null); } public void setAvailable_InScope(Collection availableList, ConditionOptionCall opLambda) { - setAvailable_MatchPhrasePrefix(availableList, opLambda); + setAvailable_Terms(availableList, opLambda); } public void setAvailable_Match(Boolean available) { @@ -96,7 +97,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setAvailable_Match(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("available", available); + MatchQueryBuilder builder = regMatchQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setAvailable_MatchPhrase(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("available", available); + MatchQueryBuilder builder = regMatchPhraseQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setAvailable_MatchPhrasePrefix(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("available", available); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setAvailable_Fuzzy(Boolean available, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("available", available); + FuzzyQueryBuilder builder = regFuzzyQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_GREATER_THAN, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_GREATER_THAN, available); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setAvailable_LessThan(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_LESS_THAN, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_LESS_THAN, available); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_GREATER_EQUAL, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_GREATER_EQUAL, available); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setAvailable_LessEqual(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_LESS_EQUAL, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_LESS_EQUAL, available); if (opLambda != null) { opLambda.callback(builder); } @@ -194,29 +195,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCrawler_Term(String crawler, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("crawler", crawler); + TermQueryBuilder builder = regTermQ("crawler", crawler); if (opLambda != null) { opLambda.callback(builder); } } public void setCrawler_Terms(Collection crawlerList) { - setCrawler_MatchPhrasePrefix(crawlerList, null); + setCrawler_Terms(crawlerList, null); } - public void setCrawler_MatchPhrasePrefix(Collection crawlerList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("crawler", crawlerList); + public void setCrawler_Terms(Collection crawlerList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("crawler", crawlerList); if (opLambda != null) { opLambda.callback(builder); } } public void setCrawler_InScope(Collection crawlerList) { - setCrawler_MatchPhrasePrefix(crawlerList, null); + setCrawler_Terms(crawlerList, null); } public void setCrawler_InScope(Collection crawlerList, ConditionOptionCall opLambda) { - setCrawler_MatchPhrasePrefix(crawlerList, opLambda); + setCrawler_Terms(crawlerList, opLambda); } public void setCrawler_Match(String crawler) { @@ -224,7 +225,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCrawler_Match(String crawler, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("crawler", crawler); + MatchQueryBuilder builder = regMatchQ("crawler", crawler); if (opLambda != null) { opLambda.callback(builder); } @@ -235,7 +236,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCrawler_MatchPhrase(String crawler, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("crawler", crawler); + MatchQueryBuilder builder = regMatchPhraseQ("crawler", crawler); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCrawler_MatchPhrasePrefix(String crawler, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("crawler", crawler); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("crawler", crawler); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCrawler_Fuzzy(String crawler, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("crawler", crawler); + FuzzyQueryBuilder builder = regFuzzyQ("crawler", crawler); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCrawler_Prefix(String crawler, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("crawler", crawler); + PrefixQueryBuilder builder = regPrefixQ("crawler", crawler); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCrawler_GreaterThan(String crawler, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("crawler", ConditionKey.CK_GREATER_THAN, crawler); + RangeQueryBuilder builder = regRangeQ("crawler", ConditionKey.CK_GREATER_THAN, crawler); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCrawler_LessThan(String crawler, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("crawler", ConditionKey.CK_LESS_THAN, crawler); + RangeQueryBuilder builder = regRangeQ("crawler", ConditionKey.CK_LESS_THAN, crawler); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCrawler_GreaterEqual(String crawler, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("crawler", ConditionKey.CK_GREATER_EQUAL, crawler); + RangeQueryBuilder builder = regRangeQ("crawler", ConditionKey.CK_GREATER_EQUAL, crawler); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCrawler_LessEqual(String crawler, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("crawler", ConditionKey.CK_LESS_EQUAL, crawler); + RangeQueryBuilder builder = regRangeQ("crawler", ConditionKey.CK_LESS_EQUAL, crawler); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -363,7 +364,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -502,7 +503,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -600,29 +601,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCronExpression_Term(String cronExpression, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("cronExpression", cronExpression); + TermQueryBuilder builder = regTermQ("cronExpression", cronExpression); if (opLambda != null) { opLambda.callback(builder); } } public void setCronExpression_Terms(Collection cronExpressionList) { - setCronExpression_MatchPhrasePrefix(cronExpressionList, null); + setCronExpression_Terms(cronExpressionList, null); } - public void setCronExpression_MatchPhrasePrefix(Collection cronExpressionList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("cronExpression", cronExpressionList); + public void setCronExpression_Terms(Collection cronExpressionList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("cronExpression", cronExpressionList); if (opLambda != null) { opLambda.callback(builder); } } public void setCronExpression_InScope(Collection cronExpressionList) { - setCronExpression_MatchPhrasePrefix(cronExpressionList, null); + setCronExpression_Terms(cronExpressionList, null); } public void setCronExpression_InScope(Collection cronExpressionList, ConditionOptionCall opLambda) { - setCronExpression_MatchPhrasePrefix(cronExpressionList, opLambda); + setCronExpression_Terms(cronExpressionList, opLambda); } public void setCronExpression_Match(String cronExpression) { @@ -630,7 +631,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCronExpression_Match(String cronExpression, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("cronExpression", cronExpression); + MatchQueryBuilder builder = regMatchQ("cronExpression", cronExpression); if (opLambda != null) { opLambda.callback(builder); } @@ -641,7 +642,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCronExpression_MatchPhrase(String cronExpression, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("cronExpression", cronExpression); + MatchQueryBuilder builder = regMatchPhraseQ("cronExpression", cronExpression); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCronExpression_MatchPhrasePrefix(String cronExpression, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("cronExpression", cronExpression); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("cronExpression", cronExpression); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCronExpression_Fuzzy(String cronExpression, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("cronExpression", cronExpression); + FuzzyQueryBuilder builder = regFuzzyQ("cronExpression", cronExpression); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCronExpression_Prefix(String cronExpression, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("cronExpression", cronExpression); + PrefixQueryBuilder builder = regPrefixQ("cronExpression", cronExpression); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCronExpression_GreaterThan(String cronExpression, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("cronExpression", ConditionKey.CK_GREATER_THAN, cronExpression); + RangeQueryBuilder builder = regRangeQ("cronExpression", ConditionKey.CK_GREATER_THAN, cronExpression); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCronExpression_LessThan(String cronExpression, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("cronExpression", ConditionKey.CK_LESS_THAN, cronExpression); + RangeQueryBuilder builder = regRangeQ("cronExpression", ConditionKey.CK_LESS_THAN, cronExpression); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCronExpression_GreaterEqual(String cronExpression, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("cronExpression", ConditionKey.CK_GREATER_EQUAL, cronExpression); + RangeQueryBuilder builder = regRangeQ("cronExpression", ConditionKey.CK_GREATER_EQUAL, cronExpression); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +719,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setCronExpression_LessEqual(String cronExpression, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("cronExpression", ConditionKey.CK_LESS_EQUAL, cronExpression); + RangeQueryBuilder builder = regRangeQ("cronExpression", ConditionKey.CK_LESS_EQUAL, cronExpression); if (opLambda != null) { opLambda.callback(builder); } @@ -739,29 +740,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -769,7 +770,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -780,7 +781,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +847,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +858,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -878,29 +879,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setJobLogging_Term(Boolean jobLogging, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("jobLogging", jobLogging); + TermQueryBuilder builder = regTermQ("jobLogging", jobLogging); if (opLambda != null) { opLambda.callback(builder); } } public void setJobLogging_Terms(Collection jobLoggingList) { - setJobLogging_MatchPhrasePrefix(jobLoggingList, null); + setJobLogging_Terms(jobLoggingList, null); } - public void setJobLogging_MatchPhrasePrefix(Collection jobLoggingList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("jobLogging", jobLoggingList); + public void setJobLogging_Terms(Collection jobLoggingList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("jobLogging", jobLoggingList); if (opLambda != null) { opLambda.callback(builder); } } public void setJobLogging_InScope(Collection jobLoggingList) { - setJobLogging_MatchPhrasePrefix(jobLoggingList, null); + setJobLogging_Terms(jobLoggingList, null); } public void setJobLogging_InScope(Collection jobLoggingList, ConditionOptionCall opLambda) { - setJobLogging_MatchPhrasePrefix(jobLoggingList, opLambda); + setJobLogging_Terms(jobLoggingList, opLambda); } public void setJobLogging_Match(Boolean jobLogging) { @@ -908,7 +909,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setJobLogging_Match(Boolean jobLogging, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("jobLogging", jobLogging); + MatchQueryBuilder builder = regMatchQ("jobLogging", jobLogging); if (opLambda != null) { opLambda.callback(builder); } @@ -919,7 +920,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setJobLogging_MatchPhrase(Boolean jobLogging, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("jobLogging", jobLogging); + MatchQueryBuilder builder = regMatchPhraseQ("jobLogging", jobLogging); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +931,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setJobLogging_MatchPhrasePrefix(Boolean jobLogging, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("jobLogging", jobLogging); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("jobLogging", jobLogging); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +942,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setJobLogging_Fuzzy(Boolean jobLogging, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("jobLogging", jobLogging); + FuzzyQueryBuilder builder = regFuzzyQ("jobLogging", jobLogging); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +953,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setJobLogging_GreaterThan(Boolean jobLogging, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobLogging", ConditionKey.CK_GREATER_THAN, jobLogging); + RangeQueryBuilder builder = regRangeQ("jobLogging", ConditionKey.CK_GREATER_THAN, jobLogging); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +964,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setJobLogging_LessThan(Boolean jobLogging, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobLogging", ConditionKey.CK_LESS_THAN, jobLogging); + RangeQueryBuilder builder = regRangeQ("jobLogging", ConditionKey.CK_LESS_THAN, jobLogging); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +975,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setJobLogging_GreaterEqual(Boolean jobLogging, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobLogging", ConditionKey.CK_GREATER_EQUAL, jobLogging); + RangeQueryBuilder builder = regRangeQ("jobLogging", ConditionKey.CK_GREATER_EQUAL, jobLogging); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +986,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setJobLogging_LessEqual(Boolean jobLogging, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("jobLogging", ConditionKey.CK_LESS_EQUAL, jobLogging); + RangeQueryBuilder builder = regRangeQ("jobLogging", ConditionKey.CK_LESS_EQUAL, jobLogging); if (opLambda != null) { opLambda.callback(builder); } @@ -1006,29 +1007,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setName_Term(String name, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("name", name); + TermQueryBuilder builder = regTermQ("name", name); if (opLambda != null) { opLambda.callback(builder); } } public void setName_Terms(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } - public void setName_MatchPhrasePrefix(Collection nameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("name", nameList); + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("name", nameList); if (opLambda != null) { opLambda.callback(builder); } } public void setName_InScope(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { - setName_MatchPhrasePrefix(nameList, opLambda); + setName_Terms(nameList, opLambda); } public void setName_Match(String name) { @@ -1036,7 +1037,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setName_Match(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("name", name); + MatchQueryBuilder builder = regMatchQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1047,7 +1048,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setName_MatchPhrase(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("name", name); + MatchQueryBuilder builder = regMatchPhraseQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1059,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setName_MatchPhrasePrefix(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1070,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setName_Fuzzy(String name, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("name", name); + FuzzyQueryBuilder builder = regFuzzyQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1081,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setName_Prefix(String name, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("name", name); + PrefixQueryBuilder builder = regPrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1092,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1103,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setName_LessThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1114,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1125,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setName_LessEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1145,29 +1146,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptData_Term(String scriptData, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("scriptData", scriptData); + TermQueryBuilder builder = regTermQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } } public void setScriptData_Terms(Collection scriptDataList) { - setScriptData_MatchPhrasePrefix(scriptDataList, null); + setScriptData_Terms(scriptDataList, null); } - public void setScriptData_MatchPhrasePrefix(Collection scriptDataList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("scriptData", scriptDataList); + public void setScriptData_Terms(Collection scriptDataList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("scriptData", scriptDataList); if (opLambda != null) { opLambda.callback(builder); } } public void setScriptData_InScope(Collection scriptDataList) { - setScriptData_MatchPhrasePrefix(scriptDataList, null); + setScriptData_Terms(scriptDataList, null); } public void setScriptData_InScope(Collection scriptDataList, ConditionOptionCall opLambda) { - setScriptData_MatchPhrasePrefix(scriptDataList, opLambda); + setScriptData_Terms(scriptDataList, opLambda); } public void setScriptData_Match(String scriptData) { @@ -1175,7 +1176,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptData_Match(String scriptData, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("scriptData", scriptData); + MatchQueryBuilder builder = regMatchQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -1186,7 +1187,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptData_MatchPhrase(String scriptData, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("scriptData", scriptData); + MatchQueryBuilder builder = regMatchPhraseQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -1197,7 +1198,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptData_MatchPhrasePrefix(String scriptData, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("scriptData", scriptData); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -1208,7 +1209,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptData_Fuzzy(String scriptData, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("scriptData", scriptData); + FuzzyQueryBuilder builder = regFuzzyQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -1219,7 +1220,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptData_Prefix(String scriptData, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("scriptData", scriptData); + PrefixQueryBuilder builder = regPrefixQ("scriptData", scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -1230,7 +1231,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptData_GreaterThan(String scriptData, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_GREATER_THAN, scriptData); + RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_GREATER_THAN, scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -1241,7 +1242,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptData_LessThan(String scriptData, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_LESS_THAN, scriptData); + RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_LESS_THAN, scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -1252,7 +1253,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptData_GreaterEqual(String scriptData, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_GREATER_EQUAL, scriptData); + RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_GREATER_EQUAL, scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -1263,7 +1264,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptData_LessEqual(String scriptData, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptData", ConditionKey.CK_LESS_EQUAL, scriptData); + RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_LESS_EQUAL, scriptData); if (opLambda != null) { opLambda.callback(builder); } @@ -1284,29 +1285,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptType_Term(String scriptType, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("scriptType", scriptType); + TermQueryBuilder builder = regTermQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } } public void setScriptType_Terms(Collection scriptTypeList) { - setScriptType_MatchPhrasePrefix(scriptTypeList, null); + setScriptType_Terms(scriptTypeList, null); } - public void setScriptType_MatchPhrasePrefix(Collection scriptTypeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("scriptType", scriptTypeList); + public void setScriptType_Terms(Collection scriptTypeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("scriptType", scriptTypeList); if (opLambda != null) { opLambda.callback(builder); } } public void setScriptType_InScope(Collection scriptTypeList) { - setScriptType_MatchPhrasePrefix(scriptTypeList, null); + setScriptType_Terms(scriptTypeList, null); } public void setScriptType_InScope(Collection scriptTypeList, ConditionOptionCall opLambda) { - setScriptType_MatchPhrasePrefix(scriptTypeList, opLambda); + setScriptType_Terms(scriptTypeList, opLambda); } public void setScriptType_Match(String scriptType) { @@ -1314,7 +1315,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptType_Match(String scriptType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("scriptType", scriptType); + MatchQueryBuilder builder = regMatchQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -1325,7 +1326,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptType_MatchPhrase(String scriptType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("scriptType", scriptType); + MatchQueryBuilder builder = regMatchPhraseQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -1336,7 +1337,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptType_MatchPhrasePrefix(String scriptType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("scriptType", scriptType); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -1347,7 +1348,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptType_Fuzzy(String scriptType, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("scriptType", scriptType); + FuzzyQueryBuilder builder = regFuzzyQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -1358,7 +1359,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptType_Prefix(String scriptType, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("scriptType", scriptType); + PrefixQueryBuilder builder = regPrefixQ("scriptType", scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -1369,7 +1370,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptType_GreaterThan(String scriptType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_GREATER_THAN, scriptType); + RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_GREATER_THAN, scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -1380,7 +1381,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptType_LessThan(String scriptType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_LESS_THAN, scriptType); + RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_LESS_THAN, scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -1391,7 +1392,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptType_GreaterEqual(String scriptType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_GREATER_EQUAL, scriptType); + RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_GREATER_EQUAL, scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -1402,7 +1403,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setScriptType_LessEqual(String scriptType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("scriptType", ConditionKey.CK_LESS_EQUAL, scriptType); + RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_LESS_EQUAL, scriptType); if (opLambda != null) { opLambda.callback(builder); } @@ -1423,29 +1424,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder); + TermQueryBuilder builder = regTermQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_Terms(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } - public void setSortOrder_MatchPhrasePrefix(Collection sortOrderList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList); + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_InScope(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { - setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda); + setSortOrder_Terms(sortOrderList, opLambda); } public void setSortOrder_Match(Integer sortOrder) { @@ -1453,7 +1454,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1464,7 +1465,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1475,7 +1476,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1486,7 +1487,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder); + FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1497,7 +1498,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1508,7 +1509,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1519,7 +1520,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1530,7 +1531,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -1551,29 +1552,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setTarget_Term(String target, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("target", target); + TermQueryBuilder builder = regTermQ("target", target); if (opLambda != null) { opLambda.callback(builder); } } public void setTarget_Terms(Collection targetList) { - setTarget_MatchPhrasePrefix(targetList, null); + setTarget_Terms(targetList, null); } - public void setTarget_MatchPhrasePrefix(Collection targetList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("target", targetList); + public void setTarget_Terms(Collection targetList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("target", targetList); if (opLambda != null) { opLambda.callback(builder); } } public void setTarget_InScope(Collection targetList) { - setTarget_MatchPhrasePrefix(targetList, null); + setTarget_Terms(targetList, null); } public void setTarget_InScope(Collection targetList, ConditionOptionCall opLambda) { - setTarget_MatchPhrasePrefix(targetList, opLambda); + setTarget_Terms(targetList, opLambda); } public void setTarget_Match(String target) { @@ -1581,7 +1582,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setTarget_Match(String target, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("target", target); + MatchQueryBuilder builder = regMatchQ("target", target); if (opLambda != null) { opLambda.callback(builder); } @@ -1592,7 +1593,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setTarget_MatchPhrase(String target, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("target", target); + MatchQueryBuilder builder = regMatchPhraseQ("target", target); if (opLambda != null) { opLambda.callback(builder); } @@ -1603,7 +1604,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setTarget_MatchPhrasePrefix(String target, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("target", target); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("target", target); if (opLambda != null) { opLambda.callback(builder); } @@ -1614,7 +1615,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setTarget_Fuzzy(String target, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("target", target); + FuzzyQueryBuilder builder = regFuzzyQ("target", target); if (opLambda != null) { opLambda.callback(builder); } @@ -1625,7 +1626,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setTarget_Prefix(String target, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("target", target); + PrefixQueryBuilder builder = regPrefixQ("target", target); if (opLambda != null) { opLambda.callback(builder); } @@ -1636,7 +1637,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setTarget_GreaterThan(String target, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_GREATER_THAN, target); + RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_GREATER_THAN, target); if (opLambda != null) { opLambda.callback(builder); } @@ -1647,7 +1648,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setTarget_LessThan(String target, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_LESS_THAN, target); + RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_LESS_THAN, target); if (opLambda != null) { opLambda.callback(builder); } @@ -1658,7 +1659,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setTarget_GreaterEqual(String target, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_GREATER_EQUAL, target); + RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_GREATER_EQUAL, target); if (opLambda != null) { opLambda.callback(builder); } @@ -1669,7 +1670,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setTarget_LessEqual(String target, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("target", ConditionKey.CK_LESS_EQUAL, target); + RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_LESS_EQUAL, target); if (opLambda != null) { opLambda.callback(builder); } @@ -1690,29 +1691,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -1720,7 +1721,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1731,7 +1732,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1742,7 +1743,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1753,7 +1754,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1764,7 +1765,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1775,7 +1776,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1786,7 +1787,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1797,7 +1798,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1808,7 +1809,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1829,29 +1830,29 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -1859,7 +1860,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1870,7 +1871,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1881,7 +1882,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1892,7 +1893,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1903,7 +1904,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1914,7 +1915,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1925,7 +1926,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1936,7 +1937,7 @@ public abstract class BsScheduledJobCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSearchFieldLogCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSearchFieldLogCQ.java index 2ce47a786..242c651e2 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSearchFieldLogCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSearchFieldLogCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.SearchFieldLogCQ; +import org.codelibs.fess.es.cbean.cf.SearchFieldLogCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { return "search_field_log"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { SearchFieldLogCQ query = new SearchFieldLogCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + SearchFieldLogCF filter = new SearchFieldLogCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { SearchFieldLogCQ shouldQuery = new SearchFieldLogCQ(); SearchFieldLogCQ mustNotQuery = new SearchFieldLogCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -96,7 +97,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +185,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +206,29 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setName_Term(String name, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("name", name); + TermQueryBuilder builder = regTermQ("name", name); if (opLambda != null) { opLambda.callback(builder); } } public void setName_Terms(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } - public void setName_MatchPhrasePrefix(Collection nameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("name", nameList); + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("name", nameList); if (opLambda != null) { opLambda.callback(builder); } } public void setName_InScope(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { - setName_MatchPhrasePrefix(nameList, opLambda); + setName_Terms(nameList, opLambda); } public void setName_Match(String name) { @@ -235,7 +236,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setName_Match(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("name", name); + MatchQueryBuilder builder = regMatchQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setName_MatchPhrase(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("name", name); + MatchQueryBuilder builder = regMatchPhraseQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setName_MatchPhrasePrefix(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setName_Fuzzy(String name, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("name", name); + FuzzyQueryBuilder builder = regFuzzyQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setName_Prefix(String name, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("name", name); + PrefixQueryBuilder builder = regPrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setName_LessThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -323,7 +324,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setName_LessEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -344,29 +345,29 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setSearchLogId_Term(String searchLogId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("searchLogId", searchLogId); + TermQueryBuilder builder = regTermQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } } public void setSearchLogId_Terms(Collection searchLogIdList) { - setSearchLogId_MatchPhrasePrefix(searchLogIdList, null); + setSearchLogId_Terms(searchLogIdList, null); } - public void setSearchLogId_MatchPhrasePrefix(Collection searchLogIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("searchLogId", searchLogIdList); + public void setSearchLogId_Terms(Collection searchLogIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("searchLogId", searchLogIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setSearchLogId_InScope(Collection searchLogIdList) { - setSearchLogId_MatchPhrasePrefix(searchLogIdList, null); + setSearchLogId_Terms(searchLogIdList, null); } public void setSearchLogId_InScope(Collection searchLogIdList, ConditionOptionCall opLambda) { - setSearchLogId_MatchPhrasePrefix(searchLogIdList, opLambda); + setSearchLogId_Terms(searchLogIdList, opLambda); } public void setSearchLogId_Match(String searchLogId) { @@ -374,7 +375,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setSearchLogId_Match(String searchLogId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("searchLogId", searchLogId); + MatchQueryBuilder builder = regMatchQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setSearchLogId_MatchPhrase(String searchLogId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("searchLogId", searchLogId); + MatchQueryBuilder builder = regMatchPhraseQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setSearchLogId_MatchPhrasePrefix(String searchLogId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("searchLogId", searchLogId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setSearchLogId_Fuzzy(String searchLogId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("searchLogId", searchLogId); + FuzzyQueryBuilder builder = regFuzzyQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setSearchLogId_Prefix(String searchLogId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("searchLogId", searchLogId); + PrefixQueryBuilder builder = regPrefixQ("searchLogId", searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setSearchLogId_GreaterThan(String searchLogId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId); + RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_GREATER_THAN, searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setSearchLogId_LessThan(String searchLogId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId); + RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_LESS_THAN, searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setSearchLogId_GreaterEqual(String searchLogId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId); + RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_GREATER_EQUAL, searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -462,7 +463,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setSearchLogId_LessEqual(String searchLogId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId); + RangeQueryBuilder builder = regRangeQ("searchLogId", ConditionKey.CK_LESS_EQUAL, searchLogId); if (opLambda != null) { opLambda.callback(builder); } @@ -483,29 +484,29 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setValue_Term(String value, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("value", value); + TermQueryBuilder builder = regTermQ("value", value); if (opLambda != null) { opLambda.callback(builder); } } public void setValue_Terms(Collection valueList) { - setValue_MatchPhrasePrefix(valueList, null); + setValue_Terms(valueList, null); } - public void setValue_MatchPhrasePrefix(Collection valueList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("value", valueList); + public void setValue_Terms(Collection valueList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("value", valueList); if (opLambda != null) { opLambda.callback(builder); } } public void setValue_InScope(Collection valueList) { - setValue_MatchPhrasePrefix(valueList, null); + setValue_Terms(valueList, null); } public void setValue_InScope(Collection valueList, ConditionOptionCall opLambda) { - setValue_MatchPhrasePrefix(valueList, opLambda); + setValue_Terms(valueList, opLambda); } public void setValue_Match(String value) { @@ -513,7 +514,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setValue_Match(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("value", value); + MatchQueryBuilder builder = regMatchQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setValue_MatchPhrase(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("value", value); + MatchQueryBuilder builder = regMatchPhraseQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setValue_MatchPhrasePrefix(String value, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("value", value); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setValue_Fuzzy(String value, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("value", value); + FuzzyQueryBuilder builder = regFuzzyQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setValue_Prefix(String value, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("value", value); + PrefixQueryBuilder builder = regPrefixQ("value", value); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setValue_GreaterThan(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_THAN, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_THAN, value); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setValue_LessThan(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_THAN, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_THAN, value); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +591,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setValue_GreaterEqual(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_GREATER_EQUAL, value); if (opLambda != null) { opLambda.callback(builder); } @@ -601,7 +602,7 @@ public abstract class BsSearchFieldLogCQ extends AbstractConditionQuery { } public void setValue_LessEqual(String value, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("value", ConditionKey.CK_LESS_EQUAL, value); + RangeQueryBuilder builder = regRangeQ("value", ConditionKey.CK_LESS_EQUAL, value); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSearchLogCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSearchLogCQ.java index 2b9e21818..0e45a8687 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSearchLogCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSearchLogCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.SearchLogCQ; +import org.codelibs.fess.es.cbean.cf.SearchLogCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { return "search_log"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { SearchLogCQ query = new SearchLogCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + SearchLogCF filter = new SearchLogCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { SearchLogCQ shouldQuery = new SearchLogCQ(); SearchLogCQ mustNotQuery = new SearchLogCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setAccessType_Term(String accessType, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("accessType", accessType); + TermQueryBuilder builder = regTermQ("accessType", accessType); if (opLambda != null) { opLambda.callback(builder); } } public void setAccessType_Terms(Collection accessTypeList) { - setAccessType_MatchPhrasePrefix(accessTypeList, null); + setAccessType_Terms(accessTypeList, null); } - public void setAccessType_MatchPhrasePrefix(Collection accessTypeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("accessType", accessTypeList); + public void setAccessType_Terms(Collection accessTypeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("accessType", accessTypeList); if (opLambda != null) { opLambda.callback(builder); } } public void setAccessType_InScope(Collection accessTypeList) { - setAccessType_MatchPhrasePrefix(accessTypeList, null); + setAccessType_Terms(accessTypeList, null); } public void setAccessType_InScope(Collection accessTypeList, ConditionOptionCall opLambda) { - setAccessType_MatchPhrasePrefix(accessTypeList, opLambda); + setAccessType_Terms(accessTypeList, opLambda); } public void setAccessType_Match(String accessType) { @@ -96,7 +97,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setAccessType_Match(String accessType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("accessType", accessType); + MatchQueryBuilder builder = regMatchQ("accessType", accessType); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setAccessType_MatchPhrase(String accessType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("accessType", accessType); + MatchQueryBuilder builder = regMatchPhraseQ("accessType", accessType); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setAccessType_MatchPhrasePrefix(String accessType, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("accessType", accessType); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("accessType", accessType); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setAccessType_Fuzzy(String accessType, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("accessType", accessType); + FuzzyQueryBuilder builder = regFuzzyQ("accessType", accessType); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setAccessType_Prefix(String accessType, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("accessType", accessType); + PrefixQueryBuilder builder = regPrefixQ("accessType", accessType); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setAccessType_GreaterThan(String accessType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("accessType", ConditionKey.CK_GREATER_THAN, accessType); + RangeQueryBuilder builder = regRangeQ("accessType", ConditionKey.CK_GREATER_THAN, accessType); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setAccessType_LessThan(String accessType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("accessType", ConditionKey.CK_LESS_THAN, accessType); + RangeQueryBuilder builder = regRangeQ("accessType", ConditionKey.CK_LESS_THAN, accessType); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setAccessType_GreaterEqual(String accessType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("accessType", ConditionKey.CK_GREATER_EQUAL, accessType); + RangeQueryBuilder builder = regRangeQ("accessType", ConditionKey.CK_GREATER_EQUAL, accessType); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +185,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setAccessType_LessEqual(String accessType, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("accessType", ConditionKey.CK_LESS_EQUAL, accessType); + RangeQueryBuilder builder = regRangeQ("accessType", ConditionKey.CK_LESS_EQUAL, accessType); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +206,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setClientIp_Term(String clientIp, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("clientIp", clientIp); + TermQueryBuilder builder = regTermQ("clientIp", clientIp); if (opLambda != null) { opLambda.callback(builder); } } public void setClientIp_Terms(Collection clientIpList) { - setClientIp_MatchPhrasePrefix(clientIpList, null); + setClientIp_Terms(clientIpList, null); } - public void setClientIp_MatchPhrasePrefix(Collection clientIpList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("clientIp", clientIpList); + public void setClientIp_Terms(Collection clientIpList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("clientIp", clientIpList); if (opLambda != null) { opLambda.callback(builder); } } public void setClientIp_InScope(Collection clientIpList) { - setClientIp_MatchPhrasePrefix(clientIpList, null); + setClientIp_Terms(clientIpList, null); } public void setClientIp_InScope(Collection clientIpList, ConditionOptionCall opLambda) { - setClientIp_MatchPhrasePrefix(clientIpList, opLambda); + setClientIp_Terms(clientIpList, opLambda); } public void setClientIp_Match(String clientIp) { @@ -235,7 +236,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setClientIp_Match(String clientIp, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("clientIp", clientIp); + MatchQueryBuilder builder = regMatchQ("clientIp", clientIp); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setClientIp_MatchPhrase(String clientIp, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("clientIp", clientIp); + MatchQueryBuilder builder = regMatchPhraseQ("clientIp", clientIp); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setClientIp_MatchPhrasePrefix(String clientIp, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("clientIp", clientIp); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("clientIp", clientIp); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setClientIp_Fuzzy(String clientIp, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("clientIp", clientIp); + FuzzyQueryBuilder builder = regFuzzyQ("clientIp", clientIp); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setClientIp_Prefix(String clientIp, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("clientIp", clientIp); + PrefixQueryBuilder builder = regPrefixQ("clientIp", clientIp); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setClientIp_GreaterThan(String clientIp, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("clientIp", ConditionKey.CK_GREATER_THAN, clientIp); + RangeQueryBuilder builder = regRangeQ("clientIp", ConditionKey.CK_GREATER_THAN, clientIp); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setClientIp_LessThan(String clientIp, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("clientIp", ConditionKey.CK_LESS_THAN, clientIp); + RangeQueryBuilder builder = regRangeQ("clientIp", ConditionKey.CK_LESS_THAN, clientIp); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setClientIp_GreaterEqual(String clientIp, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("clientIp", ConditionKey.CK_GREATER_EQUAL, clientIp); + RangeQueryBuilder builder = regRangeQ("clientIp", ConditionKey.CK_GREATER_EQUAL, clientIp); if (opLambda != null) { opLambda.callback(builder); } @@ -323,7 +324,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setClientIp_LessEqual(String clientIp, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("clientIp", ConditionKey.CK_LESS_EQUAL, clientIp); + RangeQueryBuilder builder = regRangeQ("clientIp", ConditionKey.CK_LESS_EQUAL, clientIp); if (opLambda != null) { opLambda.callback(builder); } @@ -344,29 +345,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setHitCount_Term(Long hitCount, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("hitCount", hitCount); + TermQueryBuilder builder = regTermQ("hitCount", hitCount); if (opLambda != null) { opLambda.callback(builder); } } public void setHitCount_Terms(Collection hitCountList) { - setHitCount_MatchPhrasePrefix(hitCountList, null); + setHitCount_Terms(hitCountList, null); } - public void setHitCount_MatchPhrasePrefix(Collection hitCountList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("hitCount", hitCountList); + public void setHitCount_Terms(Collection hitCountList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("hitCount", hitCountList); if (opLambda != null) { opLambda.callback(builder); } } public void setHitCount_InScope(Collection hitCountList) { - setHitCount_MatchPhrasePrefix(hitCountList, null); + setHitCount_Terms(hitCountList, null); } public void setHitCount_InScope(Collection hitCountList, ConditionOptionCall opLambda) { - setHitCount_MatchPhrasePrefix(hitCountList, opLambda); + setHitCount_Terms(hitCountList, opLambda); } public void setHitCount_Match(Long hitCount) { @@ -374,7 +375,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setHitCount_Match(Long hitCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("hitCount", hitCount); + MatchQueryBuilder builder = regMatchQ("hitCount", hitCount); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setHitCount_MatchPhrase(Long hitCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("hitCount", hitCount); + MatchQueryBuilder builder = regMatchPhraseQ("hitCount", hitCount); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setHitCount_MatchPhrasePrefix(Long hitCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("hitCount", hitCount); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("hitCount", hitCount); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setHitCount_Fuzzy(Long hitCount, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("hitCount", hitCount); + FuzzyQueryBuilder builder = regFuzzyQ("hitCount", hitCount); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setHitCount_GreaterThan(Long hitCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hitCount", ConditionKey.CK_GREATER_THAN, hitCount); + RangeQueryBuilder builder = regRangeQ("hitCount", ConditionKey.CK_GREATER_THAN, hitCount); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setHitCount_LessThan(Long hitCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hitCount", ConditionKey.CK_LESS_THAN, hitCount); + RangeQueryBuilder builder = regRangeQ("hitCount", ConditionKey.CK_LESS_THAN, hitCount); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setHitCount_GreaterEqual(Long hitCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hitCount", ConditionKey.CK_GREATER_EQUAL, hitCount); + RangeQueryBuilder builder = regRangeQ("hitCount", ConditionKey.CK_GREATER_EQUAL, hitCount); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setHitCount_LessEqual(Long hitCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hitCount", ConditionKey.CK_LESS_EQUAL, hitCount); + RangeQueryBuilder builder = regRangeQ("hitCount", ConditionKey.CK_LESS_EQUAL, hitCount); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -502,7 +503,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +591,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +612,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryOffset_Term(Integer queryOffset, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("queryOffset", queryOffset); + TermQueryBuilder builder = regTermQ("queryOffset", queryOffset); if (opLambda != null) { opLambda.callback(builder); } } public void setQueryOffset_Terms(Collection queryOffsetList) { - setQueryOffset_MatchPhrasePrefix(queryOffsetList, null); + setQueryOffset_Terms(queryOffsetList, null); } - public void setQueryOffset_MatchPhrasePrefix(Collection queryOffsetList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("queryOffset", queryOffsetList); + public void setQueryOffset_Terms(Collection queryOffsetList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("queryOffset", queryOffsetList); if (opLambda != null) { opLambda.callback(builder); } } public void setQueryOffset_InScope(Collection queryOffsetList) { - setQueryOffset_MatchPhrasePrefix(queryOffsetList, null); + setQueryOffset_Terms(queryOffsetList, null); } public void setQueryOffset_InScope(Collection queryOffsetList, ConditionOptionCall opLambda) { - setQueryOffset_MatchPhrasePrefix(queryOffsetList, opLambda); + setQueryOffset_Terms(queryOffsetList, opLambda); } public void setQueryOffset_Match(Integer queryOffset) { @@ -641,7 +642,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryOffset_Match(Integer queryOffset, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("queryOffset", queryOffset); + MatchQueryBuilder builder = regMatchQ("queryOffset", queryOffset); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryOffset_MatchPhrase(Integer queryOffset, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("queryOffset", queryOffset); + MatchQueryBuilder builder = regMatchPhraseQ("queryOffset", queryOffset); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryOffset_MatchPhrasePrefix(Integer queryOffset, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("queryOffset", queryOffset); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("queryOffset", queryOffset); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryOffset_Fuzzy(Integer queryOffset, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("queryOffset", queryOffset); + FuzzyQueryBuilder builder = regFuzzyQ("queryOffset", queryOffset); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryOffset_GreaterThan(Integer queryOffset, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("queryOffset", ConditionKey.CK_GREATER_THAN, queryOffset); + RangeQueryBuilder builder = regRangeQ("queryOffset", ConditionKey.CK_GREATER_THAN, queryOffset); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryOffset_LessThan(Integer queryOffset, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("queryOffset", ConditionKey.CK_LESS_THAN, queryOffset); + RangeQueryBuilder builder = regRangeQ("queryOffset", ConditionKey.CK_LESS_THAN, queryOffset); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryOffset_GreaterEqual(Integer queryOffset, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("queryOffset", ConditionKey.CK_GREATER_EQUAL, queryOffset); + RangeQueryBuilder builder = regRangeQ("queryOffset", ConditionKey.CK_GREATER_EQUAL, queryOffset); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +719,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryOffset_LessEqual(Integer queryOffset, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("queryOffset", ConditionKey.CK_LESS_EQUAL, queryOffset); + RangeQueryBuilder builder = regRangeQ("queryOffset", ConditionKey.CK_LESS_EQUAL, queryOffset); if (opLambda != null) { opLambda.callback(builder); } @@ -739,29 +740,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryPageSize_Term(Integer queryPageSize, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("queryPageSize", queryPageSize); + TermQueryBuilder builder = regTermQ("queryPageSize", queryPageSize); if (opLambda != null) { opLambda.callback(builder); } } public void setQueryPageSize_Terms(Collection queryPageSizeList) { - setQueryPageSize_MatchPhrasePrefix(queryPageSizeList, null); + setQueryPageSize_Terms(queryPageSizeList, null); } - public void setQueryPageSize_MatchPhrasePrefix(Collection queryPageSizeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("queryPageSize", queryPageSizeList); + public void setQueryPageSize_Terms(Collection queryPageSizeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("queryPageSize", queryPageSizeList); if (opLambda != null) { opLambda.callback(builder); } } public void setQueryPageSize_InScope(Collection queryPageSizeList) { - setQueryPageSize_MatchPhrasePrefix(queryPageSizeList, null); + setQueryPageSize_Terms(queryPageSizeList, null); } public void setQueryPageSize_InScope(Collection queryPageSizeList, ConditionOptionCall opLambda) { - setQueryPageSize_MatchPhrasePrefix(queryPageSizeList, opLambda); + setQueryPageSize_Terms(queryPageSizeList, opLambda); } public void setQueryPageSize_Match(Integer queryPageSize) { @@ -769,7 +770,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryPageSize_Match(Integer queryPageSize, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("queryPageSize", queryPageSize); + MatchQueryBuilder builder = regMatchQ("queryPageSize", queryPageSize); if (opLambda != null) { opLambda.callback(builder); } @@ -780,7 +781,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryPageSize_MatchPhrase(Integer queryPageSize, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("queryPageSize", queryPageSize); + MatchQueryBuilder builder = regMatchPhraseQ("queryPageSize", queryPageSize); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryPageSize_MatchPhrasePrefix(Integer queryPageSize, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("queryPageSize", queryPageSize); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("queryPageSize", queryPageSize); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryPageSize_Fuzzy(Integer queryPageSize, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("queryPageSize", queryPageSize); + FuzzyQueryBuilder builder = regFuzzyQ("queryPageSize", queryPageSize); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryPageSize_GreaterThan(Integer queryPageSize, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("queryPageSize", ConditionKey.CK_GREATER_THAN, queryPageSize); + RangeQueryBuilder builder = regRangeQ("queryPageSize", ConditionKey.CK_GREATER_THAN, queryPageSize); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryPageSize_LessThan(Integer queryPageSize, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("queryPageSize", ConditionKey.CK_LESS_THAN, queryPageSize); + RangeQueryBuilder builder = regRangeQ("queryPageSize", ConditionKey.CK_LESS_THAN, queryPageSize); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryPageSize_GreaterEqual(Integer queryPageSize, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("queryPageSize", ConditionKey.CK_GREATER_EQUAL, queryPageSize); + RangeQueryBuilder builder = regRangeQ("queryPageSize", ConditionKey.CK_GREATER_EQUAL, queryPageSize); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +847,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setQueryPageSize_LessEqual(Integer queryPageSize, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("queryPageSize", ConditionKey.CK_LESS_EQUAL, queryPageSize); + RangeQueryBuilder builder = regRangeQ("queryPageSize", ConditionKey.CK_LESS_EQUAL, queryPageSize); if (opLambda != null) { opLambda.callback(builder); } @@ -867,29 +868,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setReferer_Term(String referer, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("referer", referer); + TermQueryBuilder builder = regTermQ("referer", referer); if (opLambda != null) { opLambda.callback(builder); } } public void setReferer_Terms(Collection refererList) { - setReferer_MatchPhrasePrefix(refererList, null); + setReferer_Terms(refererList, null); } - public void setReferer_MatchPhrasePrefix(Collection refererList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("referer", refererList); + public void setReferer_Terms(Collection refererList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("referer", refererList); if (opLambda != null) { opLambda.callback(builder); } } public void setReferer_InScope(Collection refererList) { - setReferer_MatchPhrasePrefix(refererList, null); + setReferer_Terms(refererList, null); } public void setReferer_InScope(Collection refererList, ConditionOptionCall opLambda) { - setReferer_MatchPhrasePrefix(refererList, opLambda); + setReferer_Terms(refererList, opLambda); } public void setReferer_Match(String referer) { @@ -897,7 +898,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setReferer_Match(String referer, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("referer", referer); + MatchQueryBuilder builder = regMatchQ("referer", referer); if (opLambda != null) { opLambda.callback(builder); } @@ -908,7 +909,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setReferer_MatchPhrase(String referer, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("referer", referer); + MatchQueryBuilder builder = regMatchPhraseQ("referer", referer); if (opLambda != null) { opLambda.callback(builder); } @@ -919,7 +920,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setReferer_MatchPhrasePrefix(String referer, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("referer", referer); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("referer", referer); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +931,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setReferer_Fuzzy(String referer, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("referer", referer); + FuzzyQueryBuilder builder = regFuzzyQ("referer", referer); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +942,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setReferer_Prefix(String referer, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("referer", referer); + PrefixQueryBuilder builder = regPrefixQ("referer", referer); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +953,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setReferer_GreaterThan(String referer, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("referer", ConditionKey.CK_GREATER_THAN, referer); + RangeQueryBuilder builder = regRangeQ("referer", ConditionKey.CK_GREATER_THAN, referer); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +964,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setReferer_LessThan(String referer, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("referer", ConditionKey.CK_LESS_THAN, referer); + RangeQueryBuilder builder = regRangeQ("referer", ConditionKey.CK_LESS_THAN, referer); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +975,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setReferer_GreaterEqual(String referer, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("referer", ConditionKey.CK_GREATER_EQUAL, referer); + RangeQueryBuilder builder = regRangeQ("referer", ConditionKey.CK_GREATER_EQUAL, referer); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +986,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setReferer_LessEqual(String referer, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("referer", ConditionKey.CK_LESS_EQUAL, referer); + RangeQueryBuilder builder = regRangeQ("referer", ConditionKey.CK_LESS_EQUAL, referer); if (opLambda != null) { opLambda.callback(builder); } @@ -1006,29 +1007,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setRequestedTime_Term(Long requestedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("requestedTime", requestedTime); + TermQueryBuilder builder = regTermQ("requestedTime", requestedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setRequestedTime_Terms(Collection requestedTimeList) { - setRequestedTime_MatchPhrasePrefix(requestedTimeList, null); + setRequestedTime_Terms(requestedTimeList, null); } - public void setRequestedTime_MatchPhrasePrefix(Collection requestedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("requestedTime", requestedTimeList); + public void setRequestedTime_Terms(Collection requestedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("requestedTime", requestedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setRequestedTime_InScope(Collection requestedTimeList) { - setRequestedTime_MatchPhrasePrefix(requestedTimeList, null); + setRequestedTime_Terms(requestedTimeList, null); } public void setRequestedTime_InScope(Collection requestedTimeList, ConditionOptionCall opLambda) { - setRequestedTime_MatchPhrasePrefix(requestedTimeList, opLambda); + setRequestedTime_Terms(requestedTimeList, opLambda); } public void setRequestedTime_Match(Long requestedTime) { @@ -1036,7 +1037,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setRequestedTime_Match(Long requestedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("requestedTime", requestedTime); + MatchQueryBuilder builder = regMatchQ("requestedTime", requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1047,7 +1048,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setRequestedTime_MatchPhrase(Long requestedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("requestedTime", requestedTime); + MatchQueryBuilder builder = regMatchPhraseQ("requestedTime", requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1059,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setRequestedTime_MatchPhrasePrefix(Long requestedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("requestedTime", requestedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("requestedTime", requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1070,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setRequestedTime_Fuzzy(Long requestedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("requestedTime", requestedTime); + FuzzyQueryBuilder builder = regFuzzyQ("requestedTime", requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1081,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setRequestedTime_GreaterThan(Long requestedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_GREATER_THAN, requestedTime); + RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_GREATER_THAN, requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1092,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setRequestedTime_LessThan(Long requestedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_LESS_THAN, requestedTime); + RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_LESS_THAN, requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1103,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setRequestedTime_GreaterEqual(Long requestedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_GREATER_EQUAL, requestedTime); + RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_GREATER_EQUAL, requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1114,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setRequestedTime_LessEqual(Long requestedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("requestedTime", ConditionKey.CK_LESS_EQUAL, requestedTime); + RangeQueryBuilder builder = regRangeQ("requestedTime", ConditionKey.CK_LESS_EQUAL, requestedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1134,29 +1135,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setResponseTime_Term(Integer responseTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("responseTime", responseTime); + TermQueryBuilder builder = regTermQ("responseTime", responseTime); if (opLambda != null) { opLambda.callback(builder); } } public void setResponseTime_Terms(Collection responseTimeList) { - setResponseTime_MatchPhrasePrefix(responseTimeList, null); + setResponseTime_Terms(responseTimeList, null); } - public void setResponseTime_MatchPhrasePrefix(Collection responseTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("responseTime", responseTimeList); + public void setResponseTime_Terms(Collection responseTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("responseTime", responseTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setResponseTime_InScope(Collection responseTimeList) { - setResponseTime_MatchPhrasePrefix(responseTimeList, null); + setResponseTime_Terms(responseTimeList, null); } public void setResponseTime_InScope(Collection responseTimeList, ConditionOptionCall opLambda) { - setResponseTime_MatchPhrasePrefix(responseTimeList, opLambda); + setResponseTime_Terms(responseTimeList, opLambda); } public void setResponseTime_Match(Integer responseTime) { @@ -1164,7 +1165,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setResponseTime_Match(Integer responseTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("responseTime", responseTime); + MatchQueryBuilder builder = regMatchQ("responseTime", responseTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1175,7 +1176,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setResponseTime_MatchPhrase(Integer responseTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("responseTime", responseTime); + MatchQueryBuilder builder = regMatchPhraseQ("responseTime", responseTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1186,7 +1187,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setResponseTime_MatchPhrasePrefix(Integer responseTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("responseTime", responseTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("responseTime", responseTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1197,7 +1198,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setResponseTime_Fuzzy(Integer responseTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("responseTime", responseTime); + FuzzyQueryBuilder builder = regFuzzyQ("responseTime", responseTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1208,7 +1209,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setResponseTime_GreaterThan(Integer responseTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("responseTime", ConditionKey.CK_GREATER_THAN, responseTime); + RangeQueryBuilder builder = regRangeQ("responseTime", ConditionKey.CK_GREATER_THAN, responseTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1219,7 +1220,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setResponseTime_LessThan(Integer responseTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("responseTime", ConditionKey.CK_LESS_THAN, responseTime); + RangeQueryBuilder builder = regRangeQ("responseTime", ConditionKey.CK_LESS_THAN, responseTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1230,7 +1231,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setResponseTime_GreaterEqual(Integer responseTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("responseTime", ConditionKey.CK_GREATER_EQUAL, responseTime); + RangeQueryBuilder builder = regRangeQ("responseTime", ConditionKey.CK_GREATER_EQUAL, responseTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1241,7 +1242,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setResponseTime_LessEqual(Integer responseTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("responseTime", ConditionKey.CK_LESS_EQUAL, responseTime); + RangeQueryBuilder builder = regRangeQ("responseTime", ConditionKey.CK_LESS_EQUAL, responseTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1262,29 +1263,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setSearchWord_Term(String searchWord, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("searchWord", searchWord); + TermQueryBuilder builder = regTermQ("searchWord", searchWord); if (opLambda != null) { opLambda.callback(builder); } } public void setSearchWord_Terms(Collection searchWordList) { - setSearchWord_MatchPhrasePrefix(searchWordList, null); + setSearchWord_Terms(searchWordList, null); } - public void setSearchWord_MatchPhrasePrefix(Collection searchWordList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("searchWord", searchWordList); + public void setSearchWord_Terms(Collection searchWordList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("searchWord", searchWordList); if (opLambda != null) { opLambda.callback(builder); } } public void setSearchWord_InScope(Collection searchWordList) { - setSearchWord_MatchPhrasePrefix(searchWordList, null); + setSearchWord_Terms(searchWordList, null); } public void setSearchWord_InScope(Collection searchWordList, ConditionOptionCall opLambda) { - setSearchWord_MatchPhrasePrefix(searchWordList, opLambda); + setSearchWord_Terms(searchWordList, opLambda); } public void setSearchWord_Match(String searchWord) { @@ -1292,7 +1293,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setSearchWord_Match(String searchWord, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("searchWord", searchWord); + MatchQueryBuilder builder = regMatchQ("searchWord", searchWord); if (opLambda != null) { opLambda.callback(builder); } @@ -1303,7 +1304,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setSearchWord_MatchPhrase(String searchWord, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("searchWord", searchWord); + MatchQueryBuilder builder = regMatchPhraseQ("searchWord", searchWord); if (opLambda != null) { opLambda.callback(builder); } @@ -1314,7 +1315,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setSearchWord_MatchPhrasePrefix(String searchWord, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("searchWord", searchWord); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("searchWord", searchWord); if (opLambda != null) { opLambda.callback(builder); } @@ -1325,7 +1326,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setSearchWord_Fuzzy(String searchWord, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("searchWord", searchWord); + FuzzyQueryBuilder builder = regFuzzyQ("searchWord", searchWord); if (opLambda != null) { opLambda.callback(builder); } @@ -1336,7 +1337,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setSearchWord_Prefix(String searchWord, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("searchWord", searchWord); + PrefixQueryBuilder builder = regPrefixQ("searchWord", searchWord); if (opLambda != null) { opLambda.callback(builder); } @@ -1347,7 +1348,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setSearchWord_GreaterThan(String searchWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchWord", ConditionKey.CK_GREATER_THAN, searchWord); + RangeQueryBuilder builder = regRangeQ("searchWord", ConditionKey.CK_GREATER_THAN, searchWord); if (opLambda != null) { opLambda.callback(builder); } @@ -1358,7 +1359,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setSearchWord_LessThan(String searchWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchWord", ConditionKey.CK_LESS_THAN, searchWord); + RangeQueryBuilder builder = regRangeQ("searchWord", ConditionKey.CK_LESS_THAN, searchWord); if (opLambda != null) { opLambda.callback(builder); } @@ -1369,7 +1370,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setSearchWord_GreaterEqual(String searchWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchWord", ConditionKey.CK_GREATER_EQUAL, searchWord); + RangeQueryBuilder builder = regRangeQ("searchWord", ConditionKey.CK_GREATER_EQUAL, searchWord); if (opLambda != null) { opLambda.callback(builder); } @@ -1380,7 +1381,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setSearchWord_LessEqual(String searchWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("searchWord", ConditionKey.CK_LESS_EQUAL, searchWord); + RangeQueryBuilder builder = regRangeQ("searchWord", ConditionKey.CK_LESS_EQUAL, searchWord); if (opLambda != null) { opLambda.callback(builder); } @@ -1401,29 +1402,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserAgent_Term(String userAgent, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("userAgent", userAgent); + TermQueryBuilder builder = regTermQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } } public void setUserAgent_Terms(Collection userAgentList) { - setUserAgent_MatchPhrasePrefix(userAgentList, null); + setUserAgent_Terms(userAgentList, null); } - public void setUserAgent_MatchPhrasePrefix(Collection userAgentList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("userAgent", userAgentList); + public void setUserAgent_Terms(Collection userAgentList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("userAgent", userAgentList); if (opLambda != null) { opLambda.callback(builder); } } public void setUserAgent_InScope(Collection userAgentList) { - setUserAgent_MatchPhrasePrefix(userAgentList, null); + setUserAgent_Terms(userAgentList, null); } public void setUserAgent_InScope(Collection userAgentList, ConditionOptionCall opLambda) { - setUserAgent_MatchPhrasePrefix(userAgentList, opLambda); + setUserAgent_Terms(userAgentList, opLambda); } public void setUserAgent_Match(String userAgent) { @@ -1431,7 +1432,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserAgent_Match(String userAgent, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("userAgent", userAgent); + MatchQueryBuilder builder = regMatchQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -1442,7 +1443,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserAgent_MatchPhrase(String userAgent, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("userAgent", userAgent); + MatchQueryBuilder builder = regMatchPhraseQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -1453,7 +1454,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserAgent_MatchPhrasePrefix(String userAgent, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("userAgent", userAgent); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -1464,7 +1465,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserAgent_Fuzzy(String userAgent, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("userAgent", userAgent); + FuzzyQueryBuilder builder = regFuzzyQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -1475,7 +1476,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserAgent_Prefix(String userAgent, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("userAgent", userAgent); + PrefixQueryBuilder builder = regPrefixQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -1486,7 +1487,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserAgent_GreaterThan(String userAgent, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userAgent", ConditionKey.CK_GREATER_THAN, userAgent); + RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_GREATER_THAN, userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -1497,7 +1498,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserAgent_LessThan(String userAgent, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userAgent", ConditionKey.CK_LESS_THAN, userAgent); + RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_LESS_THAN, userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -1508,7 +1509,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserAgent_GreaterEqual(String userAgent, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userAgent", ConditionKey.CK_GREATER_EQUAL, userAgent); + RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_GREATER_EQUAL, userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -1519,7 +1520,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserAgent_LessEqual(String userAgent, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userAgent", ConditionKey.CK_LESS_EQUAL, userAgent); + RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_LESS_EQUAL, userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -1540,29 +1541,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserId_Term(Long userId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("userId", userId); + TermQueryBuilder builder = regTermQ("userId", userId); if (opLambda != null) { opLambda.callback(builder); } } public void setUserId_Terms(Collection userIdList) { - setUserId_MatchPhrasePrefix(userIdList, null); + setUserId_Terms(userIdList, null); } - public void setUserId_MatchPhrasePrefix(Collection userIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("userId", userIdList); + public void setUserId_Terms(Collection userIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("userId", userIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setUserId_InScope(Collection userIdList) { - setUserId_MatchPhrasePrefix(userIdList, null); + setUserId_Terms(userIdList, null); } public void setUserId_InScope(Collection userIdList, ConditionOptionCall opLambda) { - setUserId_MatchPhrasePrefix(userIdList, opLambda); + setUserId_Terms(userIdList, opLambda); } public void setUserId_Match(Long userId) { @@ -1570,7 +1571,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserId_Match(Long userId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("userId", userId); + MatchQueryBuilder builder = regMatchQ("userId", userId); if (opLambda != null) { opLambda.callback(builder); } @@ -1581,7 +1582,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserId_MatchPhrase(Long userId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("userId", userId); + MatchQueryBuilder builder = regMatchPhraseQ("userId", userId); if (opLambda != null) { opLambda.callback(builder); } @@ -1592,7 +1593,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserId_MatchPhrasePrefix(Long userId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("userId", userId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("userId", userId); if (opLambda != null) { opLambda.callback(builder); } @@ -1603,7 +1604,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserId_Fuzzy(Long userId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("userId", userId); + FuzzyQueryBuilder builder = regFuzzyQ("userId", userId); if (opLambda != null) { opLambda.callback(builder); } @@ -1614,7 +1615,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserId_GreaterThan(Long userId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userId", ConditionKey.CK_GREATER_THAN, userId); + RangeQueryBuilder builder = regRangeQ("userId", ConditionKey.CK_GREATER_THAN, userId); if (opLambda != null) { opLambda.callback(builder); } @@ -1625,7 +1626,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserId_LessThan(Long userId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userId", ConditionKey.CK_LESS_THAN, userId); + RangeQueryBuilder builder = regRangeQ("userId", ConditionKey.CK_LESS_THAN, userId); if (opLambda != null) { opLambda.callback(builder); } @@ -1636,7 +1637,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserId_GreaterEqual(Long userId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userId", ConditionKey.CK_GREATER_EQUAL, userId); + RangeQueryBuilder builder = regRangeQ("userId", ConditionKey.CK_GREATER_EQUAL, userId); if (opLambda != null) { opLambda.callback(builder); } @@ -1647,7 +1648,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserId_LessEqual(Long userId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userId", ConditionKey.CK_LESS_EQUAL, userId); + RangeQueryBuilder builder = regRangeQ("userId", ConditionKey.CK_LESS_EQUAL, userId); if (opLambda != null) { opLambda.callback(builder); } @@ -1668,29 +1669,29 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserSessionId_Term(String userSessionId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("userSessionId", userSessionId); + TermQueryBuilder builder = regTermQ("userSessionId", userSessionId); if (opLambda != null) { opLambda.callback(builder); } } public void setUserSessionId_Terms(Collection userSessionIdList) { - setUserSessionId_MatchPhrasePrefix(userSessionIdList, null); + setUserSessionId_Terms(userSessionIdList, null); } - public void setUserSessionId_MatchPhrasePrefix(Collection userSessionIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("userSessionId", userSessionIdList); + public void setUserSessionId_Terms(Collection userSessionIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("userSessionId", userSessionIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setUserSessionId_InScope(Collection userSessionIdList) { - setUserSessionId_MatchPhrasePrefix(userSessionIdList, null); + setUserSessionId_Terms(userSessionIdList, null); } public void setUserSessionId_InScope(Collection userSessionIdList, ConditionOptionCall opLambda) { - setUserSessionId_MatchPhrasePrefix(userSessionIdList, opLambda); + setUserSessionId_Terms(userSessionIdList, opLambda); } public void setUserSessionId_Match(String userSessionId) { @@ -1698,7 +1699,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserSessionId_Match(String userSessionId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("userSessionId", userSessionId); + MatchQueryBuilder builder = regMatchQ("userSessionId", userSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -1709,7 +1710,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserSessionId_MatchPhrase(String userSessionId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("userSessionId", userSessionId); + MatchQueryBuilder builder = regMatchPhraseQ("userSessionId", userSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -1720,7 +1721,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserSessionId_MatchPhrasePrefix(String userSessionId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("userSessionId", userSessionId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("userSessionId", userSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -1731,7 +1732,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserSessionId_Fuzzy(String userSessionId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("userSessionId", userSessionId); + FuzzyQueryBuilder builder = regFuzzyQ("userSessionId", userSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -1742,7 +1743,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserSessionId_Prefix(String userSessionId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("userSessionId", userSessionId); + PrefixQueryBuilder builder = regPrefixQ("userSessionId", userSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -1753,7 +1754,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserSessionId_GreaterThan(String userSessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userSessionId", ConditionKey.CK_GREATER_THAN, userSessionId); + RangeQueryBuilder builder = regRangeQ("userSessionId", ConditionKey.CK_GREATER_THAN, userSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -1764,7 +1765,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserSessionId_LessThan(String userSessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userSessionId", ConditionKey.CK_LESS_THAN, userSessionId); + RangeQueryBuilder builder = regRangeQ("userSessionId", ConditionKey.CK_LESS_THAN, userSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -1775,7 +1776,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserSessionId_GreaterEqual(String userSessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userSessionId", ConditionKey.CK_GREATER_EQUAL, userSessionId); + RangeQueryBuilder builder = regRangeQ("userSessionId", ConditionKey.CK_GREATER_EQUAL, userSessionId); if (opLambda != null) { opLambda.callback(builder); } @@ -1786,7 +1787,7 @@ public abstract class BsSearchLogCQ extends AbstractConditionQuery { } public void setUserSessionId_LessEqual(String userSessionId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userSessionId", ConditionKey.CK_LESS_EQUAL, userSessionId); + RangeQueryBuilder builder = regRangeQ("userSessionId", ConditionKey.CK_LESS_EQUAL, userSessionId); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSuggestBadWordCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSuggestBadWordCQ.java index 4b56b23d9..a23f9b736 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSuggestBadWordCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSuggestBadWordCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.SuggestBadWordCQ; +import org.codelibs.fess.es.cbean.cf.SuggestBadWordCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { return "suggest_bad_word"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { SuggestBadWordCQ query = new SuggestBadWordCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + SuggestBadWordCF filter = new SuggestBadWordCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { SuggestBadWordCQ shouldQuery = new SuggestBadWordCQ(); SuggestBadWordCQ mustNotQuery = new SuggestBadWordCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -96,7 +97,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +185,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +206,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -235,7 +236,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -363,7 +364,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setSuggestWord_Term(String suggestWord, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("suggestWord", suggestWord); + TermQueryBuilder builder = regTermQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } } public void setSuggestWord_Terms(Collection suggestWordList) { - setSuggestWord_MatchPhrasePrefix(suggestWordList, null); + setSuggestWord_Terms(suggestWordList, null); } - public void setSuggestWord_MatchPhrasePrefix(Collection suggestWordList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("suggestWord", suggestWordList); + public void setSuggestWord_Terms(Collection suggestWordList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("suggestWord", suggestWordList); if (opLambda != null) { opLambda.callback(builder); } } public void setSuggestWord_InScope(Collection suggestWordList) { - setSuggestWord_MatchPhrasePrefix(suggestWordList, null); + setSuggestWord_Terms(suggestWordList, null); } public void setSuggestWord_InScope(Collection suggestWordList, ConditionOptionCall opLambda) { - setSuggestWord_MatchPhrasePrefix(suggestWordList, opLambda); + setSuggestWord_Terms(suggestWordList, opLambda); } public void setSuggestWord_Match(String suggestWord) { @@ -502,7 +503,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setSuggestWord_Match(String suggestWord, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("suggestWord", suggestWord); + MatchQueryBuilder builder = regMatchQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setSuggestWord_MatchPhrase(String suggestWord, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("suggestWord", suggestWord); + MatchQueryBuilder builder = regMatchPhraseQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setSuggestWord_MatchPhrasePrefix(String suggestWord, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("suggestWord", suggestWord); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setSuggestWord_Fuzzy(String suggestWord, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("suggestWord", suggestWord); + FuzzyQueryBuilder builder = regFuzzyQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setSuggestWord_Prefix(String suggestWord, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("suggestWord", suggestWord); + PrefixQueryBuilder builder = regPrefixQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setSuggestWord_GreaterThan(String suggestWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_GREATER_THAN, suggestWord); + RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_GREATER_THAN, suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setSuggestWord_LessThan(String suggestWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_LESS_THAN, suggestWord); + RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_LESS_THAN, suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setSuggestWord_GreaterEqual(String suggestWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_GREATER_EQUAL, suggestWord); + RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_GREATER_EQUAL, suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +591,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setSuggestWord_LessEqual(String suggestWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_LESS_EQUAL, suggestWord); + RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_LESS_EQUAL, suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +612,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetLabel_Term(String targetLabel, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("targetLabel", targetLabel); + TermQueryBuilder builder = regTermQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } } public void setTargetLabel_Terms(Collection targetLabelList) { - setTargetLabel_MatchPhrasePrefix(targetLabelList, null); + setTargetLabel_Terms(targetLabelList, null); } - public void setTargetLabel_MatchPhrasePrefix(Collection targetLabelList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("targetLabel", targetLabelList); + public void setTargetLabel_Terms(Collection targetLabelList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("targetLabel", targetLabelList); if (opLambda != null) { opLambda.callback(builder); } } public void setTargetLabel_InScope(Collection targetLabelList) { - setTargetLabel_MatchPhrasePrefix(targetLabelList, null); + setTargetLabel_Terms(targetLabelList, null); } public void setTargetLabel_InScope(Collection targetLabelList, ConditionOptionCall opLambda) { - setTargetLabel_MatchPhrasePrefix(targetLabelList, opLambda); + setTargetLabel_Terms(targetLabelList, opLambda); } public void setTargetLabel_Match(String targetLabel) { @@ -641,7 +642,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetLabel_Match(String targetLabel, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("targetLabel", targetLabel); + MatchQueryBuilder builder = regMatchQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetLabel_MatchPhrase(String targetLabel, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("targetLabel", targetLabel); + MatchQueryBuilder builder = regMatchPhraseQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetLabel_MatchPhrasePrefix(String targetLabel, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("targetLabel", targetLabel); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetLabel_Fuzzy(String targetLabel, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("targetLabel", targetLabel); + FuzzyQueryBuilder builder = regFuzzyQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetLabel_Prefix(String targetLabel, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("targetLabel", targetLabel); + PrefixQueryBuilder builder = regPrefixQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetLabel_GreaterThan(String targetLabel, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_GREATER_THAN, targetLabel); + RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_GREATER_THAN, targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetLabel_LessThan(String targetLabel, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_LESS_THAN, targetLabel); + RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_LESS_THAN, targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +719,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetLabel_GreaterEqual(String targetLabel, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_GREATER_EQUAL, targetLabel); + RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_GREATER_EQUAL, targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -729,7 +730,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetLabel_LessEqual(String targetLabel, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_LESS_EQUAL, targetLabel); + RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_LESS_EQUAL, targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -750,29 +751,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetRole_Term(String targetRole, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("targetRole", targetRole); + TermQueryBuilder builder = regTermQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } } public void setTargetRole_Terms(Collection targetRoleList) { - setTargetRole_MatchPhrasePrefix(targetRoleList, null); + setTargetRole_Terms(targetRoleList, null); } - public void setTargetRole_MatchPhrasePrefix(Collection targetRoleList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("targetRole", targetRoleList); + public void setTargetRole_Terms(Collection targetRoleList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("targetRole", targetRoleList); if (opLambda != null) { opLambda.callback(builder); } } public void setTargetRole_InScope(Collection targetRoleList) { - setTargetRole_MatchPhrasePrefix(targetRoleList, null); + setTargetRole_Terms(targetRoleList, null); } public void setTargetRole_InScope(Collection targetRoleList, ConditionOptionCall opLambda) { - setTargetRole_MatchPhrasePrefix(targetRoleList, opLambda); + setTargetRole_Terms(targetRoleList, opLambda); } public void setTargetRole_Match(String targetRole) { @@ -780,7 +781,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetRole_Match(String targetRole, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("targetRole", targetRole); + MatchQueryBuilder builder = regMatchQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetRole_MatchPhrase(String targetRole, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("targetRole", targetRole); + MatchQueryBuilder builder = regMatchPhraseQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetRole_MatchPhrasePrefix(String targetRole, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("targetRole", targetRole); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetRole_Fuzzy(String targetRole, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("targetRole", targetRole); + FuzzyQueryBuilder builder = regFuzzyQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetRole_Prefix(String targetRole, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("targetRole", targetRole); + PrefixQueryBuilder builder = regPrefixQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetRole_GreaterThan(String targetRole, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_GREATER_THAN, targetRole); + RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_GREATER_THAN, targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +847,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetRole_LessThan(String targetRole, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_LESS_THAN, targetRole); + RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_LESS_THAN, targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +858,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetRole_GreaterEqual(String targetRole, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_GREATER_EQUAL, targetRole); + RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_GREATER_EQUAL, targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -868,7 +869,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setTargetRole_LessEqual(String targetRole, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_LESS_EQUAL, targetRole); + RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_LESS_EQUAL, targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -889,29 +890,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -919,7 +920,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +931,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +942,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +953,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +964,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +975,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +986,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -996,7 +997,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1007,7 +1008,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1028,29 +1029,29 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -1058,7 +1059,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1070,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1081,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1092,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1103,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1114,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1125,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1135,7 +1136,7 @@ public abstract class BsSuggestBadWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSuggestElevateWordCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSuggestElevateWordCQ.java index 63de48342..a1cad6a79 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSuggestElevateWordCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsSuggestElevateWordCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.SuggestElevateWordCQ; +import org.codelibs.fess.es.cbean.cf.SuggestElevateWordCF; 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 BsSuggestElevateWordCQ extends AbstractConditionQuery { return "suggest_elevate_word"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { SuggestElevateWordCQ query = new SuggestElevateWordCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + SuggestElevateWordCF filter = new SuggestElevateWordCF(); + 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 BsSuggestElevateWordCQ extends AbstractConditionQuery { SuggestElevateWordCQ shouldQuery = new SuggestElevateWordCQ(); SuggestElevateWordCQ mustNotQuery = new SuggestElevateWordCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setBoost_Term(Float boost, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("boost", boost); + TermQueryBuilder builder = regTermQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } } public void setBoost_Terms(Collection boostList) { - setBoost_MatchPhrasePrefix(boostList, null); + setBoost_Terms(boostList, null); } - public void setBoost_MatchPhrasePrefix(Collection boostList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("boost", boostList); + public void setBoost_Terms(Collection boostList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("boost", boostList); if (opLambda != null) { opLambda.callback(builder); } } public void setBoost_InScope(Collection boostList) { - setBoost_MatchPhrasePrefix(boostList, null); + setBoost_Terms(boostList, null); } public void setBoost_InScope(Collection boostList, ConditionOptionCall opLambda) { - setBoost_MatchPhrasePrefix(boostList, opLambda); + setBoost_Terms(boostList, opLambda); } public void setBoost_Match(Float boost) { @@ -96,7 +98,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setBoost_Match(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("boost", boost); + MatchQueryBuilder builder = regMatchQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setBoost_MatchPhrase(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("boost", boost); + MatchQueryBuilder builder = regMatchPhraseQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setBoost_MatchPhrasePrefix(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("boost", boost); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setBoost_Fuzzy(Float boost, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("boost", boost); + FuzzyQueryBuilder builder = regFuzzyQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setBoost_GreaterThan(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setBoost_LessThan(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_THAN, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_THAN, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setBoost_GreaterEqual(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setBoost_LessEqual(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -194,29 +196,29 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -224,7 +226,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -235,7 +237,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +314,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +335,29 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -363,7 +365,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +376,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -461,29 +463,29 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -491,7 +493,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -502,7 +504,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +515,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +526,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +537,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +548,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +559,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +570,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +581,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -600,29 +602,29 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setReading_Term(String reading, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("reading", reading); + TermQueryBuilder builder = regTermQ("reading", reading); if (opLambda != null) { opLambda.callback(builder); } } public void setReading_Terms(Collection readingList) { - setReading_MatchPhrasePrefix(readingList, null); + setReading_Terms(readingList, null); } - public void setReading_MatchPhrasePrefix(Collection readingList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("reading", readingList); + public void setReading_Terms(Collection readingList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("reading", readingList); if (opLambda != null) { opLambda.callback(builder); } } public void setReading_InScope(Collection readingList) { - setReading_MatchPhrasePrefix(readingList, null); + setReading_Terms(readingList, null); } public void setReading_InScope(Collection readingList, ConditionOptionCall opLambda) { - setReading_MatchPhrasePrefix(readingList, opLambda); + setReading_Terms(readingList, opLambda); } public void setReading_Match(String reading) { @@ -630,7 +632,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setReading_Match(String reading, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("reading", reading); + MatchQueryBuilder builder = regMatchQ("reading", reading); if (opLambda != null) { opLambda.callback(builder); } @@ -641,7 +643,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setReading_MatchPhrase(String reading, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("reading", reading); + MatchQueryBuilder builder = regMatchPhraseQ("reading", reading); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +654,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setReading_MatchPhrasePrefix(String reading, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("reading", reading); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("reading", reading); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +665,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setReading_Fuzzy(String reading, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("reading", reading); + FuzzyQueryBuilder builder = regFuzzyQ("reading", reading); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +676,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setReading_Prefix(String reading, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("reading", reading); + PrefixQueryBuilder builder = regPrefixQ("reading", reading); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +687,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setReading_GreaterThan(String reading, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("reading", ConditionKey.CK_GREATER_THAN, reading); + RangeQueryBuilder builder = regRangeQ("reading", ConditionKey.CK_GREATER_THAN, reading); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +698,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setReading_LessThan(String reading, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("reading", ConditionKey.CK_LESS_THAN, reading); + RangeQueryBuilder builder = regRangeQ("reading", ConditionKey.CK_LESS_THAN, reading); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +709,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setReading_GreaterEqual(String reading, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("reading", ConditionKey.CK_GREATER_EQUAL, reading); + RangeQueryBuilder builder = regRangeQ("reading", ConditionKey.CK_GREATER_EQUAL, reading); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +720,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setReading_LessEqual(String reading, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("reading", ConditionKey.CK_LESS_EQUAL, reading); + RangeQueryBuilder builder = regRangeQ("reading", ConditionKey.CK_LESS_EQUAL, reading); if (opLambda != null) { opLambda.callback(builder); } @@ -739,29 +741,29 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setSuggestWord_Term(String suggestWord, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("suggestWord", suggestWord); + TermQueryBuilder builder = regTermQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } } public void setSuggestWord_Terms(Collection suggestWordList) { - setSuggestWord_MatchPhrasePrefix(suggestWordList, null); + setSuggestWord_Terms(suggestWordList, null); } - public void setSuggestWord_MatchPhrasePrefix(Collection suggestWordList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("suggestWord", suggestWordList); + public void setSuggestWord_Terms(Collection suggestWordList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("suggestWord", suggestWordList); if (opLambda != null) { opLambda.callback(builder); } } public void setSuggestWord_InScope(Collection suggestWordList) { - setSuggestWord_MatchPhrasePrefix(suggestWordList, null); + setSuggestWord_Terms(suggestWordList, null); } public void setSuggestWord_InScope(Collection suggestWordList, ConditionOptionCall opLambda) { - setSuggestWord_MatchPhrasePrefix(suggestWordList, opLambda); + setSuggestWord_Terms(suggestWordList, opLambda); } public void setSuggestWord_Match(String suggestWord) { @@ -769,7 +771,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setSuggestWord_Match(String suggestWord, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("suggestWord", suggestWord); + MatchQueryBuilder builder = regMatchQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -780,7 +782,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setSuggestWord_MatchPhrase(String suggestWord, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("suggestWord", suggestWord); + MatchQueryBuilder builder = regMatchPhraseQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +793,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setSuggestWord_MatchPhrasePrefix(String suggestWord, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("suggestWord", suggestWord); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +804,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setSuggestWord_Fuzzy(String suggestWord, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("suggestWord", suggestWord); + FuzzyQueryBuilder builder = regFuzzyQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +815,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setSuggestWord_Prefix(String suggestWord, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("suggestWord", suggestWord); + PrefixQueryBuilder builder = regPrefixQ("suggestWord", suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +826,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setSuggestWord_GreaterThan(String suggestWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_GREATER_THAN, suggestWord); + RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_GREATER_THAN, suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +837,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setSuggestWord_LessThan(String suggestWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_LESS_THAN, suggestWord); + RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_LESS_THAN, suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +848,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setSuggestWord_GreaterEqual(String suggestWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_GREATER_EQUAL, suggestWord); + RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_GREATER_EQUAL, suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +859,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setSuggestWord_LessEqual(String suggestWord, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("suggestWord", ConditionKey.CK_LESS_EQUAL, suggestWord); + RangeQueryBuilder builder = regRangeQ("suggestWord", ConditionKey.CK_LESS_EQUAL, suggestWord); if (opLambda != null) { opLambda.callback(builder); } @@ -878,29 +880,29 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetLabel_Term(String targetLabel, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("targetLabel", targetLabel); + TermQueryBuilder builder = regTermQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } } public void setTargetLabel_Terms(Collection targetLabelList) { - setTargetLabel_MatchPhrasePrefix(targetLabelList, null); + setTargetLabel_Terms(targetLabelList, null); } - public void setTargetLabel_MatchPhrasePrefix(Collection targetLabelList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("targetLabel", targetLabelList); + public void setTargetLabel_Terms(Collection targetLabelList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("targetLabel", targetLabelList); if (opLambda != null) { opLambda.callback(builder); } } public void setTargetLabel_InScope(Collection targetLabelList) { - setTargetLabel_MatchPhrasePrefix(targetLabelList, null); + setTargetLabel_Terms(targetLabelList, null); } public void setTargetLabel_InScope(Collection targetLabelList, ConditionOptionCall opLambda) { - setTargetLabel_MatchPhrasePrefix(targetLabelList, opLambda); + setTargetLabel_Terms(targetLabelList, opLambda); } public void setTargetLabel_Match(String targetLabel) { @@ -908,7 +910,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetLabel_Match(String targetLabel, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("targetLabel", targetLabel); + MatchQueryBuilder builder = regMatchQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -919,7 +921,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetLabel_MatchPhrase(String targetLabel, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("targetLabel", targetLabel); + MatchQueryBuilder builder = regMatchPhraseQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +932,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetLabel_MatchPhrasePrefix(String targetLabel, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("targetLabel", targetLabel); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +943,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetLabel_Fuzzy(String targetLabel, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("targetLabel", targetLabel); + FuzzyQueryBuilder builder = regFuzzyQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +954,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetLabel_Prefix(String targetLabel, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("targetLabel", targetLabel); + PrefixQueryBuilder builder = regPrefixQ("targetLabel", targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +965,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetLabel_GreaterThan(String targetLabel, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_GREATER_THAN, targetLabel); + RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_GREATER_THAN, targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +976,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetLabel_LessThan(String targetLabel, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_LESS_THAN, targetLabel); + RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_LESS_THAN, targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +987,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetLabel_GreaterEqual(String targetLabel, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_GREATER_EQUAL, targetLabel); + RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_GREATER_EQUAL, targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -996,7 +998,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetLabel_LessEqual(String targetLabel, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetLabel", ConditionKey.CK_LESS_EQUAL, targetLabel); + RangeQueryBuilder builder = regRangeQ("targetLabel", ConditionKey.CK_LESS_EQUAL, targetLabel); if (opLambda != null) { opLambda.callback(builder); } @@ -1017,29 +1019,29 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetRole_Term(String targetRole, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("targetRole", targetRole); + TermQueryBuilder builder = regTermQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } } public void setTargetRole_Terms(Collection targetRoleList) { - setTargetRole_MatchPhrasePrefix(targetRoleList, null); + setTargetRole_Terms(targetRoleList, null); } - public void setTargetRole_MatchPhrasePrefix(Collection targetRoleList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("targetRole", targetRoleList); + public void setTargetRole_Terms(Collection targetRoleList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("targetRole", targetRoleList); if (opLambda != null) { opLambda.callback(builder); } } public void setTargetRole_InScope(Collection targetRoleList) { - setTargetRole_MatchPhrasePrefix(targetRoleList, null); + setTargetRole_Terms(targetRoleList, null); } public void setTargetRole_InScope(Collection targetRoleList, ConditionOptionCall opLambda) { - setTargetRole_MatchPhrasePrefix(targetRoleList, opLambda); + setTargetRole_Terms(targetRoleList, opLambda); } public void setTargetRole_Match(String targetRole) { @@ -1047,7 +1049,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetRole_Match(String targetRole, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("targetRole", targetRole); + MatchQueryBuilder builder = regMatchQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1060,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetRole_MatchPhrase(String targetRole, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("targetRole", targetRole); + MatchQueryBuilder builder = regMatchPhraseQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1071,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetRole_MatchPhrasePrefix(String targetRole, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("targetRole", targetRole); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1082,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetRole_Fuzzy(String targetRole, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("targetRole", targetRole); + FuzzyQueryBuilder builder = regFuzzyQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1093,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetRole_Prefix(String targetRole, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("targetRole", targetRole); + PrefixQueryBuilder builder = regPrefixQ("targetRole", targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1104,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetRole_GreaterThan(String targetRole, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_GREATER_THAN, targetRole); + RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_GREATER_THAN, targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1115,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetRole_LessThan(String targetRole, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_LESS_THAN, targetRole); + RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_LESS_THAN, targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1126,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetRole_GreaterEqual(String targetRole, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_GREATER_EQUAL, targetRole); + RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_GREATER_EQUAL, targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -1135,7 +1137,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setTargetRole_LessEqual(String targetRole, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("targetRole", ConditionKey.CK_LESS_EQUAL, targetRole); + RangeQueryBuilder builder = regRangeQ("targetRole", ConditionKey.CK_LESS_EQUAL, targetRole); if (opLambda != null) { opLambda.callback(builder); } @@ -1156,29 +1158,29 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -1186,7 +1188,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1197,7 +1199,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1208,7 +1210,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1219,7 +1221,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1230,7 +1232,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1241,7 +1243,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1252,7 +1254,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1263,7 +1265,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1274,7 +1276,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1295,29 +1297,29 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -1325,7 +1327,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1336,7 +1338,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1347,7 +1349,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1358,7 +1360,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1369,7 +1371,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1380,7 +1382,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1391,7 +1393,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1402,7 +1404,7 @@ public abstract class BsSuggestElevateWordCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsUserInfoCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsUserInfoCQ.java index b67b5740f..aafa4e831 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsUserInfoCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsUserInfoCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.UserInfoCQ; +import org.codelibs.fess.es.cbean.cf.UserInfoCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { return "user_info"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { UserInfoCQ query = new UserInfoCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + UserInfoCF filter = new UserInfoCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { UserInfoCQ shouldQuery = new UserInfoCQ(); UserInfoCQ mustNotQuery = new UserInfoCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCode_Term(String code, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("code", code); + TermQueryBuilder builder = regTermQ("code", code); if (opLambda != null) { opLambda.callback(builder); } } public void setCode_Terms(Collection codeList) { - setCode_MatchPhrasePrefix(codeList, null); + setCode_Terms(codeList, null); } - public void setCode_MatchPhrasePrefix(Collection codeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("code", codeList); + public void setCode_Terms(Collection codeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("code", codeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCode_InScope(Collection codeList) { - setCode_MatchPhrasePrefix(codeList, null); + setCode_Terms(codeList, null); } public void setCode_InScope(Collection codeList, ConditionOptionCall opLambda) { - setCode_MatchPhrasePrefix(codeList, opLambda); + setCode_Terms(codeList, opLambda); } public void setCode_Match(String code) { @@ -96,7 +97,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCode_Match(String code, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("code", code); + MatchQueryBuilder builder = regMatchQ("code", code); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCode_MatchPhrase(String code, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("code", code); + MatchQueryBuilder builder = regMatchPhraseQ("code", code); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCode_MatchPhrasePrefix(String code, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("code", code); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("code", code); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCode_Fuzzy(String code, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("code", code); + FuzzyQueryBuilder builder = regFuzzyQ("code", code); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCode_Prefix(String code, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("code", code); + PrefixQueryBuilder builder = regPrefixQ("code", code); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCode_GreaterThan(String code, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("code", ConditionKey.CK_GREATER_THAN, code); + RangeQueryBuilder builder = regRangeQ("code", ConditionKey.CK_GREATER_THAN, code); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCode_LessThan(String code, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("code", ConditionKey.CK_LESS_THAN, code); + RangeQueryBuilder builder = regRangeQ("code", ConditionKey.CK_LESS_THAN, code); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCode_GreaterEqual(String code, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("code", ConditionKey.CK_GREATER_EQUAL, code); + RangeQueryBuilder builder = regRangeQ("code", ConditionKey.CK_GREATER_EQUAL, code); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +185,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCode_LessEqual(String code, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("code", ConditionKey.CK_LESS_EQUAL, code); + RangeQueryBuilder builder = regRangeQ("code", ConditionKey.CK_LESS_EQUAL, code); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +206,29 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -235,7 +236,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +313,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -333,29 +334,29 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -363,7 +364,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +452,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +473,29 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -502,7 +503,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsUserInfoCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebAuthenticationCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebAuthenticationCQ.java index 3aa4b6117..ca5bacd57 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebAuthenticationCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebAuthenticationCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.WebAuthenticationCQ; +import org.codelibs.fess.es.cbean.cf.WebAuthenticationCF; 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 BsWebAuthenticationCQ extends AbstractConditionQuery { return "web_authentication"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { WebAuthenticationCQ query = new WebAuthenticationCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + WebAuthenticationCF filter = new WebAuthenticationCF(); + 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 BsWebAuthenticationCQ extends AbstractConditionQuery { WebAuthenticationCQ shouldQuery = new WebAuthenticationCQ(); WebAuthenticationCQ mustNotQuery = new WebAuthenticationCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setAuthRealm_Term(String authRealm, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("authRealm", authRealm); + TermQueryBuilder builder = regTermQ("authRealm", authRealm); if (opLambda != null) { opLambda.callback(builder); } } public void setAuthRealm_Terms(Collection authRealmList) { - setAuthRealm_MatchPhrasePrefix(authRealmList, null); + setAuthRealm_Terms(authRealmList, null); } - public void setAuthRealm_MatchPhrasePrefix(Collection authRealmList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("authRealm", authRealmList); + public void setAuthRealm_Terms(Collection authRealmList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("authRealm", authRealmList); if (opLambda != null) { opLambda.callback(builder); } } public void setAuthRealm_InScope(Collection authRealmList) { - setAuthRealm_MatchPhrasePrefix(authRealmList, null); + setAuthRealm_Terms(authRealmList, null); } public void setAuthRealm_InScope(Collection authRealmList, ConditionOptionCall opLambda) { - setAuthRealm_MatchPhrasePrefix(authRealmList, opLambda); + setAuthRealm_Terms(authRealmList, opLambda); } public void setAuthRealm_Match(String authRealm) { @@ -96,7 +98,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setAuthRealm_Match(String authRealm, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("authRealm", authRealm); + MatchQueryBuilder builder = regMatchQ("authRealm", authRealm); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setAuthRealm_MatchPhrase(String authRealm, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("authRealm", authRealm); + MatchQueryBuilder builder = regMatchPhraseQ("authRealm", authRealm); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setAuthRealm_MatchPhrasePrefix(String authRealm, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("authRealm", authRealm); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("authRealm", authRealm); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setAuthRealm_Fuzzy(String authRealm, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("authRealm", authRealm); + FuzzyQueryBuilder builder = regFuzzyQ("authRealm", authRealm); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setAuthRealm_Prefix(String authRealm, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("authRealm", authRealm); + PrefixQueryBuilder builder = regPrefixQ("authRealm", authRealm); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setAuthRealm_GreaterThan(String authRealm, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("authRealm", ConditionKey.CK_GREATER_THAN, authRealm); + RangeQueryBuilder builder = regRangeQ("authRealm", ConditionKey.CK_GREATER_THAN, authRealm); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setAuthRealm_LessThan(String authRealm, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("authRealm", ConditionKey.CK_LESS_THAN, authRealm); + RangeQueryBuilder builder = regRangeQ("authRealm", ConditionKey.CK_LESS_THAN, authRealm); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setAuthRealm_GreaterEqual(String authRealm, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("authRealm", ConditionKey.CK_GREATER_EQUAL, authRealm); + RangeQueryBuilder builder = regRangeQ("authRealm", ConditionKey.CK_GREATER_EQUAL, authRealm); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +186,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setAuthRealm_LessEqual(String authRealm, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("authRealm", ConditionKey.CK_LESS_EQUAL, authRealm); + RangeQueryBuilder builder = regRangeQ("authRealm", ConditionKey.CK_LESS_EQUAL, authRealm); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +207,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -235,7 +237,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +314,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -323,7 +325,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -344,29 +346,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -374,7 +376,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +453,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -472,29 +474,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_Term(String hostname, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("hostname", hostname); + TermQueryBuilder builder = regTermQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } } public void setHostname_Terms(Collection hostnameList) { - setHostname_MatchPhrasePrefix(hostnameList, null); + setHostname_Terms(hostnameList, null); } - public void setHostname_MatchPhrasePrefix(Collection hostnameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("hostname", hostnameList); + public void setHostname_Terms(Collection hostnameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("hostname", hostnameList); if (opLambda != null) { opLambda.callback(builder); } } public void setHostname_InScope(Collection hostnameList) { - setHostname_MatchPhrasePrefix(hostnameList, null); + setHostname_Terms(hostnameList, null); } public void setHostname_InScope(Collection hostnameList, ConditionOptionCall opLambda) { - setHostname_MatchPhrasePrefix(hostnameList, opLambda); + setHostname_Terms(hostnameList, opLambda); } public void setHostname_Match(String hostname) { @@ -502,7 +504,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_Match(String hostname, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("hostname", hostname); + MatchQueryBuilder builder = regMatchQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +515,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_MatchPhrase(String hostname, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("hostname", hostname); + MatchQueryBuilder builder = regMatchPhraseQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +526,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_MatchPhrasePrefix(String hostname, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("hostname", hostname); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +537,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_Fuzzy(String hostname, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("hostname", hostname); + FuzzyQueryBuilder builder = regFuzzyQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +548,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_Prefix(String hostname, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("hostname", hostname); + PrefixQueryBuilder builder = regPrefixQ("hostname", hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +559,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_GreaterThan(String hostname, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hostname", ConditionKey.CK_GREATER_THAN, hostname); + RangeQueryBuilder builder = regRangeQ("hostname", ConditionKey.CK_GREATER_THAN, hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +570,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_LessThan(String hostname, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hostname", ConditionKey.CK_LESS_THAN, hostname); + RangeQueryBuilder builder = regRangeQ("hostname", ConditionKey.CK_LESS_THAN, hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +581,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_GreaterEqual(String hostname, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hostname", ConditionKey.CK_GREATER_EQUAL, hostname); + RangeQueryBuilder builder = regRangeQ("hostname", ConditionKey.CK_GREATER_EQUAL, hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -590,7 +592,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setHostname_LessEqual(String hostname, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("hostname", ConditionKey.CK_LESS_EQUAL, hostname); + RangeQueryBuilder builder = regRangeQ("hostname", ConditionKey.CK_LESS_EQUAL, hostname); if (opLambda != null) { opLambda.callback(builder); } @@ -611,29 +613,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -641,7 +643,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +654,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +665,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +676,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +687,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +698,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +709,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -718,7 +720,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -729,7 +731,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -750,29 +752,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_Term(String parameters, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("parameters", parameters); + TermQueryBuilder builder = regTermQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } } public void setParameters_Terms(Collection parametersList) { - setParameters_MatchPhrasePrefix(parametersList, null); + setParameters_Terms(parametersList, null); } - public void setParameters_MatchPhrasePrefix(Collection parametersList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("parameters", parametersList); + public void setParameters_Terms(Collection parametersList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("parameters", parametersList); if (opLambda != null) { opLambda.callback(builder); } } public void setParameters_InScope(Collection parametersList) { - setParameters_MatchPhrasePrefix(parametersList, null); + setParameters_Terms(parametersList, null); } public void setParameters_InScope(Collection parametersList, ConditionOptionCall opLambda) { - setParameters_MatchPhrasePrefix(parametersList, opLambda); + setParameters_Terms(parametersList, opLambda); } public void setParameters_Match(String parameters) { @@ -780,7 +782,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_Match(String parameters, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("parameters", parameters); + MatchQueryBuilder builder = regMatchQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +793,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_MatchPhrase(String parameters, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("parameters", parameters); + MatchQueryBuilder builder = regMatchPhraseQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +804,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_MatchPhrasePrefix(String parameters, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("parameters", parameters); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +815,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_Fuzzy(String parameters, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("parameters", parameters); + FuzzyQueryBuilder builder = regFuzzyQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +826,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_Prefix(String parameters, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("parameters", parameters); + PrefixQueryBuilder builder = regPrefixQ("parameters", parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +837,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_GreaterThan(String parameters, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("parameters", ConditionKey.CK_GREATER_THAN, parameters); + RangeQueryBuilder builder = regRangeQ("parameters", ConditionKey.CK_GREATER_THAN, parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -846,7 +848,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_LessThan(String parameters, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("parameters", ConditionKey.CK_LESS_THAN, parameters); + RangeQueryBuilder builder = regRangeQ("parameters", ConditionKey.CK_LESS_THAN, parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -857,7 +859,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_GreaterEqual(String parameters, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("parameters", ConditionKey.CK_GREATER_EQUAL, parameters); + RangeQueryBuilder builder = regRangeQ("parameters", ConditionKey.CK_GREATER_EQUAL, parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -868,7 +870,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setParameters_LessEqual(String parameters, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("parameters", ConditionKey.CK_LESS_EQUAL, parameters); + RangeQueryBuilder builder = regRangeQ("parameters", ConditionKey.CK_LESS_EQUAL, parameters); if (opLambda != null) { opLambda.callback(builder); } @@ -889,29 +891,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_Term(String password, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("password", password); + TermQueryBuilder builder = regTermQ("password", password); if (opLambda != null) { opLambda.callback(builder); } } public void setPassword_Terms(Collection passwordList) { - setPassword_MatchPhrasePrefix(passwordList, null); + setPassword_Terms(passwordList, null); } - public void setPassword_MatchPhrasePrefix(Collection passwordList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("password", passwordList); + public void setPassword_Terms(Collection passwordList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("password", passwordList); if (opLambda != null) { opLambda.callback(builder); } } public void setPassword_InScope(Collection passwordList) { - setPassword_MatchPhrasePrefix(passwordList, null); + setPassword_Terms(passwordList, null); } public void setPassword_InScope(Collection passwordList, ConditionOptionCall opLambda) { - setPassword_MatchPhrasePrefix(passwordList, opLambda); + setPassword_Terms(passwordList, opLambda); } public void setPassword_Match(String password) { @@ -919,7 +921,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_Match(String password, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("password", password); + MatchQueryBuilder builder = regMatchQ("password", password); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +932,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_MatchPhrase(String password, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("password", password); + MatchQueryBuilder builder = regMatchPhraseQ("password", password); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +943,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_MatchPhrasePrefix(String password, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("password", password); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("password", password); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +954,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_Fuzzy(String password, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("password", password); + FuzzyQueryBuilder builder = regFuzzyQ("password", password); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +965,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_Prefix(String password, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("password", password); + PrefixQueryBuilder builder = regPrefixQ("password", password); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +976,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_GreaterThan(String password, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("password", ConditionKey.CK_GREATER_THAN, password); + RangeQueryBuilder builder = regRangeQ("password", ConditionKey.CK_GREATER_THAN, password); if (opLambda != null) { opLambda.callback(builder); } @@ -985,7 +987,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_LessThan(String password, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("password", ConditionKey.CK_LESS_THAN, password); + RangeQueryBuilder builder = regRangeQ("password", ConditionKey.CK_LESS_THAN, password); if (opLambda != null) { opLambda.callback(builder); } @@ -996,7 +998,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_GreaterEqual(String password, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("password", ConditionKey.CK_GREATER_EQUAL, password); + RangeQueryBuilder builder = regRangeQ("password", ConditionKey.CK_GREATER_EQUAL, password); if (opLambda != null) { opLambda.callback(builder); } @@ -1007,7 +1009,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPassword_LessEqual(String password, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("password", ConditionKey.CK_LESS_EQUAL, password); + RangeQueryBuilder builder = regRangeQ("password", ConditionKey.CK_LESS_EQUAL, password); if (opLambda != null) { opLambda.callback(builder); } @@ -1028,29 +1030,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPort_Term(Integer port, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("port", port); + TermQueryBuilder builder = regTermQ("port", port); if (opLambda != null) { opLambda.callback(builder); } } public void setPort_Terms(Collection portList) { - setPort_MatchPhrasePrefix(portList, null); + setPort_Terms(portList, null); } - public void setPort_MatchPhrasePrefix(Collection portList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("port", portList); + public void setPort_Terms(Collection portList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("port", portList); if (opLambda != null) { opLambda.callback(builder); } } public void setPort_InScope(Collection portList) { - setPort_MatchPhrasePrefix(portList, null); + setPort_Terms(portList, null); } public void setPort_InScope(Collection portList, ConditionOptionCall opLambda) { - setPort_MatchPhrasePrefix(portList, opLambda); + setPort_Terms(portList, opLambda); } public void setPort_Match(Integer port) { @@ -1058,7 +1060,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPort_Match(Integer port, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("port", port); + MatchQueryBuilder builder = regMatchQ("port", port); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1071,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPort_MatchPhrase(Integer port, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("port", port); + MatchQueryBuilder builder = regMatchPhraseQ("port", port); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1082,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPort_MatchPhrasePrefix(Integer port, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("port", port); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("port", port); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1093,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPort_Fuzzy(Integer port, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("port", port); + FuzzyQueryBuilder builder = regFuzzyQ("port", port); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1104,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPort_GreaterThan(Integer port, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("port", ConditionKey.CK_GREATER_THAN, port); + RangeQueryBuilder builder = regRangeQ("port", ConditionKey.CK_GREATER_THAN, port); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1115,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPort_LessThan(Integer port, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("port", ConditionKey.CK_LESS_THAN, port); + RangeQueryBuilder builder = regRangeQ("port", ConditionKey.CK_LESS_THAN, port); if (opLambda != null) { opLambda.callback(builder); } @@ -1124,7 +1126,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPort_GreaterEqual(Integer port, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("port", ConditionKey.CK_GREATER_EQUAL, port); + RangeQueryBuilder builder = regRangeQ("port", ConditionKey.CK_GREATER_EQUAL, port); if (opLambda != null) { opLambda.callback(builder); } @@ -1135,7 +1137,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setPort_LessEqual(Integer port, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("port", ConditionKey.CK_LESS_EQUAL, port); + RangeQueryBuilder builder = regRangeQ("port", ConditionKey.CK_LESS_EQUAL, port); if (opLambda != null) { opLambda.callback(builder); } @@ -1156,29 +1158,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_Term(String protocolScheme, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("protocolScheme", protocolScheme); + TermQueryBuilder builder = regTermQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } } public void setProtocolScheme_Terms(Collection protocolSchemeList) { - setProtocolScheme_MatchPhrasePrefix(protocolSchemeList, null); + setProtocolScheme_Terms(protocolSchemeList, null); } - public void setProtocolScheme_MatchPhrasePrefix(Collection protocolSchemeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("protocolScheme", protocolSchemeList); + public void setProtocolScheme_Terms(Collection protocolSchemeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("protocolScheme", protocolSchemeList); if (opLambda != null) { opLambda.callback(builder); } } public void setProtocolScheme_InScope(Collection protocolSchemeList) { - setProtocolScheme_MatchPhrasePrefix(protocolSchemeList, null); + setProtocolScheme_Terms(protocolSchemeList, null); } public void setProtocolScheme_InScope(Collection protocolSchemeList, ConditionOptionCall opLambda) { - setProtocolScheme_MatchPhrasePrefix(protocolSchemeList, opLambda); + setProtocolScheme_Terms(protocolSchemeList, opLambda); } public void setProtocolScheme_Match(String protocolScheme) { @@ -1186,7 +1188,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_Match(String protocolScheme, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("protocolScheme", protocolScheme); + MatchQueryBuilder builder = regMatchQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1197,7 +1199,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_MatchPhrase(String protocolScheme, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("protocolScheme", protocolScheme); + MatchQueryBuilder builder = regMatchPhraseQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1208,7 +1210,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_MatchPhrasePrefix(String protocolScheme, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("protocolScheme", protocolScheme); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1219,7 +1221,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_Fuzzy(String protocolScheme, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("protocolScheme", protocolScheme); + FuzzyQueryBuilder builder = regFuzzyQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1230,7 +1232,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_Prefix(String protocolScheme, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("protocolScheme", protocolScheme); + PrefixQueryBuilder builder = regPrefixQ("protocolScheme", protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1241,7 +1243,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_GreaterThan(String protocolScheme, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("protocolScheme", ConditionKey.CK_GREATER_THAN, protocolScheme); + RangeQueryBuilder builder = regRangeQ("protocolScheme", ConditionKey.CK_GREATER_THAN, protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1252,7 +1254,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_LessThan(String protocolScheme, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("protocolScheme", ConditionKey.CK_LESS_THAN, protocolScheme); + RangeQueryBuilder builder = regRangeQ("protocolScheme", ConditionKey.CK_LESS_THAN, protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1263,7 +1265,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_GreaterEqual(String protocolScheme, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("protocolScheme", ConditionKey.CK_GREATER_EQUAL, protocolScheme); + RangeQueryBuilder builder = regRangeQ("protocolScheme", ConditionKey.CK_GREATER_EQUAL, protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1274,7 +1276,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setProtocolScheme_LessEqual(String protocolScheme, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("protocolScheme", ConditionKey.CK_LESS_EQUAL, protocolScheme); + RangeQueryBuilder builder = regRangeQ("protocolScheme", ConditionKey.CK_LESS_EQUAL, protocolScheme); if (opLambda != null) { opLambda.callback(builder); } @@ -1295,29 +1297,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -1325,7 +1327,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1336,7 +1338,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1347,7 +1349,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1358,7 +1360,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1369,7 +1371,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1380,7 +1382,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1391,7 +1393,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1402,7 +1404,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1413,7 +1415,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -1434,29 +1436,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -1464,7 +1466,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1475,7 +1477,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1486,7 +1488,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1497,7 +1499,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1508,7 +1510,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1519,7 +1521,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1530,7 +1532,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1541,7 +1543,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1562,29 +1564,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_Term(String username, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("username", username); + TermQueryBuilder builder = regTermQ("username", username); if (opLambda != null) { opLambda.callback(builder); } } public void setUsername_Terms(Collection usernameList) { - setUsername_MatchPhrasePrefix(usernameList, null); + setUsername_Terms(usernameList, null); } - public void setUsername_MatchPhrasePrefix(Collection usernameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("username", usernameList); + public void setUsername_Terms(Collection usernameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("username", usernameList); if (opLambda != null) { opLambda.callback(builder); } } public void setUsername_InScope(Collection usernameList) { - setUsername_MatchPhrasePrefix(usernameList, null); + setUsername_Terms(usernameList, null); } public void setUsername_InScope(Collection usernameList, ConditionOptionCall opLambda) { - setUsername_MatchPhrasePrefix(usernameList, opLambda); + setUsername_Terms(usernameList, opLambda); } public void setUsername_Match(String username) { @@ -1592,7 +1594,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_Match(String username, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("username", username); + MatchQueryBuilder builder = regMatchQ("username", username); if (opLambda != null) { opLambda.callback(builder); } @@ -1603,7 +1605,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_MatchPhrase(String username, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("username", username); + MatchQueryBuilder builder = regMatchPhraseQ("username", username); if (opLambda != null) { opLambda.callback(builder); } @@ -1614,7 +1616,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_MatchPhrasePrefix(String username, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("username", username); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("username", username); if (opLambda != null) { opLambda.callback(builder); } @@ -1625,7 +1627,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_Fuzzy(String username, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("username", username); + FuzzyQueryBuilder builder = regFuzzyQ("username", username); if (opLambda != null) { opLambda.callback(builder); } @@ -1636,7 +1638,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_Prefix(String username, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("username", username); + PrefixQueryBuilder builder = regPrefixQ("username", username); if (opLambda != null) { opLambda.callback(builder); } @@ -1647,7 +1649,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_GreaterThan(String username, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("username", ConditionKey.CK_GREATER_THAN, username); + RangeQueryBuilder builder = regRangeQ("username", ConditionKey.CK_GREATER_THAN, username); if (opLambda != null) { opLambda.callback(builder); } @@ -1658,7 +1660,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_LessThan(String username, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("username", ConditionKey.CK_LESS_THAN, username); + RangeQueryBuilder builder = regRangeQ("username", ConditionKey.CK_LESS_THAN, username); if (opLambda != null) { opLambda.callback(builder); } @@ -1669,7 +1671,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_GreaterEqual(String username, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("username", ConditionKey.CK_GREATER_EQUAL, username); + RangeQueryBuilder builder = regRangeQ("username", ConditionKey.CK_GREATER_EQUAL, username); if (opLambda != null) { opLambda.callback(builder); } @@ -1680,7 +1682,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setUsername_LessEqual(String username, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("username", ConditionKey.CK_LESS_EQUAL, username); + RangeQueryBuilder builder = regRangeQ("username", ConditionKey.CK_LESS_EQUAL, username); if (opLambda != null) { opLambda.callback(builder); } @@ -1701,29 +1703,29 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setWebConfigId_Term(String webConfigId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("webConfigId", webConfigId); + TermQueryBuilder builder = regTermQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } } public void setWebConfigId_Terms(Collection webConfigIdList) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, null); + setWebConfigId_Terms(webConfigIdList, null); } - public void setWebConfigId_MatchPhrasePrefix(Collection webConfigIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("webConfigId", webConfigIdList); + public void setWebConfigId_Terms(Collection webConfigIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("webConfigId", webConfigIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setWebConfigId_InScope(Collection webConfigIdList) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, null); + setWebConfigId_Terms(webConfigIdList, null); } public void setWebConfigId_InScope(Collection webConfigIdList, ConditionOptionCall opLambda) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, opLambda); + setWebConfigId_Terms(webConfigIdList, opLambda); } public void setWebConfigId_Match(String webConfigId) { @@ -1731,7 +1733,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setWebConfigId_Match(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1742,7 +1744,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setWebConfigId_MatchPhrase(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchPhraseQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1753,7 +1755,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setWebConfigId_MatchPhrasePrefix(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1764,7 +1766,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setWebConfigId_Fuzzy(String webConfigId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("webConfigId", webConfigId); + FuzzyQueryBuilder builder = regFuzzyQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1775,7 +1777,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("webConfigId", webConfigId); + PrefixQueryBuilder builder = regPrefixQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1786,7 +1788,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1797,7 +1799,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1808,7 +1810,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -1819,7 +1821,7 @@ public abstract class BsWebAuthenticationCQ extends AbstractConditionQuery { } public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigCQ.java index 21b324743..a729412be 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.WebConfigCQ; +import org.codelibs.fess.es.cbean.cf.WebConfigCF; import org.dbflute.cbean.ckey.ConditionKey; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.FilteredQueryBuilder; @@ -28,16 +29,16 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { return "web_config"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { WebConfigCQ query = new WebConfigCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + WebConfigCF filter = new WebConfigCF(); + filteredLambda.callback(query, filter); + if (query.hasQueries()) { + FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter()); if (opLambda != null) { opLambda.callback(builder); } @@ -53,8 +54,8 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { WebConfigCQ shouldQuery = new WebConfigCQ(); WebConfigCQ mustNotQuery = new WebConfigCQ(); 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); } @@ -66,29 +67,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setAvailable_Term(Boolean available, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("available", available); + TermQueryBuilder builder = regTermQ("available", available); if (opLambda != null) { opLambda.callback(builder); } } public void setAvailable_Terms(Collection availableList) { - setAvailable_MatchPhrasePrefix(availableList, null); + setAvailable_Terms(availableList, null); } - public void setAvailable_MatchPhrasePrefix(Collection availableList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("available", availableList); + public void setAvailable_Terms(Collection availableList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("available", availableList); if (opLambda != null) { opLambda.callback(builder); } } public void setAvailable_InScope(Collection availableList) { - setAvailable_MatchPhrasePrefix(availableList, null); + setAvailable_Terms(availableList, null); } public void setAvailable_InScope(Collection availableList, ConditionOptionCall opLambda) { - setAvailable_MatchPhrasePrefix(availableList, opLambda); + setAvailable_Terms(availableList, opLambda); } public void setAvailable_Match(Boolean available) { @@ -96,7 +97,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setAvailable_Match(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("available", available); + MatchQueryBuilder builder = regMatchQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +108,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setAvailable_MatchPhrase(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("available", available); + MatchQueryBuilder builder = regMatchPhraseQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +119,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setAvailable_MatchPhrasePrefix(Boolean available, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("available", available); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +130,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setAvailable_Fuzzy(Boolean available, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("available", available); + FuzzyQueryBuilder builder = regFuzzyQ("available", available); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +141,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setAvailable_GreaterThan(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_GREATER_THAN, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_GREATER_THAN, available); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +152,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setAvailable_LessThan(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_LESS_THAN, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_LESS_THAN, available); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +163,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setAvailable_GreaterEqual(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_GREATER_EQUAL, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_GREATER_EQUAL, available); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +174,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setAvailable_LessEqual(Boolean available, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("available", ConditionKey.CK_LESS_EQUAL, available); + RangeQueryBuilder builder = regRangeQ("available", ConditionKey.CK_LESS_EQUAL, available); if (opLambda != null) { opLambda.callback(builder); } @@ -194,29 +195,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setBoost_Term(Float boost, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("boost", boost); + TermQueryBuilder builder = regTermQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } } public void setBoost_Terms(Collection boostList) { - setBoost_MatchPhrasePrefix(boostList, null); + setBoost_Terms(boostList, null); } - public void setBoost_MatchPhrasePrefix(Collection boostList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("boost", boostList); + public void setBoost_Terms(Collection boostList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("boost", boostList); if (opLambda != null) { opLambda.callback(builder); } } public void setBoost_InScope(Collection boostList) { - setBoost_MatchPhrasePrefix(boostList, null); + setBoost_Terms(boostList, null); } public void setBoost_InScope(Collection boostList, ConditionOptionCall opLambda) { - setBoost_MatchPhrasePrefix(boostList, opLambda); + setBoost_Terms(boostList, opLambda); } public void setBoost_Match(Float boost) { @@ -224,7 +225,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setBoost_Match(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("boost", boost); + MatchQueryBuilder builder = regMatchQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -235,7 +236,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setBoost_MatchPhrase(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("boost", boost); + MatchQueryBuilder builder = regMatchPhraseQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +247,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setBoost_MatchPhrasePrefix(Float boost, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("boost", boost); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +258,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setBoost_Fuzzy(Float boost, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("boost", boost); + FuzzyQueryBuilder builder = regFuzzyQ("boost", boost); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +269,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setBoost_GreaterThan(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_THAN, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +280,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setBoost_LessThan(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_THAN, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_THAN, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +291,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setBoost_GreaterEqual(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +302,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setBoost_LessEqual(Float boost, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost); + RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_EQUAL, boost); if (opLambda != null) { opLambda.callback(builder); } @@ -322,29 +323,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_Term(String configParameter, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("configParameter", configParameter); + TermQueryBuilder builder = regTermQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } } public void setConfigParameter_Terms(Collection configParameterList) { - setConfigParameter_MatchPhrasePrefix(configParameterList, null); + setConfigParameter_Terms(configParameterList, null); } - public void setConfigParameter_MatchPhrasePrefix(Collection configParameterList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("configParameter", configParameterList); + public void setConfigParameter_Terms(Collection configParameterList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("configParameter", configParameterList); if (opLambda != null) { opLambda.callback(builder); } } public void setConfigParameter_InScope(Collection configParameterList) { - setConfigParameter_MatchPhrasePrefix(configParameterList, null); + setConfigParameter_Terms(configParameterList, null); } public void setConfigParameter_InScope(Collection configParameterList, ConditionOptionCall opLambda) { - setConfigParameter_MatchPhrasePrefix(configParameterList, opLambda); + setConfigParameter_Terms(configParameterList, opLambda); } public void setConfigParameter_Match(String configParameter) { @@ -352,7 +353,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_Match(String configParameter, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("configParameter", configParameter); + MatchQueryBuilder builder = regMatchQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -363,7 +364,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_MatchPhrase(String configParameter, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("configParameter", configParameter); + MatchQueryBuilder builder = regMatchPhraseQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -374,7 +375,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_MatchPhrasePrefix(String configParameter, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("configParameter", configParameter); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +386,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_Fuzzy(String configParameter, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("configParameter", configParameter); + FuzzyQueryBuilder builder = regFuzzyQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +397,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_Prefix(String configParameter, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("configParameter", configParameter); + PrefixQueryBuilder builder = regPrefixQ("configParameter", configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +408,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_GreaterThan(String configParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configParameter", ConditionKey.CK_GREATER_THAN, configParameter); + RangeQueryBuilder builder = regRangeQ("configParameter", ConditionKey.CK_GREATER_THAN, configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +419,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_LessThan(String configParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configParameter", ConditionKey.CK_LESS_THAN, configParameter); + RangeQueryBuilder builder = regRangeQ("configParameter", ConditionKey.CK_LESS_THAN, configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +430,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_GreaterEqual(String configParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configParameter", ConditionKey.CK_GREATER_EQUAL, configParameter); + RangeQueryBuilder builder = regRangeQ("configParameter", ConditionKey.CK_GREATER_EQUAL, configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +441,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setConfigParameter_LessEqual(String configParameter, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("configParameter", ConditionKey.CK_LESS_EQUAL, configParameter); + RangeQueryBuilder builder = regRangeQ("configParameter", ConditionKey.CK_LESS_EQUAL, configParameter); if (opLambda != null) { opLambda.callback(builder); } @@ -461,29 +462,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Term(String createdBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdBy", createdBy); + TermQueryBuilder builder = regTermQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_Terms(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } - public void setCreatedBy_MatchPhrasePrefix(Collection createdByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdBy", createdByList); + public void setCreatedBy_Terms(Collection createdByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdBy", createdByList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedBy_InScope(Collection createdByList) { - setCreatedBy_MatchPhrasePrefix(createdByList, null); + setCreatedBy_Terms(createdByList, null); } public void setCreatedBy_InScope(Collection createdByList, ConditionOptionCall opLambda) { - setCreatedBy_MatchPhrasePrefix(createdByList, opLambda); + setCreatedBy_Terms(createdByList, opLambda); } public void setCreatedBy_Match(String createdBy) { @@ -491,7 +492,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Match(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -502,7 +503,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -513,7 +514,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdBy", createdBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -524,7 +525,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdBy", createdBy); + FuzzyQueryBuilder builder = regFuzzyQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -535,7 +536,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("createdBy", createdBy); + PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -546,7 +547,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -557,7 +558,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -568,7 +569,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -579,7 +580,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); + RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, createdBy); if (opLambda != null) { opLambda.callback(builder); } @@ -600,29 +601,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_Term(Long createdTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("createdTime", createdTime); + TermQueryBuilder builder = regTermQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_Terms(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } - public void setCreatedTime_MatchPhrasePrefix(Collection createdTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("createdTime", createdTimeList); + public void setCreatedTime_Terms(Collection createdTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setCreatedTime_InScope(Collection createdTimeList) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, null); + setCreatedTime_Terms(createdTimeList, null); } public void setCreatedTime_InScope(Collection createdTimeList, ConditionOptionCall opLambda) { - setCreatedTime_MatchPhrasePrefix(createdTimeList, opLambda); + setCreatedTime_Terms(createdTimeList, opLambda); } public void setCreatedTime_Match(Long createdTime) { @@ -630,7 +631,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_Match(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -641,7 +642,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -652,7 +653,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("createdTime", createdTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -663,7 +664,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("createdTime", createdTime); + FuzzyQueryBuilder builder = regFuzzyQ("createdTime", createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -674,7 +675,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -685,7 +686,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -696,7 +697,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -707,7 +708,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); + RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, createdTime); if (opLambda != null) { opLambda.callback(builder); } @@ -728,29 +729,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setDepth_Term(Integer depth, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("depth", depth); + TermQueryBuilder builder = regTermQ("depth", depth); if (opLambda != null) { opLambda.callback(builder); } } public void setDepth_Terms(Collection depthList) { - setDepth_MatchPhrasePrefix(depthList, null); + setDepth_Terms(depthList, null); } - public void setDepth_MatchPhrasePrefix(Collection depthList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("depth", depthList); + public void setDepth_Terms(Collection depthList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("depth", depthList); if (opLambda != null) { opLambda.callback(builder); } } public void setDepth_InScope(Collection depthList) { - setDepth_MatchPhrasePrefix(depthList, null); + setDepth_Terms(depthList, null); } public void setDepth_InScope(Collection depthList, ConditionOptionCall opLambda) { - setDepth_MatchPhrasePrefix(depthList, opLambda); + setDepth_Terms(depthList, opLambda); } public void setDepth_Match(Integer depth) { @@ -758,7 +759,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setDepth_Match(Integer depth, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("depth", depth); + MatchQueryBuilder builder = regMatchQ("depth", depth); if (opLambda != null) { opLambda.callback(builder); } @@ -769,7 +770,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setDepth_MatchPhrase(Integer depth, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("depth", depth); + MatchQueryBuilder builder = regMatchPhraseQ("depth", depth); if (opLambda != null) { opLambda.callback(builder); } @@ -780,7 +781,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setDepth_MatchPhrasePrefix(Integer depth, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("depth", depth); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("depth", depth); if (opLambda != null) { opLambda.callback(builder); } @@ -791,7 +792,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setDepth_Fuzzy(Integer depth, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("depth", depth); + FuzzyQueryBuilder builder = regFuzzyQ("depth", depth); if (opLambda != null) { opLambda.callback(builder); } @@ -802,7 +803,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setDepth_GreaterThan(Integer depth, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("depth", ConditionKey.CK_GREATER_THAN, depth); + RangeQueryBuilder builder = regRangeQ("depth", ConditionKey.CK_GREATER_THAN, depth); if (opLambda != null) { opLambda.callback(builder); } @@ -813,7 +814,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setDepth_LessThan(Integer depth, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("depth", ConditionKey.CK_LESS_THAN, depth); + RangeQueryBuilder builder = regRangeQ("depth", ConditionKey.CK_LESS_THAN, depth); if (opLambda != null) { opLambda.callback(builder); } @@ -824,7 +825,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setDepth_GreaterEqual(Integer depth, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("depth", ConditionKey.CK_GREATER_EQUAL, depth); + RangeQueryBuilder builder = regRangeQ("depth", ConditionKey.CK_GREATER_EQUAL, depth); if (opLambda != null) { opLambda.callback(builder); } @@ -835,7 +836,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setDepth_LessEqual(Integer depth, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("depth", ConditionKey.CK_LESS_EQUAL, depth); + RangeQueryBuilder builder = regRangeQ("depth", ConditionKey.CK_LESS_EQUAL, depth); if (opLambda != null) { opLambda.callback(builder); } @@ -856,29 +857,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedDocUrls_Term(String excludedDocUrls, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("excludedDocUrls", excludedDocUrls); + TermQueryBuilder builder = regTermQ("excludedDocUrls", excludedDocUrls); if (opLambda != null) { opLambda.callback(builder); } } public void setExcludedDocUrls_Terms(Collection excludedDocUrlsList) { - setExcludedDocUrls_MatchPhrasePrefix(excludedDocUrlsList, null); + setExcludedDocUrls_Terms(excludedDocUrlsList, null); } - public void setExcludedDocUrls_MatchPhrasePrefix(Collection excludedDocUrlsList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("excludedDocUrls", excludedDocUrlsList); + public void setExcludedDocUrls_Terms(Collection excludedDocUrlsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("excludedDocUrls", excludedDocUrlsList); if (opLambda != null) { opLambda.callback(builder); } } public void setExcludedDocUrls_InScope(Collection excludedDocUrlsList) { - setExcludedDocUrls_MatchPhrasePrefix(excludedDocUrlsList, null); + setExcludedDocUrls_Terms(excludedDocUrlsList, null); } public void setExcludedDocUrls_InScope(Collection excludedDocUrlsList, ConditionOptionCall opLambda) { - setExcludedDocUrls_MatchPhrasePrefix(excludedDocUrlsList, opLambda); + setExcludedDocUrls_Terms(excludedDocUrlsList, opLambda); } public void setExcludedDocUrls_Match(String excludedDocUrls) { @@ -886,7 +887,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedDocUrls_Match(String excludedDocUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("excludedDocUrls", excludedDocUrls); + MatchQueryBuilder builder = regMatchQ("excludedDocUrls", excludedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -897,7 +898,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedDocUrls_MatchPhrase(String excludedDocUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("excludedDocUrls", excludedDocUrls); + MatchQueryBuilder builder = regMatchPhraseQ("excludedDocUrls", excludedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -908,7 +909,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedDocUrls_MatchPhrasePrefix(String excludedDocUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("excludedDocUrls", excludedDocUrls); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("excludedDocUrls", excludedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -919,7 +920,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedDocUrls_Fuzzy(String excludedDocUrls, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("excludedDocUrls", excludedDocUrls); + FuzzyQueryBuilder builder = regFuzzyQ("excludedDocUrls", excludedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -930,7 +931,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedDocUrls_Prefix(String excludedDocUrls, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("excludedDocUrls", excludedDocUrls); + PrefixQueryBuilder builder = regPrefixQ("excludedDocUrls", excludedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -941,7 +942,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedDocUrls_GreaterThan(String excludedDocUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedDocUrls", ConditionKey.CK_GREATER_THAN, excludedDocUrls); + RangeQueryBuilder builder = regRangeQ("excludedDocUrls", ConditionKey.CK_GREATER_THAN, excludedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -952,7 +953,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedDocUrls_LessThan(String excludedDocUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedDocUrls", ConditionKey.CK_LESS_THAN, excludedDocUrls); + RangeQueryBuilder builder = regRangeQ("excludedDocUrls", ConditionKey.CK_LESS_THAN, excludedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -963,7 +964,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedDocUrls_GreaterEqual(String excludedDocUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedDocUrls", ConditionKey.CK_GREATER_EQUAL, excludedDocUrls); + RangeQueryBuilder builder = regRangeQ("excludedDocUrls", ConditionKey.CK_GREATER_EQUAL, excludedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -974,7 +975,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedDocUrls_LessEqual(String excludedDocUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedDocUrls", ConditionKey.CK_LESS_EQUAL, excludedDocUrls); + RangeQueryBuilder builder = regRangeQ("excludedDocUrls", ConditionKey.CK_LESS_EQUAL, excludedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -995,29 +996,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedUrls_Term(String excludedUrls, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("excludedUrls", excludedUrls); + TermQueryBuilder builder = regTermQ("excludedUrls", excludedUrls); if (opLambda != null) { opLambda.callback(builder); } } public void setExcludedUrls_Terms(Collection excludedUrlsList) { - setExcludedUrls_MatchPhrasePrefix(excludedUrlsList, null); + setExcludedUrls_Terms(excludedUrlsList, null); } - public void setExcludedUrls_MatchPhrasePrefix(Collection excludedUrlsList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("excludedUrls", excludedUrlsList); + public void setExcludedUrls_Terms(Collection excludedUrlsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("excludedUrls", excludedUrlsList); if (opLambda != null) { opLambda.callback(builder); } } public void setExcludedUrls_InScope(Collection excludedUrlsList) { - setExcludedUrls_MatchPhrasePrefix(excludedUrlsList, null); + setExcludedUrls_Terms(excludedUrlsList, null); } public void setExcludedUrls_InScope(Collection excludedUrlsList, ConditionOptionCall opLambda) { - setExcludedUrls_MatchPhrasePrefix(excludedUrlsList, opLambda); + setExcludedUrls_Terms(excludedUrlsList, opLambda); } public void setExcludedUrls_Match(String excludedUrls) { @@ -1025,7 +1026,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedUrls_Match(String excludedUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("excludedUrls", excludedUrls); + MatchQueryBuilder builder = regMatchQ("excludedUrls", excludedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1036,7 +1037,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedUrls_MatchPhrase(String excludedUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("excludedUrls", excludedUrls); + MatchQueryBuilder builder = regMatchPhraseQ("excludedUrls", excludedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1047,7 +1048,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedUrls_MatchPhrasePrefix(String excludedUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("excludedUrls", excludedUrls); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("excludedUrls", excludedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1058,7 +1059,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedUrls_Fuzzy(String excludedUrls, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("excludedUrls", excludedUrls); + FuzzyQueryBuilder builder = regFuzzyQ("excludedUrls", excludedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1069,7 +1070,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedUrls_Prefix(String excludedUrls, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("excludedUrls", excludedUrls); + PrefixQueryBuilder builder = regPrefixQ("excludedUrls", excludedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1080,7 +1081,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedUrls_GreaterThan(String excludedUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedUrls", ConditionKey.CK_GREATER_THAN, excludedUrls); + RangeQueryBuilder builder = regRangeQ("excludedUrls", ConditionKey.CK_GREATER_THAN, excludedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1091,7 +1092,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedUrls_LessThan(String excludedUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedUrls", ConditionKey.CK_LESS_THAN, excludedUrls); + RangeQueryBuilder builder = regRangeQ("excludedUrls", ConditionKey.CK_LESS_THAN, excludedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1102,7 +1103,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedUrls_GreaterEqual(String excludedUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedUrls", ConditionKey.CK_GREATER_EQUAL, excludedUrls); + RangeQueryBuilder builder = regRangeQ("excludedUrls", ConditionKey.CK_GREATER_EQUAL, excludedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1113,7 +1114,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setExcludedUrls_LessEqual(String excludedUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("excludedUrls", ConditionKey.CK_LESS_EQUAL, excludedUrls); + RangeQueryBuilder builder = regRangeQ("excludedUrls", ConditionKey.CK_LESS_EQUAL, excludedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1134,29 +1135,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -1164,7 +1165,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1175,7 +1176,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1186,7 +1187,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1197,7 +1198,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1208,7 +1209,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -1219,7 +1220,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1230,7 +1231,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1241,7 +1242,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1252,7 +1253,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -1273,29 +1274,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedDocUrls_Term(String includedDocUrls, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("includedDocUrls", includedDocUrls); + TermQueryBuilder builder = regTermQ("includedDocUrls", includedDocUrls); if (opLambda != null) { opLambda.callback(builder); } } public void setIncludedDocUrls_Terms(Collection includedDocUrlsList) { - setIncludedDocUrls_MatchPhrasePrefix(includedDocUrlsList, null); + setIncludedDocUrls_Terms(includedDocUrlsList, null); } - public void setIncludedDocUrls_MatchPhrasePrefix(Collection includedDocUrlsList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("includedDocUrls", includedDocUrlsList); + public void setIncludedDocUrls_Terms(Collection includedDocUrlsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("includedDocUrls", includedDocUrlsList); if (opLambda != null) { opLambda.callback(builder); } } public void setIncludedDocUrls_InScope(Collection includedDocUrlsList) { - setIncludedDocUrls_MatchPhrasePrefix(includedDocUrlsList, null); + setIncludedDocUrls_Terms(includedDocUrlsList, null); } public void setIncludedDocUrls_InScope(Collection includedDocUrlsList, ConditionOptionCall opLambda) { - setIncludedDocUrls_MatchPhrasePrefix(includedDocUrlsList, opLambda); + setIncludedDocUrls_Terms(includedDocUrlsList, opLambda); } public void setIncludedDocUrls_Match(String includedDocUrls) { @@ -1303,7 +1304,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedDocUrls_Match(String includedDocUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("includedDocUrls", includedDocUrls); + MatchQueryBuilder builder = regMatchQ("includedDocUrls", includedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1314,7 +1315,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedDocUrls_MatchPhrase(String includedDocUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("includedDocUrls", includedDocUrls); + MatchQueryBuilder builder = regMatchPhraseQ("includedDocUrls", includedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1325,7 +1326,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedDocUrls_MatchPhrasePrefix(String includedDocUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("includedDocUrls", includedDocUrls); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("includedDocUrls", includedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1336,7 +1337,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedDocUrls_Fuzzy(String includedDocUrls, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("includedDocUrls", includedDocUrls); + FuzzyQueryBuilder builder = regFuzzyQ("includedDocUrls", includedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1347,7 +1348,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedDocUrls_Prefix(String includedDocUrls, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("includedDocUrls", includedDocUrls); + PrefixQueryBuilder builder = regPrefixQ("includedDocUrls", includedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1358,7 +1359,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedDocUrls_GreaterThan(String includedDocUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedDocUrls", ConditionKey.CK_GREATER_THAN, includedDocUrls); + RangeQueryBuilder builder = regRangeQ("includedDocUrls", ConditionKey.CK_GREATER_THAN, includedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1369,7 +1370,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedDocUrls_LessThan(String includedDocUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedDocUrls", ConditionKey.CK_LESS_THAN, includedDocUrls); + RangeQueryBuilder builder = regRangeQ("includedDocUrls", ConditionKey.CK_LESS_THAN, includedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1380,7 +1381,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedDocUrls_GreaterEqual(String includedDocUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedDocUrls", ConditionKey.CK_GREATER_EQUAL, includedDocUrls); + RangeQueryBuilder builder = regRangeQ("includedDocUrls", ConditionKey.CK_GREATER_EQUAL, includedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1391,7 +1392,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedDocUrls_LessEqual(String includedDocUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedDocUrls", ConditionKey.CK_LESS_EQUAL, includedDocUrls); + RangeQueryBuilder builder = regRangeQ("includedDocUrls", ConditionKey.CK_LESS_EQUAL, includedDocUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1412,29 +1413,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedUrls_Term(String includedUrls, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("includedUrls", includedUrls); + TermQueryBuilder builder = regTermQ("includedUrls", includedUrls); if (opLambda != null) { opLambda.callback(builder); } } public void setIncludedUrls_Terms(Collection includedUrlsList) { - setIncludedUrls_MatchPhrasePrefix(includedUrlsList, null); + setIncludedUrls_Terms(includedUrlsList, null); } - public void setIncludedUrls_MatchPhrasePrefix(Collection includedUrlsList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("includedUrls", includedUrlsList); + public void setIncludedUrls_Terms(Collection includedUrlsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("includedUrls", includedUrlsList); if (opLambda != null) { opLambda.callback(builder); } } public void setIncludedUrls_InScope(Collection includedUrlsList) { - setIncludedUrls_MatchPhrasePrefix(includedUrlsList, null); + setIncludedUrls_Terms(includedUrlsList, null); } public void setIncludedUrls_InScope(Collection includedUrlsList, ConditionOptionCall opLambda) { - setIncludedUrls_MatchPhrasePrefix(includedUrlsList, opLambda); + setIncludedUrls_Terms(includedUrlsList, opLambda); } public void setIncludedUrls_Match(String includedUrls) { @@ -1442,7 +1443,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedUrls_Match(String includedUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("includedUrls", includedUrls); + MatchQueryBuilder builder = regMatchQ("includedUrls", includedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1453,7 +1454,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedUrls_MatchPhrase(String includedUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("includedUrls", includedUrls); + MatchQueryBuilder builder = regMatchPhraseQ("includedUrls", includedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1464,7 +1465,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedUrls_MatchPhrasePrefix(String includedUrls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("includedUrls", includedUrls); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("includedUrls", includedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1475,7 +1476,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedUrls_Fuzzy(String includedUrls, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("includedUrls", includedUrls); + FuzzyQueryBuilder builder = regFuzzyQ("includedUrls", includedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1486,7 +1487,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedUrls_Prefix(String includedUrls, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("includedUrls", includedUrls); + PrefixQueryBuilder builder = regPrefixQ("includedUrls", includedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1497,7 +1498,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedUrls_GreaterThan(String includedUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedUrls", ConditionKey.CK_GREATER_THAN, includedUrls); + RangeQueryBuilder builder = regRangeQ("includedUrls", ConditionKey.CK_GREATER_THAN, includedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1508,7 +1509,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedUrls_LessThan(String includedUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedUrls", ConditionKey.CK_LESS_THAN, includedUrls); + RangeQueryBuilder builder = regRangeQ("includedUrls", ConditionKey.CK_LESS_THAN, includedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1519,7 +1520,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedUrls_GreaterEqual(String includedUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedUrls", ConditionKey.CK_GREATER_EQUAL, includedUrls); + RangeQueryBuilder builder = regRangeQ("includedUrls", ConditionKey.CK_GREATER_EQUAL, includedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1530,7 +1531,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIncludedUrls_LessEqual(String includedUrls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("includedUrls", ConditionKey.CK_LESS_EQUAL, includedUrls); + RangeQueryBuilder builder = regRangeQ("includedUrls", ConditionKey.CK_LESS_EQUAL, includedUrls); if (opLambda != null) { opLambda.callback(builder); } @@ -1551,29 +1552,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_Term(Integer intervalTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("intervalTime", intervalTime); + TermQueryBuilder builder = regTermQ("intervalTime", intervalTime); if (opLambda != null) { opLambda.callback(builder); } } public void setIntervalTime_Terms(Collection intervalTimeList) { - setIntervalTime_MatchPhrasePrefix(intervalTimeList, null); + setIntervalTime_Terms(intervalTimeList, null); } - public void setIntervalTime_MatchPhrasePrefix(Collection intervalTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("intervalTime", intervalTimeList); + public void setIntervalTime_Terms(Collection intervalTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("intervalTime", intervalTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setIntervalTime_InScope(Collection intervalTimeList) { - setIntervalTime_MatchPhrasePrefix(intervalTimeList, null); + setIntervalTime_Terms(intervalTimeList, null); } public void setIntervalTime_InScope(Collection intervalTimeList, ConditionOptionCall opLambda) { - setIntervalTime_MatchPhrasePrefix(intervalTimeList, opLambda); + setIntervalTime_Terms(intervalTimeList, opLambda); } public void setIntervalTime_Match(Integer intervalTime) { @@ -1581,7 +1582,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_Match(Integer intervalTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("intervalTime", intervalTime); + MatchQueryBuilder builder = regMatchQ("intervalTime", intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1592,7 +1593,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_MatchPhrase(Integer intervalTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("intervalTime", intervalTime); + MatchQueryBuilder builder = regMatchPhraseQ("intervalTime", intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1603,7 +1604,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_MatchPhrasePrefix(Integer intervalTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("intervalTime", intervalTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("intervalTime", intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1614,7 +1615,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_Fuzzy(Integer intervalTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("intervalTime", intervalTime); + FuzzyQueryBuilder builder = regFuzzyQ("intervalTime", intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1625,7 +1626,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_GreaterThan(Integer intervalTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("intervalTime", ConditionKey.CK_GREATER_THAN, intervalTime); + RangeQueryBuilder builder = regRangeQ("intervalTime", ConditionKey.CK_GREATER_THAN, intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1636,7 +1637,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_LessThan(Integer intervalTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("intervalTime", ConditionKey.CK_LESS_THAN, intervalTime); + RangeQueryBuilder builder = regRangeQ("intervalTime", ConditionKey.CK_LESS_THAN, intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1647,7 +1648,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_GreaterEqual(Integer intervalTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("intervalTime", ConditionKey.CK_GREATER_EQUAL, intervalTime); + RangeQueryBuilder builder = regRangeQ("intervalTime", ConditionKey.CK_GREATER_EQUAL, intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1658,7 +1659,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setIntervalTime_LessEqual(Integer intervalTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("intervalTime", ConditionKey.CK_LESS_EQUAL, intervalTime); + RangeQueryBuilder builder = regRangeQ("intervalTime", ConditionKey.CK_LESS_EQUAL, intervalTime); if (opLambda != null) { opLambda.callback(builder); } @@ -1679,29 +1680,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_Term(Long maxAccessCount, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("maxAccessCount", maxAccessCount); + TermQueryBuilder builder = regTermQ("maxAccessCount", maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } } public void setMaxAccessCount_Terms(Collection maxAccessCountList) { - setMaxAccessCount_MatchPhrasePrefix(maxAccessCountList, null); + setMaxAccessCount_Terms(maxAccessCountList, null); } - public void setMaxAccessCount_MatchPhrasePrefix(Collection maxAccessCountList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("maxAccessCount", maxAccessCountList); + public void setMaxAccessCount_Terms(Collection maxAccessCountList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("maxAccessCount", maxAccessCountList); if (opLambda != null) { opLambda.callback(builder); } } public void setMaxAccessCount_InScope(Collection maxAccessCountList) { - setMaxAccessCount_MatchPhrasePrefix(maxAccessCountList, null); + setMaxAccessCount_Terms(maxAccessCountList, null); } public void setMaxAccessCount_InScope(Collection maxAccessCountList, ConditionOptionCall opLambda) { - setMaxAccessCount_MatchPhrasePrefix(maxAccessCountList, opLambda); + setMaxAccessCount_Terms(maxAccessCountList, opLambda); } public void setMaxAccessCount_Match(Long maxAccessCount) { @@ -1709,7 +1710,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_Match(Long maxAccessCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("maxAccessCount", maxAccessCount); + MatchQueryBuilder builder = regMatchQ("maxAccessCount", maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1720,7 +1721,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_MatchPhrase(Long maxAccessCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("maxAccessCount", maxAccessCount); + MatchQueryBuilder builder = regMatchPhraseQ("maxAccessCount", maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1731,7 +1732,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_MatchPhrasePrefix(Long maxAccessCount, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("maxAccessCount", maxAccessCount); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("maxAccessCount", maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1742,7 +1743,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_Fuzzy(Long maxAccessCount, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("maxAccessCount", maxAccessCount); + FuzzyQueryBuilder builder = regFuzzyQ("maxAccessCount", maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1753,7 +1754,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_GreaterThan(Long maxAccessCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxAccessCount", ConditionKey.CK_GREATER_THAN, maxAccessCount); + RangeQueryBuilder builder = regRangeQ("maxAccessCount", ConditionKey.CK_GREATER_THAN, maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1764,7 +1765,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_LessThan(Long maxAccessCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxAccessCount", ConditionKey.CK_LESS_THAN, maxAccessCount); + RangeQueryBuilder builder = regRangeQ("maxAccessCount", ConditionKey.CK_LESS_THAN, maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1775,7 +1776,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_GreaterEqual(Long maxAccessCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxAccessCount", ConditionKey.CK_GREATER_EQUAL, maxAccessCount); + RangeQueryBuilder builder = regRangeQ("maxAccessCount", ConditionKey.CK_GREATER_EQUAL, maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1786,7 +1787,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setMaxAccessCount_LessEqual(Long maxAccessCount, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("maxAccessCount", ConditionKey.CK_LESS_EQUAL, maxAccessCount); + RangeQueryBuilder builder = regRangeQ("maxAccessCount", ConditionKey.CK_LESS_EQUAL, maxAccessCount); if (opLambda != null) { opLambda.callback(builder); } @@ -1807,29 +1808,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setName_Term(String name, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("name", name); + TermQueryBuilder builder = regTermQ("name", name); if (opLambda != null) { opLambda.callback(builder); } } public void setName_Terms(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } - public void setName_MatchPhrasePrefix(Collection nameList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("name", nameList); + public void setName_Terms(Collection nameList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("name", nameList); if (opLambda != null) { opLambda.callback(builder); } } public void setName_InScope(Collection nameList) { - setName_MatchPhrasePrefix(nameList, null); + setName_Terms(nameList, null); } public void setName_InScope(Collection nameList, ConditionOptionCall opLambda) { - setName_MatchPhrasePrefix(nameList, opLambda); + setName_Terms(nameList, opLambda); } public void setName_Match(String name) { @@ -1837,7 +1838,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setName_Match(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("name", name); + MatchQueryBuilder builder = regMatchQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1848,7 +1849,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setName_MatchPhrase(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("name", name); + MatchQueryBuilder builder = regMatchPhraseQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1859,7 +1860,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setName_MatchPhrasePrefix(String name, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("name", name); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1870,7 +1871,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setName_Fuzzy(String name, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("name", name); + FuzzyQueryBuilder builder = regFuzzyQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1881,7 +1882,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setName_Prefix(String name, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("name", name); + PrefixQueryBuilder builder = regPrefixQ("name", name); if (opLambda != null) { opLambda.callback(builder); } @@ -1892,7 +1893,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setName_GreaterThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1903,7 +1904,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setName_LessThan(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_THAN, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1914,7 +1915,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setName_GreaterEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1925,7 +1926,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setName_LessEqual(String name, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); + RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, name); if (opLambda != null) { opLambda.callback(builder); } @@ -1946,29 +1947,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_Term(Integer numOfThread, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("numOfThread", numOfThread); + TermQueryBuilder builder = regTermQ("numOfThread", numOfThread); if (opLambda != null) { opLambda.callback(builder); } } public void setNumOfThread_Terms(Collection numOfThreadList) { - setNumOfThread_MatchPhrasePrefix(numOfThreadList, null); + setNumOfThread_Terms(numOfThreadList, null); } - public void setNumOfThread_MatchPhrasePrefix(Collection numOfThreadList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("numOfThread", numOfThreadList); + public void setNumOfThread_Terms(Collection numOfThreadList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("numOfThread", numOfThreadList); if (opLambda != null) { opLambda.callback(builder); } } public void setNumOfThread_InScope(Collection numOfThreadList) { - setNumOfThread_MatchPhrasePrefix(numOfThreadList, null); + setNumOfThread_Terms(numOfThreadList, null); } public void setNumOfThread_InScope(Collection numOfThreadList, ConditionOptionCall opLambda) { - setNumOfThread_MatchPhrasePrefix(numOfThreadList, opLambda); + setNumOfThread_Terms(numOfThreadList, opLambda); } public void setNumOfThread_Match(Integer numOfThread) { @@ -1976,7 +1977,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_Match(Integer numOfThread, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("numOfThread", numOfThread); + MatchQueryBuilder builder = regMatchQ("numOfThread", numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -1987,7 +1988,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_MatchPhrase(Integer numOfThread, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("numOfThread", numOfThread); + MatchQueryBuilder builder = regMatchPhraseQ("numOfThread", numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -1998,7 +1999,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_MatchPhrasePrefix(Integer numOfThread, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("numOfThread", numOfThread); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("numOfThread", numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2009,7 +2010,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_Fuzzy(Integer numOfThread, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("numOfThread", numOfThread); + FuzzyQueryBuilder builder = regFuzzyQ("numOfThread", numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2020,7 +2021,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_GreaterThan(Integer numOfThread, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("numOfThread", ConditionKey.CK_GREATER_THAN, numOfThread); + RangeQueryBuilder builder = regRangeQ("numOfThread", ConditionKey.CK_GREATER_THAN, numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2031,7 +2032,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_LessThan(Integer numOfThread, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("numOfThread", ConditionKey.CK_LESS_THAN, numOfThread); + RangeQueryBuilder builder = regRangeQ("numOfThread", ConditionKey.CK_LESS_THAN, numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2042,7 +2043,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_GreaterEqual(Integer numOfThread, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("numOfThread", ConditionKey.CK_GREATER_EQUAL, numOfThread); + RangeQueryBuilder builder = regRangeQ("numOfThread", ConditionKey.CK_GREATER_EQUAL, numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2053,7 +2054,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setNumOfThread_LessEqual(Integer numOfThread, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("numOfThread", ConditionKey.CK_LESS_EQUAL, numOfThread); + RangeQueryBuilder builder = regRangeQ("numOfThread", ConditionKey.CK_LESS_EQUAL, numOfThread); if (opLambda != null) { opLambda.callback(builder); } @@ -2074,29 +2075,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("sortOrder", sortOrder); + TermQueryBuilder builder = regTermQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_Terms(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } - public void setSortOrder_MatchPhrasePrefix(Collection sortOrderList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("sortOrder", sortOrderList); + public void setSortOrder_Terms(Collection sortOrderList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList); if (opLambda != null) { opLambda.callback(builder); } } public void setSortOrder_InScope(Collection sortOrderList) { - setSortOrder_MatchPhrasePrefix(sortOrderList, null); + setSortOrder_Terms(sortOrderList, null); } public void setSortOrder_InScope(Collection sortOrderList, ConditionOptionCall opLambda) { - setSortOrder_MatchPhrasePrefix(sortOrderList, opLambda); + setSortOrder_Terms(sortOrderList, opLambda); } public void setSortOrder_Match(Integer sortOrder) { @@ -2104,7 +2105,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2115,7 +2116,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2126,7 +2127,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("sortOrder", sortOrder); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2137,7 +2138,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("sortOrder", sortOrder); + FuzzyQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2148,7 +2149,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2159,7 +2160,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2170,7 +2171,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2181,7 +2182,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); + RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, sortOrder); if (opLambda != null) { opLambda.callback(builder); } @@ -2202,29 +2203,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedBy", updatedBy); + TermQueryBuilder builder = regTermQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_Terms(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } - public void setUpdatedBy_MatchPhrasePrefix(Collection updatedByList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedBy", updatedByList); + public void setUpdatedBy_Terms(Collection updatedByList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedBy_InScope(Collection updatedByList) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, null); + setUpdatedBy_Terms(updatedByList, null); } public void setUpdatedBy_InScope(Collection updatedByList, ConditionOptionCall opLambda) { - setUpdatedBy_MatchPhrasePrefix(updatedByList, opLambda); + setUpdatedBy_Terms(updatedByList, opLambda); } public void setUpdatedBy_Match(String updatedBy) { @@ -2232,7 +2233,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2243,7 +2244,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2254,7 +2255,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedBy", updatedBy); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2265,7 +2266,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedBy", updatedBy); + FuzzyQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2276,7 +2277,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("updatedBy", updatedBy); + PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2287,7 +2288,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2298,7 +2299,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2309,7 +2310,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2320,7 +2321,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); + RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, updatedBy); if (opLambda != null) { opLambda.callback(builder); } @@ -2341,29 +2342,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("updatedTime", updatedTime); + TermQueryBuilder builder = regTermQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_Terms(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } - public void setUpdatedTime_MatchPhrasePrefix(Collection updatedTimeList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("updatedTime", updatedTimeList); + public void setUpdatedTime_Terms(Collection updatedTimeList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList); if (opLambda != null) { opLambda.callback(builder); } } public void setUpdatedTime_InScope(Collection updatedTimeList) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, null); + setUpdatedTime_Terms(updatedTimeList, null); } public void setUpdatedTime_InScope(Collection updatedTimeList, ConditionOptionCall opLambda) { - setUpdatedTime_MatchPhrasePrefix(updatedTimeList, opLambda); + setUpdatedTime_Terms(updatedTimeList, opLambda); } public void setUpdatedTime_Match(Long updatedTime) { @@ -2371,7 +2372,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2382,7 +2383,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2393,7 +2394,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("updatedTime", updatedTime); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2404,7 +2405,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("updatedTime", updatedTime); + FuzzyQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2415,7 +2416,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2426,7 +2427,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2437,7 +2438,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2448,7 +2449,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); + RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, updatedTime); if (opLambda != null) { opLambda.callback(builder); } @@ -2469,29 +2470,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUrls_Term(String urls, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("urls", urls); + TermQueryBuilder builder = regTermQ("urls", urls); if (opLambda != null) { opLambda.callback(builder); } } public void setUrls_Terms(Collection urlsList) { - setUrls_MatchPhrasePrefix(urlsList, null); + setUrls_Terms(urlsList, null); } - public void setUrls_MatchPhrasePrefix(Collection urlsList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("urls", urlsList); + public void setUrls_Terms(Collection urlsList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("urls", urlsList); if (opLambda != null) { opLambda.callback(builder); } } public void setUrls_InScope(Collection urlsList) { - setUrls_MatchPhrasePrefix(urlsList, null); + setUrls_Terms(urlsList, null); } public void setUrls_InScope(Collection urlsList, ConditionOptionCall opLambda) { - setUrls_MatchPhrasePrefix(urlsList, opLambda); + setUrls_Terms(urlsList, opLambda); } public void setUrls_Match(String urls) { @@ -2499,7 +2500,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUrls_Match(String urls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("urls", urls); + MatchQueryBuilder builder = regMatchQ("urls", urls); if (opLambda != null) { opLambda.callback(builder); } @@ -2510,7 +2511,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUrls_MatchPhrase(String urls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("urls", urls); + MatchQueryBuilder builder = regMatchPhraseQ("urls", urls); if (opLambda != null) { opLambda.callback(builder); } @@ -2521,7 +2522,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUrls_MatchPhrasePrefix(String urls, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("urls", urls); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("urls", urls); if (opLambda != null) { opLambda.callback(builder); } @@ -2532,7 +2533,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUrls_Fuzzy(String urls, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("urls", urls); + FuzzyQueryBuilder builder = regFuzzyQ("urls", urls); if (opLambda != null) { opLambda.callback(builder); } @@ -2543,7 +2544,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUrls_Prefix(String urls, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("urls", urls); + PrefixQueryBuilder builder = regPrefixQ("urls", urls); if (opLambda != null) { opLambda.callback(builder); } @@ -2554,7 +2555,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUrls_GreaterThan(String urls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("urls", ConditionKey.CK_GREATER_THAN, urls); + RangeQueryBuilder builder = regRangeQ("urls", ConditionKey.CK_GREATER_THAN, urls); if (opLambda != null) { opLambda.callback(builder); } @@ -2565,7 +2566,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUrls_LessThan(String urls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("urls", ConditionKey.CK_LESS_THAN, urls); + RangeQueryBuilder builder = regRangeQ("urls", ConditionKey.CK_LESS_THAN, urls); if (opLambda != null) { opLambda.callback(builder); } @@ -2576,7 +2577,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUrls_GreaterEqual(String urls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("urls", ConditionKey.CK_GREATER_EQUAL, urls); + RangeQueryBuilder builder = regRangeQ("urls", ConditionKey.CK_GREATER_EQUAL, urls); if (opLambda != null) { opLambda.callback(builder); } @@ -2587,7 +2588,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUrls_LessEqual(String urls, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("urls", ConditionKey.CK_LESS_EQUAL, urls); + RangeQueryBuilder builder = regRangeQ("urls", ConditionKey.CK_LESS_EQUAL, urls); if (opLambda != null) { opLambda.callback(builder); } @@ -2608,29 +2609,29 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUserAgent_Term(String userAgent, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("userAgent", userAgent); + TermQueryBuilder builder = regTermQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } } public void setUserAgent_Terms(Collection userAgentList) { - setUserAgent_MatchPhrasePrefix(userAgentList, null); + setUserAgent_Terms(userAgentList, null); } - public void setUserAgent_MatchPhrasePrefix(Collection userAgentList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("userAgent", userAgentList); + public void setUserAgent_Terms(Collection userAgentList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("userAgent", userAgentList); if (opLambda != null) { opLambda.callback(builder); } } public void setUserAgent_InScope(Collection userAgentList) { - setUserAgent_MatchPhrasePrefix(userAgentList, null); + setUserAgent_Terms(userAgentList, null); } public void setUserAgent_InScope(Collection userAgentList, ConditionOptionCall opLambda) { - setUserAgent_MatchPhrasePrefix(userAgentList, opLambda); + setUserAgent_Terms(userAgentList, opLambda); } public void setUserAgent_Match(String userAgent) { @@ -2638,7 +2639,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUserAgent_Match(String userAgent, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("userAgent", userAgent); + MatchQueryBuilder builder = regMatchQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -2649,7 +2650,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUserAgent_MatchPhrase(String userAgent, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("userAgent", userAgent); + MatchQueryBuilder builder = regMatchPhraseQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -2660,7 +2661,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUserAgent_MatchPhrasePrefix(String userAgent, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("userAgent", userAgent); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -2671,7 +2672,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUserAgent_Fuzzy(String userAgent, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("userAgent", userAgent); + FuzzyQueryBuilder builder = regFuzzyQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -2682,7 +2683,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUserAgent_Prefix(String userAgent, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("userAgent", userAgent); + PrefixQueryBuilder builder = regPrefixQ("userAgent", userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -2693,7 +2694,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUserAgent_GreaterThan(String userAgent, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userAgent", ConditionKey.CK_GREATER_THAN, userAgent); + RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_GREATER_THAN, userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -2704,7 +2705,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUserAgent_LessThan(String userAgent, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userAgent", ConditionKey.CK_LESS_THAN, userAgent); + RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_LESS_THAN, userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -2715,7 +2716,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUserAgent_GreaterEqual(String userAgent, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userAgent", ConditionKey.CK_GREATER_EQUAL, userAgent); + RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_GREATER_EQUAL, userAgent); if (opLambda != null) { opLambda.callback(builder); } @@ -2726,7 +2727,7 @@ public abstract class BsWebConfigCQ extends AbstractConditionQuery { } public void setUserAgent_LessEqual(String userAgent, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("userAgent", ConditionKey.CK_LESS_EQUAL, userAgent); + RangeQueryBuilder builder = regRangeQ("userAgent", ConditionKey.CK_LESS_EQUAL, userAgent); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigToLabelCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigToLabelCQ.java index aa8060bf3..33d4c24d8 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigToLabelCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigToLabelCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.WebConfigToLabelCQ; +import org.codelibs.fess.es.cbean.cf.WebConfigToLabelCF; 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 BsWebConfigToLabelCQ extends AbstractConditionQuery { return "web_config_to_label"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { WebConfigToLabelCQ query = new WebConfigToLabelCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + WebConfigToLabelCF filter = new WebConfigToLabelCF(); + 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 BsWebConfigToLabelCQ extends AbstractConditionQuery { WebConfigToLabelCQ shouldQuery = new WebConfigToLabelCQ(); WebConfigToLabelCQ mustNotQuery = new WebConfigToLabelCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -96,7 +98,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +186,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +207,29 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("labelTypeId", labelTypeId); + TermQueryBuilder builder = regTermQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } } public void setLabelTypeId_Terms(Collection labelTypeIdList) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null); + setLabelTypeId_Terms(labelTypeIdList, null); } - public void setLabelTypeId_MatchPhrasePrefix(Collection labelTypeIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("labelTypeId", labelTypeIdList); + public void setLabelTypeId_Terms(Collection labelTypeIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("labelTypeId", labelTypeIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setLabelTypeId_InScope(Collection labelTypeIdList) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, null); + setLabelTypeId_Terms(labelTypeIdList, null); } public void setLabelTypeId_InScope(Collection labelTypeIdList, ConditionOptionCall opLambda) { - setLabelTypeId_MatchPhrasePrefix(labelTypeIdList, opLambda); + setLabelTypeId_Terms(labelTypeIdList, opLambda); } public void setLabelTypeId_Match(String labelTypeId) { @@ -235,7 +237,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Match(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_MatchPhrase(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchPhraseQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_MatchPhrasePrefix(String labelTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("labelTypeId", labelTypeId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Fuzzy(String labelTypeId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("labelTypeId", labelTypeId); + FuzzyQueryBuilder builder = regFuzzyQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("labelTypeId", labelTypeId); + PrefixQueryBuilder builder = regPrefixQ("labelTypeId", labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_GreaterThan(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_THAN, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +314,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_GreaterEqual(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_GREATER_EQUAL, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -323,7 +325,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); + RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, labelTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -344,29 +346,29 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setWebConfigId_Term(String webConfigId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("webConfigId", webConfigId); + TermQueryBuilder builder = regTermQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } } public void setWebConfigId_Terms(Collection webConfigIdList) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, null); + setWebConfigId_Terms(webConfigIdList, null); } - public void setWebConfigId_MatchPhrasePrefix(Collection webConfigIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("webConfigId", webConfigIdList); + public void setWebConfigId_Terms(Collection webConfigIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("webConfigId", webConfigIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setWebConfigId_InScope(Collection webConfigIdList) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, null); + setWebConfigId_Terms(webConfigIdList, null); } public void setWebConfigId_InScope(Collection webConfigIdList, ConditionOptionCall opLambda) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, opLambda); + setWebConfigId_Terms(webConfigIdList, opLambda); } public void setWebConfigId_Match(String webConfigId) { @@ -374,7 +376,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setWebConfigId_Match(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setWebConfigId_MatchPhrase(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchPhraseQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setWebConfigId_MatchPhrasePrefix(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setWebConfigId_Fuzzy(String webConfigId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("webConfigId", webConfigId); + FuzzyQueryBuilder builder = regFuzzyQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("webConfigId", webConfigId); + PrefixQueryBuilder builder = regPrefixQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +453,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -462,7 +464,7 @@ public abstract class BsWebConfigToLabelCQ extends AbstractConditionQuery { } public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); if (opLambda != null) { opLambda.callback(builder); } diff --git a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigToRoleCQ.java b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigToRoleCQ.java index 91700082a..5699663ee 100644 --- a/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigToRoleCQ.java +++ b/src/main/java/org/codelibs/fess/es/cbean/cq/bs/BsWebConfigToRoleCQ.java @@ -3,6 +3,7 @@ package org.codelibs.fess.es.cbean.cq.bs; import java.util.Collection; import org.codelibs.fess.es.cbean.cq.WebConfigToRoleCQ; +import org.codelibs.fess.es.cbean.cf.WebConfigToRoleCF; 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 BsWebConfigToRoleCQ extends AbstractConditionQuery { return "web_config_to_role"; } - public void filtered(FilteredCall filteredLambda) { + public void filtered(FilteredCall filteredLambda) { filtered(filteredLambda, null); } - public void filtered(FilteredCall filteredLambda, ConditionOptionCall opLambda) { + public void filtered(FilteredCall filteredLambda, + ConditionOptionCall opLambda) { WebConfigToRoleCQ query = new WebConfigToRoleCQ(); - filteredLambda.callback(query); - if (!query.queryBuilderList.isEmpty()) { - // TODO filter - FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null); + WebConfigToRoleCF filter = new WebConfigToRoleCF(); + 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 BsWebConfigToRoleCQ extends AbstractConditionQuery { WebConfigToRoleCQ shouldQuery = new WebConfigToRoleCQ(); WebConfigToRoleCQ mustNotQuery = new WebConfigToRoleCQ(); 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); } @@ -66,29 +68,29 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Term(String id, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("id", id); + TermQueryBuilder builder = regTermQ("id", id); if (opLambda != null) { opLambda.callback(builder); } } public void setId_Terms(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } - public void setId_MatchPhrasePrefix(Collection idList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("id", idList); + public void setId_Terms(Collection idList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("id", idList); if (opLambda != null) { opLambda.callback(builder); } } public void setId_InScope(Collection idList) { - setId_MatchPhrasePrefix(idList, null); + setId_Terms(idList, null); } public void setId_InScope(Collection idList, ConditionOptionCall opLambda) { - setId_MatchPhrasePrefix(idList, opLambda); + setId_Terms(idList, opLambda); } public void setId_Match(String id) { @@ -96,7 +98,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Match(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("id", id); + MatchQueryBuilder builder = regMatchQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -107,7 +109,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setId_MatchPhrase(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("id", id); + MatchQueryBuilder builder = regMatchPhraseQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -118,7 +120,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setId_MatchPhrasePrefix(String id, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("id", id); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -129,7 +131,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Fuzzy(String id, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("id", id); + FuzzyQueryBuilder builder = regFuzzyQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -140,7 +142,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setId_Prefix(String id, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("id", id); + PrefixQueryBuilder builder = regPrefixQ("id", id); if (opLambda != null) { opLambda.callback(builder); } @@ -151,7 +153,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setId_GreaterThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -162,7 +164,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setId_LessThan(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_THAN, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_THAN, id); if (opLambda != null) { opLambda.callback(builder); } @@ -173,7 +175,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setId_GreaterEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_GREATER_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -184,7 +186,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setId_LessEqual(String id, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); + RangeQueryBuilder builder = regRangeQ("id", ConditionKey.CK_LESS_EQUAL, id); if (opLambda != null) { opLambda.callback(builder); } @@ -205,29 +207,29 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Term(String roleTypeId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("roleTypeId", roleTypeId); + TermQueryBuilder builder = regTermQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } } public void setRoleTypeId_Terms(Collection roleTypeIdList) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null); + setRoleTypeId_Terms(roleTypeIdList, null); } - public void setRoleTypeId_MatchPhrasePrefix(Collection roleTypeIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("roleTypeId", roleTypeIdList); + public void setRoleTypeId_Terms(Collection roleTypeIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("roleTypeId", roleTypeIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setRoleTypeId_InScope(Collection roleTypeIdList) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, null); + setRoleTypeId_Terms(roleTypeIdList, null); } public void setRoleTypeId_InScope(Collection roleTypeIdList, ConditionOptionCall opLambda) { - setRoleTypeId_MatchPhrasePrefix(roleTypeIdList, opLambda); + setRoleTypeId_Terms(roleTypeIdList, opLambda); } public void setRoleTypeId_Match(String roleTypeId) { @@ -235,7 +237,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Match(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -246,7 +248,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_MatchPhrase(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchPhraseQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -257,7 +259,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_MatchPhrasePrefix(String roleTypeId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("roleTypeId", roleTypeId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -268,7 +270,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Fuzzy(String roleTypeId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("roleTypeId", roleTypeId); + FuzzyQueryBuilder builder = regFuzzyQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -279,7 +281,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_Prefix(String roleTypeId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("roleTypeId", roleTypeId); + PrefixQueryBuilder builder = regPrefixQ("roleTypeId", roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -290,7 +292,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_GreaterThan(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_THAN, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -301,7 +303,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_LessThan(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_THAN, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -312,7 +314,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_GreaterEqual(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_GREATER_EQUAL, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -323,7 +325,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setRoleTypeId_LessEqual(String roleTypeId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); + RangeQueryBuilder builder = regRangeQ("roleTypeId", ConditionKey.CK_LESS_EQUAL, roleTypeId); if (opLambda != null) { opLambda.callback(builder); } @@ -344,29 +346,29 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setWebConfigId_Term(String webConfigId, ConditionOptionCall opLambda) { - TermQueryBuilder builder = reqTermQ("webConfigId", webConfigId); + TermQueryBuilder builder = regTermQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } } public void setWebConfigId_Terms(Collection webConfigIdList) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, null); + setWebConfigId_Terms(webConfigIdList, null); } - public void setWebConfigId_MatchPhrasePrefix(Collection webConfigIdList, ConditionOptionCall opLambda) { - TermsQueryBuilder builder = reqTermsQ("webConfigId", webConfigIdList); + public void setWebConfigId_Terms(Collection webConfigIdList, ConditionOptionCall opLambda) { + TermsQueryBuilder builder = regTermsQ("webConfigId", webConfigIdList); if (opLambda != null) { opLambda.callback(builder); } } public void setWebConfigId_InScope(Collection webConfigIdList) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, null); + setWebConfigId_Terms(webConfigIdList, null); } public void setWebConfigId_InScope(Collection webConfigIdList, ConditionOptionCall opLambda) { - setWebConfigId_MatchPhrasePrefix(webConfigIdList, opLambda); + setWebConfigId_Terms(webConfigIdList, opLambda); } public void setWebConfigId_Match(String webConfigId) { @@ -374,7 +376,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setWebConfigId_Match(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -385,7 +387,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setWebConfigId_MatchPhrase(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhraseQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchPhraseQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -396,7 +398,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setWebConfigId_MatchPhrasePrefix(String webConfigId, ConditionOptionCall opLambda) { - MatchQueryBuilder builder = reqMatchPhrasePrefixQ("webConfigId", webConfigId); + MatchQueryBuilder builder = regMatchPhrasePrefixQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -407,7 +409,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setWebConfigId_Fuzzy(String webConfigId, ConditionOptionCall opLambda) { - FuzzyQueryBuilder builder = reqFuzzyQ("webConfigId", webConfigId); + FuzzyQueryBuilder builder = regFuzzyQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -418,7 +420,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setWebConfigId_Prefix(String webConfigId, ConditionOptionCall opLambda) { - PrefixQueryBuilder builder = reqPrefixQ("webConfigId", webConfigId); + PrefixQueryBuilder builder = regPrefixQ("webConfigId", webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -429,7 +431,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setWebConfigId_GreaterThan(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_THAN, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -440,7 +442,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setWebConfigId_LessThan(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_THAN, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -451,7 +453,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setWebConfigId_GreaterEqual(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_GREATER_EQUAL, webConfigId); if (opLambda != null) { opLambda.callback(builder); } @@ -462,7 +464,7 @@ public abstract class BsWebConfigToRoleCQ extends AbstractConditionQuery { } public void setWebConfigId_LessEqual(String webConfigId, ConditionOptionCall opLambda) { - RangeQueryBuilder builder = reqRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); + RangeQueryBuilder builder = regRangeQ("webConfigId", ConditionKey.CK_LESS_EQUAL, webConfigId); if (opLambda != null) { opLambda.callback(builder); }