1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.codelibs.fess.opensearch.config.bsbhv;
17
18 import java.util.List;
19 import java.util.Map;
20
21 import org.codelibs.fess.opensearch.config.allcommon.EsAbstractBehavior;
22 import org.codelibs.fess.opensearch.config.allcommon.EsAbstractEntity.RequestOptionCall;
23 import org.codelibs.fess.opensearch.config.bsentity.dbmeta.DuplicateHostDbm;
24 import org.codelibs.fess.opensearch.config.cbean.DuplicateHostCB;
25 import org.codelibs.fess.opensearch.config.exentity.DuplicateHost;
26 import org.dbflute.Entity;
27 import org.dbflute.bhv.readable.CBCall;
28 import org.dbflute.bhv.readable.EntityRowHandler;
29 import org.dbflute.cbean.ConditionBean;
30 import org.dbflute.cbean.result.ListResultBean;
31 import org.dbflute.cbean.result.PagingResultBean;
32 import org.dbflute.exception.IllegalBehaviorStateException;
33 import org.dbflute.optional.OptionalEntity;
34 import org.dbflute.util.DfTypeUtil;
35 import org.opensearch.action.bulk.BulkRequestBuilder;
36 import org.opensearch.action.delete.DeleteRequestBuilder;
37 import org.opensearch.action.index.IndexRequestBuilder;
38
39
40
41
42 public abstract class BsDuplicateHostBhv extends EsAbstractBehavior<DuplicateHost, DuplicateHostCB> {
43
44
45
46
47 @Override
48 public String asTableDbName() {
49 return asEsIndexType();
50 }
51
52 @Override
53 protected String asEsIndex() {
54 return "fess_config.duplicate_host";
55 }
56
57 @Override
58 public String asEsIndexType() {
59 return "duplicate_host";
60 }
61
62 @Override
63 public String asEsSearchType() {
64 return "duplicate_host";
65 }
66
67 @Override
68 public DuplicateHostDbm asDBMeta() {
69 return DuplicateHostDbm.getInstance();
70 }
71
72 @Override
73 protected <RESULT extends DuplicateHost> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
74 try {
75 final RESULT result = entityType.newInstance();
76 result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));
77 result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
78 result.setDuplicateHostName(DfTypeUtil.toString(source.get("duplicateHostName")));
79 result.setRegularName(DfTypeUtil.toString(source.get("regularName")));
80 result.setSortOrder(DfTypeUtil.toInteger(source.get("sortOrder")));
81 result.setUpdatedBy(DfTypeUtil.toString(source.get("updatedBy")));
82 result.setUpdatedTime(DfTypeUtil.toLong(source.get("updatedTime")));
83 return updateEntity(source, result);
84 } catch (InstantiationException | IllegalAccessException e) {
85 final String msg = "Cannot create a new instance: " + entityType.getName();
86 throw new IllegalBehaviorStateException(msg, e);
87 }
88 }
89
90 protected <RESULT extends DuplicateHost> RESULT updateEntity(Map<String, Object> source, RESULT result) {
91 return result;
92 }
93
94
95
96
97 public int selectCount(CBCall<DuplicateHostCB> cbLambda) {
98 return facadeSelectCount(createCB(cbLambda));
99 }
100
101 public OptionalEntity<DuplicateHost> selectEntity(CBCall<DuplicateHostCB> cbLambda) {
102 return facadeSelectEntity(createCB(cbLambda));
103 }
104
105 protected OptionalEntity<DuplicateHost> facadeSelectEntity(DuplicateHostCB cb) {
106 return doSelectOptionalEntity(cb, typeOfSelectedEntity());
107 }
108
109 protected <ENTITY extends DuplicateHost> OptionalEntity<ENTITY> doSelectOptionalEntity(DuplicateHostCB cb, Class<? extends ENTITY> tp) {
110 return createOptionalEntity(doSelectEntity(cb, tp), cb);
111 }
112
113 @Override
114 public DuplicateHostCB newConditionBean() {
115 return new DuplicateHostCB();
116 }
117
118 @Override
119 protected Entity doReadEntity(ConditionBean cb) {
120 return facadeSelectEntity(downcast(cb)).orElse(null);
121 }
122
123 public DuplicateHost selectEntityWithDeletedCheck(CBCall<DuplicateHostCB> cbLambda) {
124 return facadeSelectEntityWithDeletedCheck(createCB(cbLambda));
125 }
126
127 public OptionalEntity<DuplicateHost> selectByPK(String id) {
128 return facadeSelectByPK(id);
129 }
130
131 protected OptionalEntity<DuplicateHost> facadeSelectByPK(String id) {
132 return doSelectOptionalByPK(id, typeOfSelectedEntity());
133 }
134
135 protected <ENTITY extends DuplicateHost> ENTITY doSelectByPK(String id, Class<? extends ENTITY> tp) {
136 return doSelectEntity(xprepareCBAsPK(id), tp);
137 }
138
139 protected DuplicateHostCB xprepareCBAsPK(String id) {
140 assertObjectNotNull("id", id);
141 return newConditionBean().acceptPK(id);
142 }
143
144 protected <ENTITY extends DuplicateHost> OptionalEntity<ENTITY> doSelectOptionalByPK(String id, Class<? extends ENTITY> tp) {
145 return createOptionalEntity(doSelectByPK(id, tp), id);
146 }
147
148 @Override
149 protected Class<? extends DuplicateHost> typeOfSelectedEntity() {
150 return DuplicateHost.class;
151 }
152
153 @Override
154 protected Class<DuplicateHost> typeOfHandlingEntity() {
155 return DuplicateHost.class;
156 }
157
158 @Override
159 protected Class<DuplicateHostCB> typeOfHandlingConditionBean() {
160 return DuplicateHostCB.class;
161 }
162
163 public ListResultBean<DuplicateHost> selectList(CBCall<DuplicateHostCB> cbLambda) {
164 return facadeSelectList(createCB(cbLambda));
165 }
166
167 public PagingResultBean<DuplicateHost> selectPage(CBCall<DuplicateHostCB> cbLambda) {
168
169 return (PagingResultBean<DuplicateHost>) facadeSelectList(createCB(cbLambda));
170 }
171
172 public void selectCursor(CBCall<DuplicateHostCB> cbLambda, EntityRowHandler<DuplicateHost> entityLambda) {
173 facadeSelectCursor(createCB(cbLambda), entityLambda);
174 }
175
176 public void selectBulk(CBCall<DuplicateHostCB> cbLambda, EntityRowHandler<List<DuplicateHost>> entityLambda) {
177 delegateSelectBulk(createCB(cbLambda), entityLambda, typeOfSelectedEntity());
178 }
179
180
181
182
183 public void insert(DuplicateHost entity) {
184 doInsert(entity, null);
185 }
186
187 public void insert(DuplicateHost entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
188 entity.asDocMeta().indexOption(opLambda);
189 doInsert(entity, null);
190 }
191
192 public void update(DuplicateHost entity) {
193 doUpdate(entity, null);
194 }
195
196 public void update(DuplicateHost entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
197 entity.asDocMeta().indexOption(opLambda);
198 doUpdate(entity, null);
199 }
200
201 public void insertOrUpdate(DuplicateHost entity) {
202 doInsertOrUpdate(entity, null, null);
203 }
204
205 public void insertOrUpdate(DuplicateHost entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
206 entity.asDocMeta().indexOption(opLambda);
207 doInsertOrUpdate(entity, null, null);
208 }
209
210 public void delete(DuplicateHost entity) {
211 doDelete(entity, null);
212 }
213
214 public void delete(DuplicateHost entity, RequestOptionCall<DeleteRequestBuilder> opLambda) {
215 entity.asDocMeta().deleteOption(opLambda);
216 doDelete(entity, null);
217 }
218
219 public int queryDelete(CBCall<DuplicateHostCB> cbLambda) {
220 return doQueryDelete(createCB(cbLambda), null);
221 }
222
223 public int[] batchInsert(List<DuplicateHost> list) {
224 return batchInsert(list, null, null);
225 }
226
227 public int[] batchInsert(List<DuplicateHost> list, RequestOptionCall<BulkRequestBuilder> call) {
228 return batchInsert(list, call, null);
229 }
230
231 public int[] batchInsert(List<DuplicateHost> list, RequestOptionCall<BulkRequestBuilder> call,
232 RequestOptionCall<IndexRequestBuilder> entityCall) {
233 return doBatchInsert(new BulkList<>(list, call, entityCall), null);
234 }
235
236 public int[] batchUpdate(List<DuplicateHost> list) {
237 return batchUpdate(list, null, null);
238 }
239
240 public int[] batchUpdate(List<DuplicateHost> list, RequestOptionCall<BulkRequestBuilder> call) {
241 return batchUpdate(list, call, null);
242 }
243
244 public int[] batchUpdate(List<DuplicateHost> list, RequestOptionCall<BulkRequestBuilder> call,
245 RequestOptionCall<IndexRequestBuilder> entityCall) {
246 return doBatchUpdate(new BulkList<>(list, call, entityCall), null);
247 }
248
249 public int[] batchDelete(List<DuplicateHost> list) {
250 return batchDelete(list, null, null);
251 }
252
253 public int[] batchDelete(List<DuplicateHost> list, RequestOptionCall<BulkRequestBuilder> call) {
254 return batchDelete(list, call, null);
255 }
256
257 public int[] batchDelete(List<DuplicateHost> list, RequestOptionCall<BulkRequestBuilder> call,
258 RequestOptionCall<IndexRequestBuilder> entityCall) {
259 return doBatchDelete(new BulkList<>(list, call, entityCall), null);
260 }
261
262
263 }