/*
* Copyright 2012-2017 CodeLibs Project and the Others.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*/
package org.codelibs.fess.es.config.bsbhv;
import java.util.List;
import java.util.Map;
import org.codelibs.fess.es.config.allcommon.EsAbstractBehavior;
import org.codelibs.fess.es.config.allcommon.EsAbstractEntity.RequestOptionCall;
import org.codelibs.fess.es.config.bsentity.dbmeta.BadWordDbm;
import org.codelibs.fess.es.config.cbean.BadWordCB;
import org.codelibs.fess.es.config.exentity.BadWord;
import org.dbflute.Entity;
import org.dbflute.bhv.readable.CBCall;
import org.dbflute.bhv.readable.EntityRowHandler;
import org.dbflute.cbean.ConditionBean;
import org.dbflute.cbean.result.ListResultBean;
import org.dbflute.cbean.result.PagingResultBean;
import org.dbflute.exception.IllegalBehaviorStateException;
import org.dbflute.optional.OptionalEntity;
import org.dbflute.util.DfTypeUtil;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.delete.DeleteRequestBuilder;
import org.elasticsearch.action.index.IndexRequestBuilder;
/**
* @author ESFlute (using FreeGen)
*/
public abstract class BsBadWordBhv extends EsAbstractBehavior<BadWord, BadWordCB> {
// ===================================================================================
// Control Override
// ================
@Override
public String asTableDbName() {
return asEsIndexType();
}
@Override
protected String asEsIndex() {
return ".fess_config";
}
@Override
public String asEsIndexType() {
return "bad_word";
}
@Override
public String asEsSearchType() {
return "bad_word";
}
@Override
public BadWordDbm asDBMeta() {
return BadWordDbm.getInstance();
}
@Override
protected <RESULT extends BadWord> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
try {
final RESULT result = entityType.newInstance();
result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));
result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
result.setSuggestWord(DfTypeUtil.toString(source.get("suggestWord")));
result.setTargetLabel(DfTypeUtil.toString(source.get("targetLabel")));
result.setTargetRole(DfTypeUtil.toString(source.get("targetRole")));
result.setUpdatedBy(DfTypeUtil.toString(source.get("updatedBy")));
result.setUpdatedTime(DfTypeUtil.toLong(source.get("updatedTime")));
return updateEntity(source, result);
} catch (InstantiationException | IllegalAccessException e) {
final String msg = "Cannot create a new instance: " + entityType.getName();
throw new IllegalBehaviorStateException(msg, e);
}
}
protected <RESULT extends BadWord> RESULT updateEntity(Map<String, Object> source, RESULT result) {
return result;
}
// ===================================================================================
// Select
// ======
public int selectCount(CBCall<BadWordCB> cbLambda) {
return facadeSelectCount(createCB(cbLambda));
}
public OptionalEntity<BadWord> selectEntity(CBCall<BadWordCB> cbLambda) {
return facadeSelectEntity(createCB(cbLambda));
}
protected OptionalEntity<BadWord> facadeSelectEntity(BadWordCB cb) {
return doSelectOptionalEntity(cb, typeOfSelectedEntity());
}
protected <ENTITY extends BadWord> OptionalEntity<ENTITY> doSelectOptionalEntity(BadWordCB cb, Class<? extends ENTITY> tp) {
return createOptionalEntity(doSelectEntity(cb, tp), cb);
}
@Override
public BadWordCB newConditionBean() {
return new BadWordCB();
}
@Override
protected Entity doReadEntity(ConditionBean cb) {
return facadeSelectEntity(downcast(cb)).orElse(null);
}
public BadWord selectEntityWithDeletedCheck(CBCall<BadWordCB> cbLambda) {
return facadeSelectEntityWithDeletedCheck(createCB(cbLambda));
}
public OptionalEntity<BadWord> selectByPK(String id) {
return facadeSelectByPK(id);
}
protected OptionalEntity<BadWord> facadeSelectByPK(String id) {
return doSelectOptionalByPK(id, typeOfSelectedEntity());
}
protected <ENTITY extends BadWord> ENTITY doSelectByPK(String id, Class<? extends ENTITY> tp) {
return doSelectEntity(xprepareCBAsPK(id), tp);
}
protected BadWordCB xprepareCBAsPK(String id) {
assertObjectNotNull("id", id);
return newConditionBean().acceptPK(id);
}
protected <ENTITY extends BadWord> OptionalEntity<ENTITY> doSelectOptionalByPK(String id, Class<? extends ENTITY> tp) {
return createOptionalEntity(doSelectByPK(id, tp), id);
}
@Override
protected Class<? extends BadWord> typeOfSelectedEntity() {
return BadWord.class;
}
@Override
protected Class<BadWord> typeOfHandlingEntity() {
return BadWord.class;
}
@Override
protected Class<BadWordCB> typeOfHandlingConditionBean() {
return BadWordCB.class;
}
public ListResultBean<BadWord> selectList(CBCall<BadWordCB> cbLambda) {
return facadeSelectList(createCB(cbLambda));
}
public PagingResultBean<BadWord> selectPage(CBCall<BadWordCB> cbLambda) {
// #pending same?
return (PagingResultBean<BadWord>) facadeSelectList(createCB(cbLambda));
}
public void selectCursor(CBCall<BadWordCB> cbLambda, EntityRowHandler<BadWord> entityLambda) {
facadeSelectCursor(createCB(cbLambda), entityLambda);
}
public void selectBulk(CBCall<BadWordCB> cbLambda, EntityRowHandler<List<BadWord>> entityLambda) {
delegateSelectBulk(createCB(cbLambda), entityLambda, typeOfSelectedEntity());
}
// ===================================================================================
// Update
// ======
public void insert(BadWord entity) {
doInsert(entity, null);
}
public void insert(BadWord entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
entity.asDocMeta().indexOption(opLambda);
doInsert(entity, null);
}
public void update(BadWord entity) {
doUpdate(entity, null);
}
public void update(BadWord entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
entity.asDocMeta().indexOption(opLambda);
doUpdate(entity, null);
}
public void insertOrUpdate(BadWord entity) {
doInsertOrUpdate(entity, null, null);
}
public void insertOrUpdate(BadWord entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
entity.asDocMeta().indexOption(opLambda);
doInsertOrUpdate(entity, null, null);
}
public void delete(BadWord entity) {
doDelete(entity, null);
}
public void delete(BadWord entity, RequestOptionCall<DeleteRequestBuilder> opLambda) {
entity.asDocMeta().deleteOption(opLambda);
doDelete(entity, null);
}
public int queryDelete(CBCall<BadWordCB> cbLambda) {
return doQueryDelete(createCB(cbLambda), null);
}
public int[] batchInsert(List<BadWord> list) {
return batchInsert(list, null, null);
}
public int[] batchInsert(List<BadWord> list, RequestOptionCall<BulkRequestBuilder> call) {
return batchInsert(list, call, null);
}
public int[] batchInsert(List<BadWord> list, RequestOptionCall<BulkRequestBuilder> call,
RequestOptionCall<IndexRequestBuilder> entityCall) {
return doBatchInsert(new BulkList<>(list, call, entityCall), null);
}
public int[] batchUpdate(List<BadWord> list) {
return batchUpdate(list, null, null);
}
public int[] batchUpdate(List<BadWord> list, RequestOptionCall<BulkRequestBuilder> call) {
return batchUpdate(list, call, null);
}
public int[] batchUpdate(List<BadWord> list, RequestOptionCall<BulkRequestBuilder> call,
RequestOptionCall<IndexRequestBuilder> entityCall) {
return doBatchUpdate(new BulkList<>(list, call, entityCall), null);
}
public int[] batchDelete(List<BadWord> list) {
return batchDelete(list, null, null);
}
public int[] batchDelete(List<BadWord> list, RequestOptionCall<BulkRequestBuilder> call) {
return batchDelete(list, call, null);
}
public int[] batchDelete(List<BadWord> list, RequestOptionCall<BulkRequestBuilder> call,
RequestOptionCall<IndexRequestBuilder> entityCall) {
return doBatchDelete(new BulkList<>(list, call, entityCall), null);
}
// #pending create, modify, remove
}