1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.codelibs.fess.opensearch.user.cbean.cq.bs;
17
18 import java.time.LocalDateTime;
19 import java.util.ArrayList;
20 import java.util.Collection;
21
22 import org.codelibs.fess.opensearch.user.allcommon.EsAbstractConditionQuery;
23 import org.codelibs.fess.opensearch.user.cbean.cq.RoleCQ;
24 import org.dbflute.cbean.ckey.ConditionKey;
25 import org.opensearch.index.query.BoolQueryBuilder;
26 import org.opensearch.index.query.CommonTermsQueryBuilder;
27 import org.opensearch.index.query.ExistsQueryBuilder;
28 import org.opensearch.index.query.IdsQueryBuilder;
29 import org.opensearch.index.query.MatchPhrasePrefixQueryBuilder;
30 import org.opensearch.index.query.MatchPhraseQueryBuilder;
31 import org.opensearch.index.query.MatchQueryBuilder;
32 import org.opensearch.index.query.PrefixQueryBuilder;
33 import org.opensearch.index.query.RangeQueryBuilder;
34 import org.opensearch.index.query.RegexpQueryBuilder;
35 import org.opensearch.index.query.SpanTermQueryBuilder;
36 import org.opensearch.index.query.TermQueryBuilder;
37 import org.opensearch.index.query.TermsQueryBuilder;
38 import org.opensearch.index.query.WildcardQueryBuilder;
39 import org.opensearch.index.query.functionscore.FunctionScoreQueryBuilder;
40 import org.opensearch.index.query.functionscore.FunctionScoreQueryBuilder.FilterFunctionBuilder;
41
42
43
44
45 public abstract class BsRoleCQ extends EsAbstractConditionQuery {
46
47 protected static final Class<?> suppressUnusedImportLocalDateTime = LocalDateTime.class;
48
49
50
51
52 @Override
53 public String asTableDbName() {
54 return "role";
55 }
56
57 @Override
58 public String xgetAliasName() {
59 return "role";
60 }
61
62
63
64
65 public void functionScore(OperatorCall<RoleCQ> queryLambda, ScoreFunctionCall<ScoreFunctionCreator<RoleCQ>> functionsLambda,
66 final ConditionOptionCall<FunctionScoreQueryBuilder> opLambda) {
67 RoleCQ cq = new RoleCQ();
68 queryLambda.callback(cq);
69 final Collection<FilterFunctionBuilder> list = new ArrayList<>();
70 if (functionsLambda != null) {
71 functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
72 RoleCQ cf = new RoleCQ();
73 cqLambda.callback(cf);
74 list.add(new FilterFunctionBuilder(cf.getQuery(), scoreFunctionBuilder));
75 });
76 }
77 final FunctionScoreQueryBuilder builder = regFunctionScoreQ(cq.getQuery(), list);
78 if (opLambda != null) {
79 opLambda.callback(builder);
80 }
81 }
82
83 public void filtered(FilteredCall<RoleCQ, RoleCQ> filteredLambda) {
84 filtered(filteredLambda, null);
85 }
86
87 public void filtered(FilteredCall<RoleCQ, RoleCQ> filteredLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
88 bool((must, should, mustNot, filter) -> {
89 filteredLambda.callback(must, filter);
90 }, opLambda);
91 }
92
93 public void not(OperatorCall<RoleCQ> notLambda) {
94 not(notLambda, null);
95 }
96
97 public void not(final OperatorCall<RoleCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
98 bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
99 }
100
101 public void bool(BoolCall<RoleCQ> boolLambda) {
102 bool(boolLambda, null);
103 }
104
105 public void bool(BoolCall<RoleCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
106 RoleCQ mustQuery = new RoleCQ();
107 RoleCQ shouldQuery = new RoleCQ();
108 RoleCQ mustNotQuery = new RoleCQ();
109 RoleCQ filterQuery = new RoleCQ();
110 boolLambda.callback(mustQuery, shouldQuery, mustNotQuery, filterQuery);
111 if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries() || filterQuery.hasQueries()) {
112 BoolQueryBuilder builder = regBoolCQ(mustQuery.getQueryBuilderList(), shouldQuery.getQueryBuilderList(),
113 mustNotQuery.getQueryBuilderList(), filterQuery.getQueryBuilderList());
114 if (opLambda != null) {
115 opLambda.callback(builder);
116 }
117 }
118 }
119
120
121
122
123 public void setId_Equal(String id) {
124 setId_Term(id, null);
125 }
126
127 public void setId_Equal(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
128 setId_Term(id, opLambda);
129 }
130
131 public void setId_Term(String id) {
132 setId_Term(id, null);
133 }
134
135 public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
136 TermQueryBuilder builder = regTermQ("_id", id);
137 if (opLambda != null) {
138 opLambda.callback(builder);
139 }
140 }
141
142 public void setId_NotEqual(String id) {
143 setId_NotTerm(id, null);
144 }
145
146 public void setId_NotTerm(String id) {
147 setId_NotTerm(id, null);
148 }
149
150 public void setId_NotEqual(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
151 setId_NotTerm(id, opLambda);
152 }
153
154 public void setId_NotTerm(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
155 not(not -> not.setId_Term(id), opLambda);
156 }
157
158 public void setId_Terms(Collection<String> idList) {
159 setId_Terms(idList, null);
160 }
161
162 public void setId_Terms(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
163 IdsQueryBuilder builder = regIdsQ(idList);
164 if (opLambda != null) {
165 opLambda.callback(builder);
166 }
167 }
168
169 public void setId_InScope(Collection<String> idList) {
170 setId_Terms(idList, null);
171 }
172
173 public void setId_InScope(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
174 setId_Terms(idList, opLambda);
175 }
176
177 @Deprecated
178 public BsRoleCQ addOrderBy_Id_Asc() {
179 regOBA("_id");
180 return this;
181 }
182
183 @Deprecated
184 public BsRoleCQ addOrderBy_Id_Desc() {
185 regOBD("_id");
186 return this;
187 }
188
189 public void setName_Equal(String name) {
190 setName_Term(name, null);
191 }
192
193 public void setName_Equal(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
194 setName_Term(name, opLambda);
195 }
196
197 public void setName_Term(String name) {
198 setName_Term(name, null);
199 }
200
201 public void setName_Term(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
202 TermQueryBuilder builder = regTermQ("name", name);
203 if (opLambda != null) {
204 opLambda.callback(builder);
205 }
206 }
207
208 public void setName_NotEqual(String name) {
209 setName_NotTerm(name, null);
210 }
211
212 public void setName_NotTerm(String name) {
213 setName_NotTerm(name, null);
214 }
215
216 public void setName_NotEqual(String name, ConditionOptionCall<BoolQueryBuilder> opLambda) {
217 setName_NotTerm(name, opLambda);
218 }
219
220 public void setName_NotTerm(String name, ConditionOptionCall<BoolQueryBuilder> opLambda) {
221 not(not -> not.setName_Term(name), opLambda);
222 }
223
224 public void setName_Terms(Collection<String> nameList) {
225 setName_Terms(nameList, null);
226 }
227
228 public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
229 TermsQueryBuilder builder = regTermsQ("name", nameList);
230 if (opLambda != null) {
231 opLambda.callback(builder);
232 }
233 }
234
235 public void setName_InScope(Collection<String> nameList) {
236 setName_Terms(nameList, null);
237 }
238
239 public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
240 setName_Terms(nameList, opLambda);
241 }
242
243 public void setName_Match(String name) {
244 setName_Match(name, null);
245 }
246
247 public void setName_Match(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
248 MatchQueryBuilder builder = regMatchQ("name", name);
249 if (opLambda != null) {
250 opLambda.callback(builder);
251 }
252 }
253
254 public void setName_MatchPhrase(String name) {
255 setName_MatchPhrase(name, null);
256 }
257
258 public void setName_MatchPhrase(String name, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
259 MatchPhraseQueryBuilder builder = regMatchPhraseQ("name", name);
260 if (opLambda != null) {
261 opLambda.callback(builder);
262 }
263 }
264
265 public void setName_MatchPhrasePrefix(String name) {
266 setName_MatchPhrasePrefix(name, null);
267 }
268
269 public void setName_MatchPhrasePrefix(String name, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
270 MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("name", name);
271 if (opLambda != null) {
272 opLambda.callback(builder);
273 }
274 }
275
276 public void setName_Fuzzy(String name) {
277 setName_Fuzzy(name, null);
278 }
279
280 public void setName_Fuzzy(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
281 MatchQueryBuilder builder = regFuzzyQ("name", name);
282 if (opLambda != null) {
283 opLambda.callback(builder);
284 }
285 }
286
287 public void setName_Prefix(String name) {
288 setName_Prefix(name, null);
289 }
290
291 public void setName_Prefix(String name, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
292 PrefixQueryBuilder builder = regPrefixQ("name", name);
293 if (opLambda != null) {
294 opLambda.callback(builder);
295 }
296 }
297
298 public void setName_Wildcard(String name) {
299 setName_Wildcard(name, null);
300 }
301
302 public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
303 WildcardQueryBuilder builder = regWildcardQ("name", name);
304 if (opLambda != null) {
305 opLambda.callback(builder);
306 }
307 }
308
309 public void setName_Regexp(String name) {
310 setName_Regexp(name, null);
311 }
312
313 public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
314 RegexpQueryBuilder builder = regRegexpQ("name", name);
315 if (opLambda != null) {
316 opLambda.callback(builder);
317 }
318 }
319
320 public void setName_SpanTerm(String name) {
321 setName_SpanTerm("name", null);
322 }
323
324 public void setName_SpanTerm(String name, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
325 SpanTermQueryBuilder builder = regSpanTermQ("name", name);
326 if (opLambda != null) {
327 opLambda.callback(builder);
328 }
329 }
330
331 public void setName_GreaterThan(String name) {
332 setName_GreaterThan(name, null);
333 }
334
335 public void setName_GreaterThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
336 final Object _value = name;
337 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, _value);
338 if (opLambda != null) {
339 opLambda.callback(builder);
340 }
341 }
342
343 public void setName_LessThan(String name) {
344 setName_LessThan(name, null);
345 }
346
347 public void setName_LessThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
348 final Object _value = name;
349 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, _value);
350 if (opLambda != null) {
351 opLambda.callback(builder);
352 }
353 }
354
355 public void setName_GreaterEqual(String name) {
356 setName_GreaterEqual(name, null);
357 }
358
359 public void setName_GreaterEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
360 final Object _value = name;
361 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, _value);
362 if (opLambda != null) {
363 opLambda.callback(builder);
364 }
365 }
366
367 public void setName_LessEqual(String name) {
368 setName_LessEqual(name, null);
369 }
370
371 public void setName_LessEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
372 final Object _value = name;
373 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, _value);
374 if (opLambda != null) {
375 opLambda.callback(builder);
376 }
377 }
378
379 public void setName_Exists() {
380 setName_Exists(null);
381 }
382
383 public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
384 ExistsQueryBuilder builder = regExistsQ("name");
385 if (opLambda != null) {
386 opLambda.callback(builder);
387 }
388 }
389
390 @Deprecated
391 public void setName_CommonTerms(String name) {
392 setName_CommonTerms(name, null);
393 }
394
395 @Deprecated
396 public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
397 CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
398 if (opLambda != null) {
399 opLambda.callback(builder);
400 }
401 }
402
403 public BsRoleCQ addOrderBy_Name_Asc() {
404 regOBA("name");
405 return this;
406 }
407
408 public BsRoleCQ addOrderBy_Name_Desc() {
409 regOBD("name");
410 return this;
411 }
412
413 }