package com.vci.web.service.impl;
|
|
import com.vci.client.common.oq.OQTool;
|
import com.vci.common.qt.object.*;
|
import com.vci.common.utility.ObjectUtility;
|
import com.vci.corba.common.PLException;
|
import com.vci.corba.omd.data.AttributeValue;
|
import com.vci.corba.omd.data.BusinessObject;
|
import com.vci.corba.omd.data.LinkObject;
|
import com.vci.corba.omd.qtm.QTInfo;
|
import com.vci.corba.query.ObjectQueryService;
|
import com.vci.corba.query.ObjectQueryServicePrx;
|
import com.vci.corba.query.data.BtmRefQueryOption;
|
import com.vci.corba.query.data.KV;
|
import com.vci.frameworkcore.compatibility.SmUserQueryServiceI;
|
import com.vci.omd.utils.ObjectTool;
|
import com.vci.pagemodel.*;
|
import com.vci.starter.web.annotation.Column;
|
import com.vci.starter.web.constant.QueryOptionConstant;
|
import com.vci.starter.web.enumpck.BooleanEnum;
|
import com.vci.starter.web.exception.VciBaseException;
|
import com.vci.starter.web.pagemodel.DataGrid;
|
import com.vci.starter.web.pagemodel.PageHelper;
|
import com.vci.starter.web.util.BeanUtil;
|
import com.vci.starter.web.util.VciBaseUtil;
|
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
|
import com.vci.web.properties.WebProperties;
|
import com.vci.web.service.*;
|
import com.vci.web.util.PlatformClientUtil;
|
import com.vci.web.util.WebUtil;
|
import org.apache.commons.lang3.StringUtils;
|
import org.dom4j.DocumentException;
|
import org.dom4j.DocumentHelper;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
|
import java.lang.reflect.Field;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 业务类型操作服务---只能在dao层调用，其他的服务不允许使用
|
* 自动封装了平台相关的操作
|
* @author weidy
|
*/
|
@Service
|
public class WebBoServiceImpl implements WebBoServiceI{
|
|
/**
|
* 枚举服务
|
*/
|
@Autowired
|
private OsEnumServiceI enumService;//枚举服务
|
|
/**
|
* 属性服务
|
*/
|
@Autowired
|
private OsAttributeServiceI attrService;//属性服务
|
|
/**
|
* 生命周期的服务
|
*/
|
@Autowired
|
private OsLifeCycleServiceI lifeService;//生命周期服务
|
|
/**
|
* 状态的服务
|
*/
|
@Autowired
|
private OsStatusServiceI statusService;
|
|
/**
|
* 用户查询服务
|
*/
|
@Autowired
|
private SmUserQueryServiceI userQueryService;
|
|
/**
|
* 链接类型服务
|
*/
|
@Autowired
|
private WebLoServiceI loService;
|
|
/**
|
* 配置信息
|
*/
|
@Autowired
|
private WebProperties webProperties;
|
|
/**
|
* 多语言前缀
|
*/
|
private final String msgCodePrefix = "com.vci.web.boService.";
|
|
/**
|
* 日志对象
|
*/
|
private Logger logger = LoggerFactory.getLogger(getClass());
|
|
/**
|
* 业务类型的服务
|
*/
|
@Autowired
|
private OsBtmServiceI btmService;
|
|
/**
|
* 版本规则的服务
|
*/
|
@Autowired
|
private OsRevisionRuleServiceI revisionRuleService;
|
|
/**
|
* 平台调用客户端
|
*/
|
@Autowired
|
private PlatformClientUtil platformClientUtil;
|
|
/**
|
* 已经创建过的业务对象
|
*/
|
private static Map<String, BusinessObject> hasCreatedCbos = new HashMap<String, BusinessObject>();
|
|
/**
|
* 业务对象默认属性
|
*/
|
public static final Map<String,String> BO_BASE_FIELD_MAP = new HashMap<>();
|
|
public WebBoServiceImpl(){
|
List<Field> fields = WebUtil.getAllFieldForObj(BusinessObject.class);
|
if(!CollectionUtils.isEmpty(fields)) {
|
fields.stream().forEach(field -> {
|
BO_BASE_FIELD_MAP.put(field.getName(),WebUtil.getCboAttrNameFromField(field,BusinessObject.class));
|
});
|
}
|
}
|
|
/**
|
* 初始化业务类型
|
* --第一次调用的时候会相对慢一下，后续获取就很快的
|
* --注意在服务启动时才会清除缓存
|
* --创建人默认为当前用户，如果需要修改，可以在获取后自行处理
|
* @param btmName 业务类型的名称，会自动变成小写
|
* @return 业务数据的对象
|
* @throws VciBaseException 初始化出错的是会抛出异常
|
*/
|
@Override
|
public BusinessObject createCBOByBtmName(String btmName)
|
throws VciBaseException {
|
if(btmName!=null){
|
btmName = btmName.trim().toLowerCase();
|
}
|
String userid = WebUtil.getCurrentUserId();
|
if(!hasCreatedCbos.containsKey(btmName)){
|
if(StringUtils.isEmpty(userid)){
|
throw new VciBaseException(msgCodePrefix +"noHasUserid");
|
}
|
try {
|
// ClientServiceProvider.getBOFService().initBusinessObject(btmName); 可以进行替换
|
hasCreatedCbos.put(btmName, createBusinessObject(btmName));
|
} catch (Exception e) {
|
logger.error("创建业务类型对象",e);
|
throw new VciBaseException(msgCodePrefix + "initBoError",new String[]{btmName});
|
}
|
}
|
BusinessObject cbo = cloneBusinessObject(hasCreatedCbos.get(btmName));
|
return cbo;
|
}
|
|
/**
|
* 根据业务类型名称创建业务数据源对象
|
* @param boName 业务类型名称
|
* @return 业务数据对象
|
*/
|
public BusinessObject createBusinessObject(String boName) throws PLException {
|
// ClientServiceProvider.getBOFService().initBusinessObject(boName);
|
OsBtmTypeVO btmTypeVO = btmService.getBtmById(boName);
|
String userName = WebUtil.getCurrentUserId();
|
BusinessObject bo = new BusinessObject();
|
bo.oid = (new ObjectUtility()).getNewObjectID36();
|
bo.revisionid = (new ObjectUtility()).getNewObjectID36();
|
bo.nameoid = (new ObjectUtility()).getNewObjectID36();
|
bo.btName = boName;
|
bo.isLastR = true;
|
bo.isFirstR = true;
|
bo.isFirstV = true;
|
bo.isLastV = true;
|
bo.creator = userName;
|
bo.createTime = System.currentTimeMillis();
|
bo.modifier = userName;
|
bo.modifyTime = System.currentTimeMillis();
|
bo.revisionRule = btmTypeVO.getRevisionRuleId();
|
bo.versionRule = String.valueOf(btmTypeVO.getVersionRule());
|
if(StringUtils.isNotBlank(btmTypeVO.getRevisionRuleId())){
|
OsRevisionRuleVO revisionRuleVO = revisionRuleService.getRevisionRuleById(btmTypeVO.getRevisionRuleId());
|
bo.revisionValue = revisionRuleVO.getStartCode();
|
}
|
|
bo.revisionSeq = (short) 1;
|
bo.versionSeq = (short) 1;
|
bo.versionValue = getVersionValue(WebUtil.getInt(btmTypeVO.getVersionRule()));
|
bo.lctId = btmTypeVO.getLifeCycleId();
|
if(StringUtils.isNotBlank(btmTypeVO.getLifeCycleId())){
|
OsLifeCycleVO lifeCycleVO = lifeService.getLifeCycleById(btmTypeVO.getLifeCycleId());
|
//todo 无法获取数据
|
bo.lcStatus = lifeCycleVO == null ? "" : lifeCycleVO.getStartStatus();
|
}
|
bo.id = "";
|
bo.name = "";
|
bo.description = "";
|
bo.owner = userName;
|
// bo.setCheckinBy(userName);
|
bo.fromVersion = "";
|
this.initTypeAttributeValue(bo,btmTypeVO);
|
return bo;
|
}
|
|
/**
|
* 初始化业务类型的默认值
|
* @param cbo 业务数据对象
|
* @param btmTypeVO 业务类型的显示对象
|
*/
|
private void initTypeAttributeValue(BusinessObject cbo,OsBtmTypeVO btmTypeVO) {
|
Optional.ofNullable(btmTypeVO.getAttributes()).orElseGet(()->new ArrayList<>()).stream().forEach(attribute->{
|
ObjectTool.setBOAttributeValue(cbo,attribute.getId(),attribute.getDefaultValue());
|
});
|
}
|
|
/**
|
* 获取版次的值
|
* @param verRuleName 版次的规则
|
* @return 版次的值，没有规则则为空
|
*/
|
private String getVersionValue(int verRuleName) {
|
if (verRuleName == 0) {
|
return "1";
|
} else if (verRuleName == 1) {
|
return "a";
|
} else if (verRuleName == 2) {
|
return "0";
|
}
|
return "";
|
}
|
|
/**
|
* 拷贝以前的业务数据
|
* @param cbo 以前的业务数据对象
|
* @return 拷贝后的对象
|
*/
|
private BusinessObject cloneBusinessObject(BusinessObject cbo){
|
if(cbo !=null){
|
BusinessObject businessObject = new BusinessObject();
|
businessObject.oid = new ObjectUtility().getNewObjectID36();
|
businessObject.revisionid = new ObjectUtility().getNewObjectID36();
|
businessObject.nameoid = new ObjectUtility().getNewObjectID36();
|
businessObject.btName = cbo.btName;
|
businessObject.isLastR = cbo.isLastR;
|
businessObject.isFirstR = cbo.isFirstR;
|
businessObject.isLastV = cbo.isLastV;
|
businessObject.isFirstV = cbo.isFirstV;
|
businessObject.creator = WebUtil.getCurrentUserId();
|
businessObject.createTime = System.currentTimeMillis();
|
businessObject.modifier = cbo.modifier;
|
businessObject.modifyTime = cbo.modifyTime;
|
businessObject.revisionRule = cbo.revisionRule;
|
businessObject.versionRule = cbo.versionRule;
|
businessObject.revisionSeq = cbo.revisionSeq;
|
businessObject.revisionValue = cbo.revisionValue;
|
businessObject.versionSeq = cbo.versionSeq;
|
businessObject.versionValue = cbo.versionValue;
|
businessObject.lctId = cbo.lctId;
|
businessObject.lcStatus = cbo.lcStatus;
|
businessObject.ts = System.currentTimeMillis();
|
businessObject.id = cbo.id;
|
businessObject.name = cbo.name;
|
businessObject.description = cbo.description;
|
businessObject.owner = businessObject.creator;
|
businessObject.fromVersion = cbo.fromVersion;
|
if(cbo.newAttrValList !=null){
|
businessObject.newAttrValList = clone(cbo.newAttrValList);
|
}
|
if(cbo.hisAttrValList !=null){
|
businessObject.hisAttrValList = clone(cbo.hisAttrValList);
|
}
|
return businessObject;
|
}else {
|
return null;
|
}
|
}
|
|
/**
|
* 拷贝属性的值
|
* @param newAttrValList 属性值对象数组
|
* @return 拷贝后的新属性数组
|
*/
|
private AttributeValue[] clone(AttributeValue[] newAttrValList) {
|
AttributeValue[] n = new AttributeValue[newAttrValList.length];
|
for (int i = 0; i < newAttrValList.length; i++) {
|
n[i] = new AttributeValue(newAttrValList[i].attrName,newAttrValList[i].attrVal);
|
}
|
return n;
|
}
|
|
/**
|
* 前端的查询条件转换为平台需要的查询对象
|
* @param conditionMap 查询条款
|
* @return 查询对象
|
*/
|
@Override
|
public Condition getConditionByMap(Map<String, String> conditionMap){
|
Condition mergeCondition = null;//组合后的查询条件
|
if(conditionMap!=null && conditionMap.size() > 0){
|
//先把所有的查询条件都转换为小写
|
//然后开始逐个遍历，主要是对_start和_end这样的
|
Iterator<String> itor = conditionMap.keySet().iterator();
|
while(itor.hasNext()){
|
String key = itor.next();
|
String value = conditionMap.get(key);
|
Condition condition = null;//本次的条件
|
Map<String,String> thisConditionMap = new HashMap<String, String>();
|
boolean isOr = false;
|
if(WebUtil.isNotNull(value) && value.startsWith(QueryOptionConstant.OR)){
|
isOr = true;
|
value = value.substring(4);
|
}
|
if(key.indexOf("_start")>-1 || key.indexOf("_end")>-1){//介于....之间
|
if(key.indexOf("_start")>-1){
|
String attr = key.replace("_start", "");
|
thisConditionMap.put(attr, value);
|
condition = OQTool.getCondition(thisConditionMap);
|
if(conditionMap.containsKey(attr + "_end")){//如果没有结束，其实也是允许的；
|
Map<String,String> endConditonMap = new HashMap<String, String>();
|
endConditonMap.put(attr, conditionMap.get(attr + "_end"));
|
condition = OQTool.mergeCondition(condition, OQTool.getCondition(endConditonMap), Connector.AND);
|
}
|
}
|
}else{
|
if(("creator".equalsIgnoreCase(key) || "lastmodifier".equalsIgnoreCase(key)) && StringUtils.isNotBlank(value) ){
|
//说明是查询创建人和最后修改人
|
//模糊，等于，不等于，其余的不处理姓名
|
if(value.contains("*")) {
|
//说明是like
|
String userValue = value.replace("*", "%");
|
thisConditionMap.put(key, QueryOptionConstant.IN + "(select plusername from pluser where plusername like '" + userValue + "' or pltruename like '" + userValue + "')");
|
}else if(value.startsWith(QueryOptionConstant.NOTEQUAL)){
|
thisConditionMap.put(key, QueryOptionConstant.NOTIN + "(select plusername from pluser where plusername = '" + value + "' or pltruename = '" + value + "')");
|
}else if(value.startsWith(QueryOptionConstant.EQUAL)){
|
thisConditionMap.put(key, QueryOptionConstant.IN + "(select plusername from pluser where plusername = '" + value + "' or pltruename = '" + value + "')");
|
}else{
|
thisConditionMap.put(key, value);
|
}
|
}else {
|
thisConditionMap.put(key, value);
|
}
|
condition = OQTool.getCondition(thisConditionMap);
|
}
|
if(mergeCondition == null){
|
mergeCondition = condition;
|
}else{
|
mergeCondition = OQTool.mergeCondition(mergeCondition, condition, isOr? Connector.OR:Connector.AND);
|
}
|
}
|
}
|
return mergeCondition;
|
}
|
|
/**
|
* 根据属性来查询主键
|
*
|
* @param referInfo 业务类型.属性名
|
* @param value 属性的值
|
* @return 查询后的值
|
* @throws VciBaseException 查询出错的时候会抛出异常
|
*/
|
@Override
|
public Map<String, String> queryOidByPropertie(String referInfo, List<String> value) throws VciBaseException {
|
WebUtil.alertNotNull(referInfo,"参照信息",value,"参照的内容");
|
if(referInfo.indexOf(".") < 0){
|
throw new VciBaseException("参照的信息必须是【业务类型.属性】这样的格式");
|
}
|
String btmName = referInfo.split("\\.")[0].trim().toLowerCase();
|
String fieldName = referInfo.split("\\.")[1].trim().toLowerCase();
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put(fieldName,QueryOptionConstant.IN + "(" + WebUtil.toInSql(value.toArray(new String[0])) + ")");
|
List<BusinessObject> cbos = queryCBO(btmName,conditionMap,null, Arrays.asList(new String[]{"oid",fieldName}));
|
|
Map<String,String> data = new HashMap<String, String>();
|
if(cbos!=null && cbos.size() > 0){
|
for(BusinessObject cbo : cbos){
|
data.put(ObjectTool.getBOAttributeValue(cbo,fieldName),cbo.oid);
|
}
|
}
|
return data;
|
}
|
|
/**
|
* 校验特定属性的值是否存在
|
*
|
* @param btmName 业务类型
|
* @param columnName 列名称
|
* @param columnValues 列的值
|
* @return true表示存在这个值
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public boolean checkDataExsitByColumn(String btmName, String columnName, Collection<String> columnValues) throws VciBaseException {
|
WebUtil.alertNotNull(btmName,"业务类型",columnName,"属性名称",columnValues,"属性" + columnName + "的值");
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
Set<String> oidSet = new HashSet<String>();
|
for(String oid : columnValues){
|
if(StringUtils.isNotBlank(oid)){
|
oidSet.add(oid);
|
}
|
}
|
if(oidSet.size() == 0){
|
throw new VciBaseException("属性" + columnName + "的值为空");
|
}
|
conditionMap.put(columnName,QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oidSet.toArray(new String[0])) + ")");
|
List<BusinessObject> cbos = queryCBO(btmName,conditionMap,null,Arrays.asList(new String[]{columnName}));
|
if(cbos !=null && cbos.size() >0){
|
for(BusinessObject cbo : cbos){
|
String oid = ObjectTool.getBOAttributeValue(cbo,columnName);
|
if(oidSet.contains(oid)){
|
oidSet.remove(oid);
|
}
|
}
|
if(oidSet.size()>0){
|
throw new VciBaseException("属性" + columnName + "的值有" + oidSet.size() + "个不存在");
|
}
|
return true;
|
}else{
|
throw new VciBaseException("属性" + columnName + "的值全部不存在");
|
}
|
}
|
|
/**
|
* 校验特定属性的值是否存在
|
*
|
* @param btmName 业务类型
|
* @param columnName 列名称
|
* @param columnValues 列的值
|
* @return
|
* @throws VciBaseException
|
*/
|
@Override
|
public boolean checkDataExsitByColumn(String btmName, String columnName, String columnValues) throws VciBaseException {
|
WebUtil.alertNotNull(columnValues,"属性" + columnName + "的值");
|
return checkDataExsitByColumn(btmName,columnName,Arrays.asList(columnValues.split(",")));
|
}
|
|
/**
|
* 根据查询条件来查询业务类型下的数据
|
* @param btmType 业务类型的名称，会自动变成小写
|
* @param conditionMap 查询条件，注意介于...之间使用xxx_start和xxx_end
|
* @return 业务数据列表
|
* @throws VciBaseException 查询出错的是抛出异常
|
*/
|
@Override
|
public List<BusinessObject> queryCBO(String btmType,
|
Map<String, String> conditionMap) throws VciBaseException {
|
List<String> clauseList = new ArrayList<String>();
|
clauseList.add("*");
|
PageHelper ph = new PageHelper(-1);
|
return queryCBO(btmType,conditionMap,ph,clauseList);
|
}
|
|
/**
|
* 支持排序和分页的查询业务类型下的数据
|
* @param btmType 业务类型的名称
|
* @param conditionMap 查询条件，注意介于...之间使用xxx_start和xxx_end
|
* @param ph 排序和分页
|
* @return 业务数据列表
|
* @throws VciBaseException 查询出错的是抛出异常
|
*/
|
@Override
|
public List<BusinessObject> queryCBO(String btmType,
|
Map<String, String> conditionMap, PageHelper ph)
|
throws VciBaseException {
|
List<String> clauseList = new ArrayList<String>();
|
clauseList.add("*");
|
return queryCBO(btmType,conditionMap,ph,clauseList);
|
}
|
|
/**
|
* 使用查询方案来查询数据，返回CBO
|
* @param btmType 业务类型名称
|
* @param conditionMap 查询条件
|
* @param ph 分页对象
|
* @param clauseList 查询字段
|
* @return 业务数据列表
|
* @throws VciBaseException 查询出错的是抛出异常
|
*/
|
@Override
|
public List<BusinessObject> queryCBO(String btmType,
|
Map<String, String> conditionMap, PageHelper ph,
|
List<String> clauseList) throws VciBaseException {
|
QueryTemplate qt = new QueryTemplate();
|
//基础设置
|
qt.setId("queryBOHasPage");
|
qt.setType(QTConstants.TYPE_BTM);
|
qt.setBtmType(btmType.toLowerCase());
|
return baseQueryCBO(qt, conditionMap, ph, clauseList);
|
}
|
|
/**
|
* 设置是否过滤数据权限
|
* @param qt 查询模板
|
* @param conditionMap 查询条件
|
*/
|
private void setRightValueToQueryTemplate(QueryTemplate qt,Map<String,String> conditionMap){
|
boolean filterDataRight = webProperties.isDataRight();
|
if(conditionMap == null){
|
conditionMap = new HashMap<String, String>();
|
}
|
if(conditionMap.containsKey(QUERY_FILTER_DATARIGHT)){
|
if(BooleanEnum.TRUE.getValue().equals(conditionMap.get(QUERY_FILTER_DATARIGHT).toLowerCase())){
|
filterDataRight = true;
|
}else{
|
filterDataRight = false;
|
}
|
conditionMap.remove(QUERY_FILTER_DATARIGHT);
|
}
|
boolean filterSecret = webProperties.isSecretRight();
|
if(conditionMap.containsKey(QUERY_FILTER_SECRET)){
|
if(BooleanEnum.TRUE.getValue().equals(conditionMap.get(QUERY_FILTER_SECRET).toLowerCase())){
|
filterSecret = true;
|
}else{
|
filterDataRight = false;
|
}
|
conditionMap.remove(QUERY_FILTER_SECRET);
|
}
|
qt.setRightFlag(filterDataRight);
|
qt.setSecretFlag(filterSecret);
|
}
|
|
/**
|
* 基础的查询方法
|
* @param qt 查询模板
|
* @param conditionMap 查询条件
|
* @param ph 分页
|
* @param clauseList 查询字段
|
* @return 查询出来的值
|
* @throws VciBaseException 查询出错的时候会抛出异常
|
*/
|
private List<BusinessObject> baseQueryCBO(QueryTemplate qt,Map<String,String> conditionMap,PageHelper ph,List<String> clauseList) throws VciBaseException{
|
List<BusinessObject> allCbos = new ArrayList<BusinessObject>();
|
if(clauseList == null){
|
clauseList = new ArrayList<String>();
|
clauseList.add("*");
|
}
|
setRightValueToQueryTemplate(qt,conditionMap);//设置密级查询，和数据权限控制
|
List<BtmRefQueryOption> refOpts = new ArrayList<BtmRefQueryOption>();
|
List<String> enumAttrName = new ArrayList<String>();
|
List<String> thisQueryAttr = new ArrayList<String>();
|
if(clauseList!=null && clauseList.size()>0){
|
for(String attrName : clauseList){
|
if(attrName.indexOf(".")>-1){
|
String[] kvs = attrName.split("\\.");
|
int len = kvs.length;
|
if(len == 2){
|
// 一层参照 a.b
|
// 第二个参数给空，是此不处从属性中查其参数的业务类型，由下下专用掊中进行处理
|
BtmRefQueryOption refOpt = new BtmRefQueryOption(
|
kvs[0], "", new String[]{kvs[1]}
|
);
|
refOpts.add(refOpt);
|
} else if(len == 3){
|
// 二层参照 a.b.c
|
// TODO 需要支持两层参照
|
} else {
|
// 三层以的参照 a.b.c.d a.b.c.d.e
|
// TODO 需要支持三层以及以上的参照
|
}
|
}else if(attrName.indexOf("_")>-1
|
&& !"lcStatus_text".toLowerCase().equalsIgnoreCase(attrName.toLowerCase())){
|
enumAttrName.add(attrName);
|
}else{
|
thisQueryAttr.add(attrName);
|
}
|
}
|
}
|
if(thisQueryAttr.isEmpty()){
|
thisQueryAttr.add("*");
|
}
|
//设置查询字段,这个必须是当前业务类型中的查询字段
|
qt.setClauseList(thisQueryAttr);
|
conditionMap = WebUtil.getNotNullMap(conditionMap);
|
Condition condition = getConditionByMap(conditionMap);
|
if(qt.getCondition() !=null) {
|
qt.setCondition(OQTool.mergeCondition(qt.getCondition(), condition, Connector.AND));
|
}else {
|
qt.setCondition(condition);
|
}
|
qt.setLevel(-1);//对于业务类型来说没有作用
|
|
//设置分页信息和排序
|
setPageAndOrderToQT(qt,ph);
|
try {
|
ObjectQueryServicePrx qtService = platformClientUtil.getQueryService();
|
if(qtService == null){
|
logger.error("没有找到查询服务");
|
throw new VciBaseException(msgCodePrefix+"qtServerNull", new String[]{});
|
}
|
ObjectQueryService.FindBTMObjectsV3Result bos = qtService.findBTMObjectsV3(qt.getId(), OQTool.qtTOXMl(qt).asXML(), refOpts.toArray(new BtmRefQueryOption[refOpts.size()]));
|
if (bos != null && bos.count > 0) {
|
for (BusinessObject bo : bos.returnValue) {
|
// BusinessObject cbo = new BusinessObject();
|
// cbo = bo;
|
queryEnumText(bo,enumAttrName);
|
allCbos.add(bo);
|
}
|
//因为修改了查询的方式，所以就不需要单独查询参照
|
}
|
queryLcStatus(allCbos);
|
} catch (PLException e) {
|
throw WebUtil.getVciBaseException(e);
|
}
|
return allCbos;
|
}
|
|
public AttributeValue[] copyToAttributeValue(AttributeValue[] attributeValues){
|
AttributeValue[] attributeValueList = new AttributeValue[attributeValues.length];
|
for (int i = 0; i < attributeValues.length; i++) {
|
AttributeValue newAttributeValue = new AttributeValue();
|
newAttributeValue.attrName = attributeValues[i].attrName;
|
newAttributeValue.attrVal = attributeValues[i].attrVal;
|
attributeValueList[i] = newAttributeValue;
|
}
|
return attributeValueList;
|
}
|
|
/**
|
* 拷贝分页和排序的设置到查询模板
|
* @param qt 查询，模板
|
* @param pageHelper 分页对象
|
*/
|
@Override
|
public void setPageAndOrderToQT(QueryTemplate qt,PageHelper pageHelper){
|
if(pageHelper!=null){
|
if(pageHelper.getLimit()>0){
|
PageInfo pageInfo = new PageInfo();
|
pageInfo.setPageNO(pageHelper.getPage());
|
pageInfo.setRowCount(pageHelper.getLimit());
|
qt.setPageInfo(pageInfo);
|
}
|
if(WebUtil.isNotNull(pageHelper.getSort()) && WebUtil.isNotNull(pageHelper.getOrder())){
|
//设置了排序
|
String[] sort = pageHelper.getSort().split(",");
|
String[] order = pageHelper.getOrder().split(",");
|
if(sort.length != order.length){
|
throw new VciBaseException(msgCodePrefix + "sortlengtherror",new Object[]{sort.length,order.length});
|
}
|
List<OrderInfo> orderInfoList = new ArrayList<OrderInfo>();
|
for(int i = 0 ; i < sort.length ;i++){
|
OrderInfo oi = new OrderInfo();
|
oi.setOrderField(sort[i]);
|
oi.setOrderMode(order[i]);
|
oi.setLevel(sort.length -i);//值越大优先级越大，而排在数组的前面的优先级越大
|
orderInfoList.add(oi);
|
}
|
qt.setOrderInfoList(orderInfoList);
|
}
|
}
|
}
|
|
/**
|
* 获取所有的枚举属性
|
* @param allAttrMap 所有的属性
|
* @return 获取属性中的枚举属性
|
*/
|
private List<String> getEnumAttrName(Map<String,String> allAttrMap){
|
List<String> enumAttrName = new ArrayList<String>();
|
if(allAttrMap!=null && allAttrMap.size() > 0){
|
for(String attr : allAttrMap.keySet()){
|
if(attr.indexOf("_")>-1
|
&& !"lcStatus_text".toLowerCase().equalsIgnoreCase(attr)){
|
enumAttrName.add(attr);
|
}
|
}
|
}
|
return enumAttrName;
|
}
|
|
/**
|
* 获取引用的属性---只支持一级参照
|
* @param allAttrMap 所有的属性
|
* @return 枚举属性
|
*/
|
private Map<String,String> getReferAttrName(Map<String,String> allAttrMap){
|
Map<String,String> referAttrName = new HashMap<String,String>();
|
if(allAttrMap!=null && allAttrMap.size() > 0){
|
for(String attr : allAttrMap.keySet()){
|
if(attr.indexOf(".")>-1){
|
referAttrName.put(attr,allAttrMap.get(attr));
|
}
|
}
|
}
|
return referAttrName;
|
}
|
|
/**
|
* 查询生命周期的值
|
* @param cbos 业务对象
|
*/
|
private void queryLcStatus(List<BusinessObject> cbos){
|
if(!CollectionUtils.isEmpty(cbos)){
|
|
Map<String, OsStatusVO> statusVOMap = statusService.selectAllStatusMap();
|
cbos.stream().forEach(cbo->{
|
try{
|
ObjectTool.setBOAttributeValue(cbo,"lcStatus_text", statusVOMap.getOrDefault(cbo.lcStatus,new OsStatusVO()).getName());
|
}catch(Exception e){
|
logger.error("获取生命周期中状态的显示文本出错",e);
|
}
|
});
|
}
|
}
|
|
/**
|
* 查询业务对象上的枚举值
|
* @param cbo 业务对象
|
* @param enumAttrName 枚举属性的值
|
* @throws VciBaseException
|
*/
|
private void queryEnumText(BusinessObject cbo,List<String> enumAttrName) throws VciBaseException{
|
queryEnumText(cbo,null,enumAttrName);
|
}
|
|
/**
|
* 查询枚举的信息
|
* @param cbo 业务数据
|
* @param clo 链接属性
|
* @param enumAttrName 枚举的名称
|
* @throws VciBaseException 查询枚举出错的时候会抛出异常
|
*/
|
@Override
|
public void queryEnumText(BusinessObject cbo, LinkObject clo, List<String> enumAttrName) throws VciBaseException{
|
if(enumAttrName.size()>0){//查询枚举
|
for(String enumAttr:enumAttrName){//格式为 code_field code是枚举的编码，field是当前业务类型存储枚举值的字段
|
if(enumAttr.toLowerCase().equals("creator_name")){
|
//创建人的名称
|
String creator = "";
|
if(cbo!=null){
|
creator = cbo.creator;
|
}else{
|
creator = clo.creator;
|
}
|
if(StringUtils.isNotBlank(creator)){
|
String userTrueName = userQueryService.getUserNameByUserId(creator);
|
setValueToCboOrClo(cbo,clo,"creator_name",userTrueName);
|
}
|
}else if(enumAttr.toLowerCase().equals("lastmodifier_name")){
|
//最后修改人名称
|
String modifier = "";
|
if(cbo!=null){
|
modifier = cbo.modifier;
|
}else{
|
modifier = clo.modifier;
|
}
|
if(StringUtils.isNotBlank(modifier)){
|
String userTrueName = userQueryService.getUserNameByUserId(modifier);
|
setValueToCboOrClo(cbo,clo,"lastmodifier_name",userTrueName);
|
}
|
}else if(enumAttr.toLowerCase().endsWith("${user_name}")){
|
String usernameField = enumAttr.toLowerCase();
|
String fields= usernameField.replace("${user_name}","");
|
if(fields.contains("_")){
|
String valueField = "";
|
valueField = fields.split("_")[0];
|
String value = ObjectTool.getBOAttributeValue(cbo,valueField);;
|
if(StringUtils.isNotBlank(value)){
|
String userTrueName = userQueryService.getUserNameByUserId(value);
|
setValueToCboOrClo(cbo,clo,enumAttr,userTrueName);
|
}
|
}
|
}else {
|
String[] tempArray = enumAttr.split("_");
|
String enumCode = tempArray[0];//枚举编码
|
if (tempArray.length > 1) {
|
//从枚举中获取值
|
String valueFieldName = tempArray[1];
|
String comboxField = "";
|
if(valueFieldName.contains("#")){
|
valueFieldName = tempArray[1].split("#")[0];
|
comboxField = tempArray[1].split("#")[1];
|
}
|
String enumKey = "";
|
if (cbo != null) {
|
enumKey = ObjectTool.getBOAttributeValue(cbo,valueFieldName);
|
} else if (clo != null) {
|
enumKey = ObjectTool.getLOAttributeValue(clo,valueFieldName);
|
}
|
String enumText = "";
|
if (WebUtil.isNotNull(enumKey)) {
|
enumText = enumService.getValue(enumCode, enumKey);
|
}
|
if(StringUtils.isNotBlank(comboxField)){
|
setValueToCboOrClo(cbo, clo, comboxField, enumText);
|
}else {
|
setValueToCboOrClo(cbo, clo, enumAttr.toLowerCase(), enumText);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* 为业务类型设置值
|
* @param cbo 业务类型
|
* @param clo 链接类型
|
* @param attr 属性名
|
* @param value 值
|
*/
|
private void setValueToCboOrClo(BusinessObject cbo,LinkObject clo,String attr,String value){
|
try {
|
if (cbo != null) {
|
ObjectTool.setBOAttributeValue(cbo, attr, value);
|
}else{
|
setAttributeValueForClo(clo,attr, value);
|
}
|
} catch (Exception e) {
|
logger.error("setValueToCboOrClo",e);
|
}
|
}
|
|
/**
|
* 给链接类型设置属性
|
* @param clo 链接类型
|
* @param attributeName 属性的名称
|
* @param attributeValue 属性的值
|
*/
|
@Override
|
public void setAttributeValueForClo(LinkObject clo, String attributeName, String attributeValue) {
|
AttributeValue[] attrValues = clo.newAttrValList;
|
ArrayList<AttributeValue> attrValList = new ArrayList();
|
AttributeValue attrVal;
|
int i;
|
if (attrValues != null && attrValues.length > 0) {
|
AttributeValue[] var9 = attrValues;
|
i = attrValues.length;
|
|
for (int var7 = 0; var7 < i; ++var7) {
|
attrVal = var9[var7];
|
attrValList.add(attrVal);
|
}
|
}
|
|
attrVal = null;
|
boolean isExist = false;
|
|
for (i = 0; i < attrValList.size(); ++i) {
|
attrVal = (AttributeValue) attrValList.get(i);
|
if (attrVal.attrName.toUpperCase().equals(attributeName.toUpperCase())) {
|
attrVal.attrVal = attributeValue;
|
isExist = true;
|
break;
|
}
|
}
|
|
if (!isExist) {
|
attrVal = new AttributeValue();
|
attrVal.attrName = attributeName.toUpperCase();
|
attrVal.attrVal = attributeValue;
|
attrValList.add(attrVal);
|
}
|
|
clo.newAttrValList = attrValList.toArray(new AttributeValue[attrValList.size()]);
|
}
|
|
|
/**
|
* 查询链接类型中的枚举属性的对应值
|
* @param clo 链接类型
|
* @param enumAttrName 枚举属性
|
* @throws VciBaseException 查询出错的时候会抛出异常
|
*/
|
private void queryEnumTextClo(LinkObject clo,List<String> enumAttrName) throws VciBaseException{
|
queryEnumText(null,clo,enumAttrName);
|
}
|
|
/**
|
* 使用查询方案来查询数据，返回CBO，支持分页
|
* @param queryScheme 查询方案
|
* @param conditionMap 查询条件
|
* @param replaceMap 替换查询方案里的变量值
|
* @return 业务类型
|
* @throws VciBaseException 查询出错的时候会抛出异常
|
*/
|
@Override
|
public List<BusinessObject> queryCBOByScheme(String queryScheme,
|
Map<String, String> conditionMap, Map<String, String> replaceMap)
|
throws VciBaseException {
|
PageHelper ph = new PageHelper(-1);
|
return queryCBOByScheme(queryScheme,conditionMap,replaceMap,ph);
|
}
|
|
|
/**
|
* 使用查询方案来查询数据，返回CBO，支持自定义查询字段，包括参照和枚举;参照字段使用xxx.yy;枚举字段使用xxx_enumCode
|
* @param queryScheme 查询方案
|
* @param conditionMap 查询条件
|
* @param replaceMap 替换查询方案里的变量值
|
* @param ph 分页和排序
|
* @return 业务数据
|
* @throws VciBaseException 查询出错的时候会抛出异常
|
*/
|
@Override
|
public List<BusinessObject> queryCBOByScheme(String queryScheme,
|
Map<String, String> conditionMap, Map<String, String> replaceMap,
|
PageHelper ph) throws VciBaseException {
|
List<String> clauseList = new ArrayList<String>();
|
clauseList.add("*");
|
return queryCBOByScheme(queryScheme,conditionMap,replaceMap,ph,clauseList);
|
}
|
|
/**
|
* 使用名字获取查询模板
|
* @param name 名称
|
* @param replaceMap 源数据
|
* @return 查询模板
|
* @throws VciBaseException 查询出错的时候会抛出异常
|
*/
|
@Override
|
public QueryTemplate getQtByName(String name, Map<String, String> replaceMap) throws VciBaseException{
|
QueryTemplate qt = null;
|
try{
|
VciBaseUtil.alertNotNull(name,"查询模板的名称");
|
QTInfo wrapper = platformClientUtil.getQTDService().getQT(name);
|
qt = OQTool.getQTByDoc(DocumentHelper.parseText(wrapper.qtText), name);
|
//因为之前平台的Tool.replaceQTValues 没有处理 ${xxx}。， 为了忽略大小写，我们这里单独处理 weidy@2021-3-10
|
//我们转换为小写
|
Condition condition = qt.getCondition();
|
Map<String,String> replaceLowMap = new HashMap<>();
|
if(condition !=null && condition.getCIMap()!=null){
|
// Map<String, String> systemVarValueMap = VciSystemVarConstants.getSystemVarValueMap();
|
if(!CollectionUtils.isEmpty(replaceMap)){
|
replaceMap.forEach((key,value)->{
|
replaceLowMap.put(key.toLowerCase(),value);
|
});
|
}
|
Map<String, ConditionItem> ciMap = condition.getCIMap();
|
ciMap.forEach((ciId,ci)->{
|
if(ci.isLeaf()) {
|
LeafInfo lInfo = ci.getLeafInfo();
|
String value = lInfo.getValue().getOrdinaryValue();
|
if(StringUtils.isNotBlank(value)){
|
if(value.contains("#")){
|
//系统变量.支持一个
|
//lInfo.getValue().setOrdinaryValue(systemVarValueMap.getOrDefault(value.toUpperCase(),""));
|
}else if(value.contains("${")){
|
//有${xxxx}的方式
|
if(!CollectionUtils.isEmpty(replaceLowMap)) {
|
try {
|
lInfo.getValue().setOrdinaryValue(VciBaseUtil.replaceByFreeMarker(value, replaceLowMap));
|
}catch (Throwable e){
|
logger.error("可能配置有问题，在转换freemarker表达式的时候，没有找到对应的值，目前表达式为{}",new String[]{value},e);
|
}
|
}
|
}else if(replaceLowMap.containsKey(value.toLowerCase())){
|
lInfo.getValue().setOrdinaryValue(replaceLowMap.get(value.toLowerCase()));
|
}
|
}
|
}
|
});
|
}
|
}catch(PLException e){
|
logger.error(e.code,e);
|
throw WebUtil.getVciBaseException(e);
|
} catch (DocumentException e) {
|
logger.error("查询模板转换",e);
|
throw new VciBaseException(this.msgCodePrefix + "qtError", new Object[]{name});
|
}
|
return qt;
|
}
|
|
/**
|
* 根据查询模板来查询数据
|
* @param queryScheme 查询方案
|
* @param conditionMap 查询条件
|
* @param replaceMap 替换查询方案里的变量值
|
* @param ph 分页和排序
|
* @param clauseList 查询字段
|
* @return 业务数据列表
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public List<BusinessObject> queryCBOByScheme(String queryScheme,
|
Map<String, String> conditionMap, Map<String, String> replaceMap,
|
PageHelper ph, List<String> clauseList) throws VciBaseException {
|
QueryTemplate qt = getQtByName(queryScheme,replaceMap);
|
return baseQueryCBO(qt,conditionMap,ph,clauseList);
|
}
|
|
/**
|
* 查询个数
|
* @param qt 查询模板
|
* @param conditionMap 查询条件
|
* @return 个数
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
private int baseQueryCount(QueryTemplate qt,Map<String, String> conditionMap) throws VciBaseException{
|
List<String> clauseList = new ArrayList<String>();
|
clauseList.add("*");
|
qt.setClauseList(clauseList);
|
setRightValueToQueryTemplate(qt,conditionMap);//设置密级查询，和数据权限控制
|
conditionMap = WebUtil.getNotNullMap(conditionMap);
|
Condition condition = getConditionByMap(conditionMap);
|
if(qt.getCondition() !=null) {
|
qt.setCondition(OQTool.mergeCondition(qt.getCondition(), condition, Connector.AND));
|
}else {
|
qt.setCondition(condition);
|
}
|
long count = 0;
|
try{
|
count = platformClientUtil.getQueryService().findTotalCount(qt.getId(), OQTool.qtTOXMl(qt).asXML());
|
}catch (PLException e) {
|
logger.error(e.code,e);
|
throw WebUtil.getVciBaseException(e);
|
}
|
return (int) count;
|
}
|
|
/**
|
* 查询个数
|
* @param btmType 业务类型名称
|
* @param conditionMap 查询条件
|
* @return 个数
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public int queryCount(String btmType, Map<String, String> conditionMap)
|
throws VciBaseException {
|
QueryTemplate qt = new QueryTemplate();
|
qt.setId("queryBOCount");
|
if(btmType.endsWith("_link")){
|
qt.setType(QTConstants.TYPE_LINK);
|
}else{
|
qt.setType(QTConstants.TYPE_BTM);
|
}
|
qt.setBtmType(btmType.toLowerCase());
|
return baseQueryCount(qt,conditionMap);
|
}
|
/**
|
* 使用sql查询个数，最终的字段必须是count
|
* @param sql 查询的sql
|
* @param conditionMap 查询条件
|
* @return 个数，
|
* @throws VciBaseException 查询出错的时候会抛出异常
|
*/
|
@Override
|
public int queryCountBySql(String sql,Map<String,String> conditionMap) throws VciBaseException{
|
WebUtil.alertNotNull(sql,"sql语句");
|
AttributeValue[] ava = null;
|
if(conditionMap!=null&&!conditionMap.isEmpty()){
|
ava = new AttributeValue[conditionMap.size()];
|
Iterator<String> it = conditionMap.keySet().iterator();
|
int i = 0 ;
|
while(it.hasNext()){
|
String key = it.next();
|
String value = conditionMap.get(key);
|
if(value == null){
|
value = "";
|
}
|
AttributeValue av = new AttributeValue(key, value);
|
ava[i] = av;
|
i++;
|
}
|
}else{
|
ava = new AttributeValue[0];
|
}
|
try {
|
String[][] results = platformClientUtil.getBOFactoryService().getSqlQueryResult(sql, ava);
|
if(results!=null && results.length>0 && results[0] != null && results[0].length>0){
|
return WebUtil.getInt(results[0][0]);
|
}
|
} catch (PLException e) {
|
throw new RuntimeException(e);
|
}
|
return 0;
|
}
|
|
/**
|
* 根据方案查询个数
|
* @param queryScheme 查询方案
|
* @param conditionMap 查询条件
|
* @param replaceMap 替换查询方案里的变量值
|
* @return 个数
|
* @throws VciBaseException 查询出错的时候会抛出异常
|
*/
|
@Override
|
public int queryCountByScheme(String queryScheme,
|
Map<String, String> conditionMap, Map<String, String> replaceMap)
|
throws VciBaseException {
|
QueryTemplate qt = getQtByName(queryScheme,replaceMap);
|
return baseQueryCount(qt,conditionMap);
|
}
|
|
/**
|
* 使用对象里的查询方案来查询数量
|
* @param c 对象所属类
|
* @param conditionMap 查询条件
|
* @return 数量
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public int queryCount(Class c, Map<String, String> conditionMap)
|
throws VciBaseException {
|
return queryCount(WebUtil.getBtmTypeByObject(c), conditionMap);
|
}
|
|
/**
|
* 根据sql语句来查询内容 --sql不能是select * 或者 select t.*
|
* @param sql 为了防止SQL注入，值必须在sql语句里以:xxx格式，如 id =:idvalue，然后在conditionMap中添加建为idvalue的格式
|
* @param conditionMap 查询条件，必须与sql里对应
|
* @return CBO
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public List<BusinessObject> queryBySql(String sql,
|
Map<String, String> conditionMap) throws VciBaseException {
|
List<Map> allData = queryBySqlForMap(sql,conditionMap);
|
if(allData == null || allData.size() == 0){
|
return new ArrayList<BusinessObject>();
|
}else{
|
return map2Cbos(allData);
|
}
|
}
|
|
/**
|
* 只用sql语句查询，这个和queryBySql区别是，特殊的sql(如包含有函数的)可以用这个方法，但是有sql注入风险
|
* @param sql sql语句，查询条件必须自行在其中处理完成
|
* @return CBO
|
* @throws VciBaseException 查询出错活抛出异常
|
*/
|
@Override
|
public List<BusinessObject> queryByOnlySql(String sql) throws VciBaseException{
|
List<Map> allData = queryByOnlySqlForMap(sql);
|
if(allData == null || allData.size() == 0){
|
return new ArrayList<BusinessObject>();
|
}else{
|
return map2Cbos(allData);
|
}
|
}
|
|
/**
|
* 只用sql语句查询，这个和queryBySqlForMap区别是，特殊的sql(如包含有函数的)可以用这个方法，但是有sql注入风险
|
* @param sql sql语句，查询条件必须自行在其中处理完成
|
* @return 数据映射
|
* @throws VciBaseException 查询出错活抛出异常
|
*/
|
@Override
|
public List<Map> queryByOnlySqlForMap(String sql) throws VciBaseException{
|
if(StringUtils.isBlank(sql)){
|
return new ArrayList<>();
|
}
|
List<Map> dataList = new ArrayList<>();
|
try {
|
KV[][] kvs = platformClientUtil.getQueryService().queryBySql(sql);
|
if(kvs!=null && kvs.length>0){
|
for (int i = 0; i < kvs.length; i++) {
|
Map<String,String> data = new HashMap<>();
|
KV[] kv = kvs[i];
|
if(kv!=null && kv.length >0){
|
for (int j = 0; j < kv.length; j++) {
|
KV kv1 = kv[j];
|
data.put(kv1.key,kv1.value);
|
}
|
}
|
dataList.add(data);
|
}
|
}
|
} catch (PLException e) {
|
throw WebUtil.getVciBaseException(e);
|
}
|
return dataList;
|
}
|
|
/**
|
* 使用sql语句查询后转换为对象
|
* @param sql sql语句
|
* @param tClass 对象的类
|
* @param <T> 泛型
|
* @return 数据的列表
|
* @throws VciBaseException 查询和转换出错会抛出异常
|
*/
|
@Override
|
public <T> List<T> queryByOnlySqlForObj(String sql, Class<T> tClass) throws VciBaseException{
|
List<Map> allData = queryByOnlySqlForMap(sql);
|
//需要转换一下cbo的那个属性
|
Map<String/**业务类型中的字段*/, String/**属性里的字段**/> fieldNameMap = WebUtil.getFieldNameMap(tClass);
|
List<T> dataList = new ArrayList<>();
|
if(!CollectionUtils.isEmpty(allData)){
|
allData.stream().forEach(data->{
|
Map thisData = new HashMap();
|
if(!CollectionUtils.isEmpty(data)){
|
data.forEach((key,value)->{
|
thisData.put(fieldNameMap.getOrDefault(((String)key).toLowerCase(Locale.ROOT), (String) key),value);
|
});
|
}
|
try {
|
Object o = VciBaseUtil.mapToBean(thisData, tClass);
|
dataList.add((T)o);
|
} catch (Exception e) {
|
if(logger.isErrorEnabled()){
|
logger.error("转换错误",e);
|
}
|
}
|
});
|
}
|
return dataList;
|
}
|
|
/**
|
* 根据sql语句来查询内容，返回Map----sql不能是select * 或者 select t.*
|
* @param sql 为了防止SQL注入，值必须在sql语句里以:xxx格式，如 id =:idvalue，然后在conditionMap中添加建为idvalue的格式
|
* @param conditionMap 查询条件，必须与sql里对应
|
* @return 业务数据的映射
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public List<Map> queryBySqlForMap(String sql,
|
Map<String, String> conditionMap) throws VciBaseException {
|
return queryBySqlForMap(sql,conditionMap,null);
|
}
|
|
/**
|
* 和上个方法一样，多传了查询字段 selectKeys
|
* @param sql sql语句
|
* @param conditionMap 查询条件
|
* @param selectKeys 查询的字段
|
* @return 数据
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public List<Map> queryBySqlForMap(String sql,Map<String, String> conditionMap, String[] selectKeys) throws VciBaseException {
|
|
if(WebUtil.isNull(sql) || sql.toLowerCase(Locale.ROOT).indexOf("select") <0 || sql.toLowerCase(Locale.ROOT).indexOf("from") < 0){
|
throw new VciBaseException(msgCodePrefix + "sqlError",new String[]{sql});
|
}
|
|
//处理大写FROM,平台查询会报错
|
if(sql.contains(" FROM ")){
|
sql = sql.replaceAll(" FROM "," from ");
|
}
|
|
AttributeValue[] ava = null;
|
if(conditionMap!=null&&!conditionMap.isEmpty()){
|
ava = new AttributeValue[conditionMap.size()];
|
Iterator<String> it = conditionMap.keySet().iterator();
|
int i = 0 ;
|
while(it.hasNext()){
|
String key = it.next();
|
String value = conditionMap.get(key);
|
if(value == null){
|
value = "";
|
}
|
AttributeValue av = new AttributeValue(key, value);
|
ava[i] = av;
|
i++;
|
}
|
}else{
|
ava = new AttributeValue[0];
|
}
|
try {
|
String[][] results =platformClientUtil.getSqlQueryService(sql, ava);
|
if(results.length>0){
|
if(selectKeys==null) {
|
String selectSql = sql.substring(sql.toLowerCase(Locale.ROOT).indexOf("select") + 6, sql.toLowerCase(Locale.ROOT).indexOf(" from")).trim();
|
selectKeys = selectSql.split(",");
|
}
|
List<Map> allData = new ArrayList<Map>();
|
for(int i = 0 ; i < results.length ;i ++){
|
String[] values = results[i];
|
Map<String,String> map = new HashMap<String, String>();
|
for(int j = 0 ; j < selectKeys.length; j ++){
|
String field = selectKeys[j];
|
if(WebUtil.isNotNull(field)){
|
//field = field.toLowerCase().trim();
|
//有可能有as的情况 或者空格 或者有.的情况
|
//必须优先处理as和空格的情况，最后处理.
|
if(field.indexOf(" as ")>-1){
|
field = field.substring(field.lastIndexOf(" as ") + 4);
|
}else if(field.indexOf(" ")>-1){
|
field =field.substring(field.lastIndexOf(" ") + 1);
|
}else if(field.indexOf(".")>-1){
|
field = field.substring(field.lastIndexOf(".") + 1);
|
}
|
//获取值
|
String value = "";
|
if(values.length>j){
|
value = values[j] == null?"":values[j];
|
}
|
map.put(field, value);
|
}
|
}
|
allData.add(map);
|
}
|
return allData;
|
}else{
|
return new ArrayList<Map>();
|
}
|
} catch (PLException e) {
|
// logger.error(e.error_code,e);
|
throw WebUtil.getVciBaseException(e);
|
}
|
}
|
|
|
/**
|
* 查询数据，返回对象，对象的字段上可以设置参照和枚举
|
* @param c 对象所属类
|
* @param conditionMap 查询条件
|
* @return 业务数据对象
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public <T> List<T> queryObject(Class<T> c, Map<String, String> conditionMap)
|
throws VciBaseException {
|
return queryObject(c,conditionMap,new PageHelper(-1));
|
}
|
|
/**
|
* 查询数据，返回对象，支持分页
|
* @param c 对象所属类
|
* @param conditionMap 查询条件
|
* @param ph 分页组件
|
* @return 业务数据对象
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public <T> List<T> queryObject(Class<T> c,
|
Map<String, String> conditionMap, PageHelper ph)
|
throws VciBaseException {
|
//直接从对象里去查询业务类型的名称
|
swapConditionMap(c,conditionMap);
|
//获取要查询的所有的列
|
Map<String,String> allFieldAttrMap = WebUtil.getFieldNameMap(c);
|
if(!allFieldAttrMap.containsKey("lctid")){
|
allFieldAttrMap.put("lctid","lctid");
|
}
|
List<String> queryAttr = new ArrayList<String>();
|
Iterator<String> it = allFieldAttrMap.keySet().iterator();
|
while(it.hasNext()){
|
queryAttr.add(it.next());
|
}
|
for(String columnName:queryAttr){
|
String fieldName = allFieldAttrMap.get(columnName);
|
allFieldAttrMap.remove(columnName);
|
allFieldAttrMap.put(columnName.toLowerCase(),fieldName);
|
}
|
List<T> allObject = new ArrayList<T>();
|
List<BusinessObject> allCbos = queryCBO(WebUtil.getBtmTypeByObject(c), conditionMap, ph, allFieldAttrMap.keySet().stream().collect(Collectors.toList()));//执行查询
|
List<String> oids = new ArrayList<String>();
|
|
if(allCbos!=null&&allCbos.size()>0){
|
for(BusinessObject cbo : allCbos){
|
T obj = null;
|
try {
|
obj = c.newInstance();
|
WebUtil.copyValueToObjectFromCbos(cbo, obj,allFieldAttrMap);//为了少去查询一次字段
|
} catch (InstantiationException e) {
|
|
} catch (IllegalAccessException e) {
|
}
|
if(obj !=null){
|
oids.add(cbo.oid);
|
allObject.add(obj);
|
}
|
}
|
}
|
return allObject;
|
}
|
|
/**
|
* 转换查询条件
|
* @param c 对象类
|
* @param conditionMap 查询条件
|
* @throws VciBaseException 转换出错
|
*/
|
private void swapConditionMap(Class c ,Map<String,String> conditionMap) throws VciBaseException{
|
WebUtil.alertNotNull(c,"对象所属类");
|
if(conditionMap == null){
|
conditionMap = new HashMap<String, String>();
|
}
|
conditionMap = WebUtil.getNotNullMap(conditionMap);
|
//对于是参照字段的，也要检查conditionMap里面是否有，有的话需要替换成xxx.yy这种格式
|
try{
|
if(conditionMap.size()>0){
|
Map<String,String> fieldMap = WebUtil.getFieldNameMap(c);
|
Iterator<String> it = fieldMap.keySet().iterator();
|
while(it.hasNext()){
|
String attrName = it.next();
|
if(attrName.indexOf(".")>-1){
|
//说明是参照的
|
String fieldName = fieldMap.get(attrName).toLowerCase();
|
if(conditionMap.containsKey(fieldName)){
|
String value = conditionMap.get(fieldName);
|
conditionMap.remove(fieldName);
|
conditionMap.put(attrName, value);
|
}
|
}
|
}
|
}
|
}catch(Throwable e){
|
if(logger.isErrorEnabled()){
|
logger.error("转换条件出错",e);
|
}
|
}
|
}
|
|
/**
|
* 使用查询方案来查询数据，返回对象，支持分页
|
* @param queryScheme 查询方案
|
* @param c 对象所属类
|
* @param conditionMap 查询条件
|
* @param ph 分页组件
|
* @return 业务对象
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public <T> List<T> queryObjectByScheme(String queryScheme, Class<T> c,
|
Map<String, String> conditionMap, PageHelper ph)
|
throws VciBaseException {
|
return queryObjectByScheme(queryScheme,c,conditionMap,ph,null);
|
}
|
|
/**
|
* 使用查询方案来查询数据，返回对象，支持分页
|
* @param queryScheme 查询方案
|
* @param c 对象所属类
|
* @param conditionMap 查询条件
|
* @param ph 分页组件
|
* @param replaceMap 替换查询方案中的变量值
|
* @return 数据对象
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public <T> List<T> queryObjectByScheme(String queryScheme, Class<T> c,
|
Map<String, String> conditionMap, PageHelper ph,
|
Map<String, String> replaceMap) throws VciBaseException {
|
WebUtil.alertNotNull(queryScheme,"查询方案");
|
//直接从对象里去查询业务类型的名称
|
swapConditionMap(c,conditionMap);
|
//获取要查询的所有的列
|
Map<String,String> allFieldAttrMap = WebUtil.getFieldNameMap(c);
|
List<String> queryAttr = new ArrayList<String>();
|
Iterator<String> it = allFieldAttrMap.keySet().iterator();
|
while(it.hasNext()){
|
queryAttr.add(it.next());
|
}
|
for(String columnName:queryAttr){
|
String fieldName = allFieldAttrMap.get(columnName);
|
allFieldAttrMap.remove(columnName);
|
allFieldAttrMap.put(columnName.toLowerCase(),fieldName);
|
}
|
List<T> allObject = new ArrayList<T>();
|
List<BusinessObject> allCbos = queryCBOByScheme(queryScheme, conditionMap, replaceMap,ph, allFieldAttrMap.keySet().stream().collect(Collectors.toList()));
|
List<String> oids = new ArrayList<String>();
|
if(allCbos!=null&&allCbos.size()>0){
|
for(BusinessObject cbo : allCbos){
|
T obj = null;
|
try {
|
obj = c.newInstance();
|
WebUtil.copyValueToObjectFromCbos(cbo, obj,allFieldAttrMap);//为了少去查询一次字段
|
} catch (InstantiationException e) {
|
|
} catch (IllegalAccessException e) {
|
}
|
if(obj !=null){
|
oids.add(cbo.oid);
|
allObject.add(obj);
|
}
|
}
|
}
|
return allObject;
|
}
|
|
/**
|
* 保存数据，可以在request中设置是否持久化
|
*
|
* @param obj 要保存的对象
|
* @return 保存后包含的数据对象
|
* @throws VciBaseException 添加出错会抛出异常
|
*/
|
@Override
|
public <T> BatchCBO addSave(T obj) throws VciBaseException {
|
List<T> list = new ArrayList<T>();
|
list.add(obj);
|
return batchAddSave(list);
|
}
|
|
/**
|
* 值加到查询条件的map里
|
* @param field 属性名字
|
* @param value 属性值
|
* @return 查询条件的map
|
*/
|
public Map<String, String> getOneQuery(String field, String value) {
|
return this.getOneQuery(field, value, "");
|
}
|
|
/**
|
* 值加到查询条件的map里
|
* @param field 属性名字
|
* @param value 属性值
|
* @param options 操作符
|
* @return 查询条件的map
|
*/
|
public Map<String, String> getOneQuery(String field, String value, String options) {
|
Map<String, String> conditionMap = new HashMap();
|
options = WebUtil.isNull(options) ? "" : (options.indexOf("\\") > -1 ? options.toUpperCase() : "\\" + options.toUpperCase());
|
conditionMap.put(field, options + value);
|
return conditionMap;
|
}
|
|
/**
|
* 设置值到业务数据对象上
|
* @param obj 对象的值
|
* @param btmType 业务类型的名称
|
* @param cbo 业务数据对象
|
* @param isEdit 是否为编辑
|
* @throws VciBaseException 设置出错会抛出异常
|
*/
|
private void setValueToCbo(Object obj,String btmType,BusinessObject cbo ,boolean isEdit) throws VciBaseException{
|
Field pkField = WebUtil.getPkFieldForObj(obj.getClass());
|
if(pkField == null){
|
throw new VciBaseException("{0}类中没有定义主键属性",new Object[]{obj.getClass()});
|
}
|
//主键
|
Object pkValue = WebUtil.getValueFromField(pkField.getName(), obj);
|
if(pkValue == null || (pkValue instanceof String && WebUtil.isNull(pkValue.toString()))){
|
WebUtil.setValueToField(pkField.getName(), obj, cbo.oid);
|
pkValue = cbo.oid;
|
}else{
|
cbo.oid = pkValue.toString();
|
}
|
//进行非空，长度，重复的校验。。校验通过的赋值
|
Map<String,String> fieldMap = WebUtil.getFieldNameMap(obj.getClass());
|
Iterator<String> it = fieldMap.keySet().iterator();
|
while(it.hasNext()){
|
String attrName = it.next();
|
String fieldName = fieldMap.get(attrName);
|
attrName = attrName.toLowerCase();
|
if(attrName.indexOf(".")<0 && attrName.indexOf("_")<0 && !attrName.toLowerCase().equalsIgnoreCase("lcstatus_text") && !attrName.toLowerCase().equals("lcstatustext")){//不是参照的属性才能赋值
|
Field thisField = WebUtil.getFieldForObject(fieldName, obj);
|
String value = WebUtil.getValueFromFieldForCbo(thisField, obj);
|
|
if(thisField.isAnnotationPresent(Column.class)){
|
//需要校验重复和为空.而且配置了Column的
|
Column column = (Column)thisField.getAnnotation(Column.class);
|
String columnText = column.columnDefinition();
|
columnText = StringUtils.isNotBlank(columnText)?columnText:fieldName;
|
//四个默认属性不判断非空
|
boolean is4 = false;//是不是4个属性
|
String[] defaultFieldName_notChecks = {"creator","lastModifier","ts","oid","createTime"};
|
//判断fieldName不是
|
for (String defaultFieldName_notCheck:defaultFieldName_notChecks){
|
if(defaultFieldName_notCheck.equals(fieldName)){
|
is4 = true;
|
}
|
}
|
if(!is4) {//不是4个属性才判断非空
|
//判断非空
|
if (!column.nullable() && WebUtil.isNull(value)) {
|
throw new VciBaseException("{0}字段不能为空", new Object[]{columnText});
|
}
|
}
|
|
value = value==null?"":value;
|
if(column.length()>0 && value.length()> column.length()){//长度
|
throw new VciBaseException("{0}字段的长度太长，要求{1},实际{2}", new Object[]{columnText,column.length(),value.length()});
|
}
|
if(!thisField.equals(pkField) && column.unique()){
|
//说明不能重复，那么就需要查询一下
|
Map<String,String> queryRepeatMap = getOneQuery(attrName, value);
|
if(isEdit){
|
queryRepeatMap.put("oid", QueryOptionConstant.NOTEQUAL + cbo.oid);
|
}
|
if(queryCount(btmType, queryRepeatMap)>0){
|
throw new VciBaseException("{0}字段的值{1}在系统中已经存在", new Object[]{columnText,value});
|
}
|
}
|
}
|
if(value==null){
|
continue;
|
}
|
if(isEdit && checkUnAttrUnEdit(attrName)){
|
//编辑的时候，TS和OID不能设置.因为平台那接口设置了就会报错
|
}else {
|
//需要判断是否默认的属性，如果是默认属性，则使用对象的赋值的方式
|
if (WebUtil.isDefaultField(fieldName) && WebUtil.inArray(new String[]{"id", "name", "description","lcstatus","revisionvalue","versionvalue"}, fieldName.toLowerCase())) {
|
WebUtil.setValueToField(fieldName, cbo, value);
|
ObjectTool.setBOAttributeValue(cbo, attrName.toLowerCase(), value);
|
} else {
|
ObjectTool.setBOAttributeValue(cbo, attrName.toLowerCase(), value);
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* 批量保存数据，可以在request里设置不持久化
|
* @param list 要保存的数据对象列表
|
* @return 需要创建的CBO,CLO;需要修改的CBO,CLO;需要删除的CBO,CLO
|
* @throws VciBaseException 报错出错会抛出异常
|
*/
|
@Override
|
public <T> BatchCBO batchAddSave(List<T> list)
|
throws VciBaseException {
|
if(list==null){
|
throw new VciBaseException(VciBaseException.paramNull);
|
}
|
Set<BusinessObject> allCbos = new HashSet<BusinessObject>();
|
for(T obj : list){
|
//需要处理默认值
|
Field pkField = WebUtil.getPkFieldForObj(obj.getClass());
|
if(pkField == null){
|
throw new VciBaseException("{0}对象中没有设置主键的属性",new Object[]{obj.getClass()});
|
}
|
String btmType = WebUtil.getBtmTypeByObject(obj.getClass());
|
BusinessObject cbo = createCBOByBtmName(btmType);
|
setValueToCbo(obj,btmType,cbo,false);
|
allCbos.add(cbo);
|
}
|
//因为使用了平台，事务没办法统一，所以只能是在服务调用服务之间的时候，返回要保存的数据；
|
BatchCBO batchCbo = new BatchCBO();
|
batchCbo.setCreateCbos(allCbos);
|
if(allCbos.size()>0 && WebUtil.isPersistence()){
|
if(logger.isInfoEnabled()) {
|
logger.info("执行了持久化");
|
}
|
persistenceBatch(batchCbo);
|
}
|
return batchCbo;
|
}
|
|
/**
|
* 修改数据，可以在request里设置不持久化
|
*
|
* @param obj 修改数据对象
|
* @return 需要创建的CBO, CLO;需要修改的CBO,CLO;需要删除的CBO,CLO
|
* @throws VciBaseException 修改出错会抛出异常
|
*/
|
@Override
|
public <T> BatchCBO editSave(T obj) throws VciBaseException {
|
List<Object> list = new ArrayList<Object>();
|
list.add(obj);
|
return batchEditSave(list);
|
}
|
|
|
/**
|
* 批量修改数据，可以在request里设置不持久化
|
* @param list 要保存的数据对象列表
|
* @return 需要创建的CBO,CLO;需要修改的CBO,CLO;需要删除的CBO,CLO
|
* @throws VciBaseException 修改出错会抛出异常
|
*/
|
@Override
|
public <T> BatchCBO batchEditSave(List<T> list)
|
throws VciBaseException {
|
if(list==null){
|
throw new VciBaseException(VciBaseException.paramNull);
|
}
|
Set<BusinessObject> allUpdateCbos = new HashSet<BusinessObject>();
|
Set<BusinessObject> allDeleteCbos = new HashSet<BusinessObject>();
|
Set<BusinessObject> allAddCbos = new HashSet<BusinessObject>();
|
Map<String,String> btmOidsMap = new HashMap<String, String>();
|
for(T obj : list){
|
String btmType = WebUtil.getBtmTypeByObject(obj.getClass());
|
String tempOids = "";
|
if(btmOidsMap.containsKey(btmType)){
|
tempOids = btmOidsMap.get(btmType);
|
}
|
|
Field pkField = WebUtil.getPkFieldForObj(obj.getClass());
|
if(pkField == null){
|
throw new VciBaseException("{0}对象中没有设置主键的属性",new Object[]{obj.getClass()});
|
}
|
//主键
|
Object pkValue = WebUtil.getValueFromField(pkField.getName(), obj);
|
if(pkValue == null || (pkValue instanceof String && WebUtil.isNull(pkValue.toString()))){
|
}else{
|
tempOids += "'" + pkValue.toString() + "',";
|
}
|
btmOidsMap.put(btmType, tempOids);
|
}
|
List<BusinessObject> needUpdateCbos = new ArrayList<BusinessObject>();
|
Iterator<String> it = btmOidsMap.keySet().iterator();
|
while(it.hasNext()){
|
String btmType = it.next();
|
String oids = WebUtil.removeComma(btmOidsMap.get(btmType));
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put("oid", QueryOptionConstant.IN +"(" + oids + ")");
|
needUpdateCbos.addAll(queryCBO(btmType, conditionMap));
|
}
|
//需要先从后台查询
|
for(T obj : list){
|
//需要处理默认值
|
Field pkField = WebUtil.getPkFieldForObj(obj.getClass());
|
if(pkField == null){
|
throw new VciBaseException("{0}对象中没有设置主键的属性",new Object[]{obj.getClass()});
|
}
|
//主键
|
Object pkValue = WebUtil.getValueFromField(pkField.getName(), obj);
|
BusinessObject cbo = null;
|
if(pkValue == null || (pkValue instanceof String && WebUtil.isNull(pkValue.toString()))){
|
continue;
|
}else{
|
for(BusinessObject tempCbo : needUpdateCbos){
|
if(tempCbo.oid.equalsIgnoreCase(pkValue.toString().trim())){
|
cbo = tempCbo;
|
break;
|
}
|
}
|
}
|
String btmType = WebUtil.getBtmTypeByObject(obj.getClass());
|
//拷贝之前先清除已经有的值
|
cbo.newAttrValList = new AttributeValue[0];
|
setValueToCbo(obj,btmType,cbo,true);
|
allUpdateCbos.add(cbo);
|
}
|
BatchCBO batchCbo = new BatchCBO();
|
batchCbo.setCreateCbos(allAddCbos);
|
batchCbo.setUpdateCbos(allUpdateCbos);
|
batchCbo.setDeleteCbos(allDeleteCbos);
|
//因为使用了平台，事务没办法统一，所以只能是在服务调用服务之间的时候，返回要保存的数据；
|
if(WebUtil.isPersistence()){
|
persistenceBatch(batchCbo);
|
}
|
return batchCbo;
|
}
|
|
/**
|
* 删除数据，可以在request里设置不持久化
|
*
|
* @param obj 删除数据对象
|
* @return 需要创建的CBO, CLO;需要修改的CBO,CLO;需要删除的CBO,CLO
|
* @throws VciBaseException 删除出错会抛出异常
|
*/
|
@Override
|
public <T> BatchCBO delete(T obj) throws VciBaseException {
|
return delete(obj,true);
|
}
|
@Override
|
public <T> BatchCBO delete(T obj,boolean checkRefered) throws VciBaseException{
|
List<T> list = new ArrayList<T>();
|
list.add(obj);
|
return batchDelete(list,checkRefered);
|
}
|
|
|
/**
|
* 批量删除数据，可以在request里设置不持久化
|
* @param list 需要删除数据对象列表
|
* @return 需要创建的CBO,CLO;需要修改的CBO,CLO;需要删除的CBO,CLO
|
* @throws VciBaseException 删除出错会抛出异常
|
*/
|
@Override
|
public <T> BatchCBO batchDelete(List<T> list)
|
throws VciBaseException {
|
return batchDelete(list,true);
|
}
|
|
/**
|
* 批量删除
|
* @param list 需要删除数据对象列表
|
* @param checkRefered 是否删除引用的数据
|
* @param <T> 类型
|
* @return 受影响的行数
|
* @throws VciBaseException 执行出错会抛出异常
|
*/
|
@Override
|
public <T> BatchCBO batchDelete(List<T> list,boolean checkRefered) throws VciBaseException{
|
if(list==null){
|
throw new VciBaseException(VciBaseException.paramNull);
|
}
|
Set<BusinessObject> allDeleteCbos = new HashSet<BusinessObject>();
|
Map<String,List<BusinessObject>> btmBos = new HashMap<String, List<BusinessObject>>();
|
for(Object obj : list){
|
//有可能不属于同一个业务类型下
|
Field pkField = WebUtil.getPkFieldForObj(obj.getClass());
|
if(pkField == null){
|
throw new VciBaseException("{0}对象中没有设置主键的属性",new Object[]{obj.getClass()});
|
}
|
String btmType = WebUtil.getBtmTypeByObject(obj.getClass());
|
String pkValue = WebUtil.getValueFromFieldForCbo(pkField, obj);
|
//所以这里也是直接查询的单个'
|
List<BusinessObject> deleteCbos = queryCBO(btmType, getOneQuery(
|
WebUtil.getCboAttrNameFromField(pkField, obj.getClass()), pkValue));
|
if(deleteCbos!=null){
|
allDeleteCbos.addAll(deleteCbos);
|
if(!btmBos.containsKey(btmType)){
|
btmBos.put(btmType, deleteCbos);
|
}else{
|
btmBos.get(btmType).addAll(deleteCbos);
|
}
|
}
|
}
|
|
//不执行验证，是true才检查，默认不检查
|
if(checkRefered) {
|
checkCanDelete(btmBos);
|
}
|
|
BatchCBO batchCbo = new BatchCBO();
|
batchCbo.setDeleteCbos(allDeleteCbos);
|
if(allDeleteCbos.size()>0 && WebUtil.isPersistence()){
|
persistenceBatch(batchCbo);
|
}
|
return batchCbo;
|
}
|
|
/**
|
* 校验是否可以删除
|
* @param btmBos 业务数据
|
* @throws VciBaseException 被引用的时候会抛出异常
|
*/
|
private void checkCanDelete(Map<String,List<BusinessObject>> btmBos) throws VciBaseException{
|
//查找表是否被其他的属性引用
|
if(!btmBos.isEmpty()){
|
Iterator<String> it = btmBos.keySet().iterator();
|
while(it.hasNext()){
|
//每一个业务类型找一次引用字段
|
String btmType = it.next();
|
List<OsUsedAttributeVO> usedAttrVOs = btmService.listBtmUsedInfo(btmType);
|
|
Map<String, List<OsUsedAttributeVO>> allReferAttr = Optional.ofNullable(usedAttrVOs).orElseGet(()->new ArrayList<>()).stream().collect(Collectors.groupingBy(s -> s.getPkBtmType()));
|
List<BusinessObject> thisBtmTypeBo = btmBos.get(btmType);
|
if(thisBtmTypeBo.size()== 0){
|
return;
|
}
|
String oids = "";
|
for(BusinessObject cbo : thisBtmTypeBo){
|
oids += "'" + cbo.oid + "',";
|
}
|
oids = WebUtil.removeComma(oids);
|
if(!allReferAttr.isEmpty()){
|
Iterator<String> atIt = allReferAttr.keySet().iterator();
|
while(atIt.hasNext()){
|
String referBtmType = atIt.next();//拥有参照当前业务类型的属性所在业务类型
|
List<OsUsedAttributeVO> allAttr = allReferAttr.get(referBtmType);//该业务类型中所有的引用当前业务类型的
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
for(OsUsedAttributeVO attr : allAttr){
|
conditionMap.put(attr.getId(),QueryOptionConstant.IN +"(" + oids + ")");//平台所有的引用都是oid
|
}
|
if(queryCount(referBtmType, conditionMap)>0){
|
throw new VciBaseException(msgCodePrefix + "refered", new String[]{referBtmType});
|
}
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* 根据查询条件来删除数据
|
* @param c 删除数据对象所属类
|
* @param conditionMap 查询条件
|
* @return 需要创建的CBO,CLO;需要修改的CBO,CLO;需要删除的CBO,CLO
|
* @throws VciBaseException 删除出错会抛出异常
|
*/
|
@Override
|
public <T> BatchCBO deleteByCondition(Class<T> c,
|
Map<String, String> conditionMap) throws VciBaseException {
|
swapConditionMap(c,conditionMap);
|
String btmType = WebUtil.getBtmTypeByObject(c);
|
return deleteByCondition(btmType,conditionMap);
|
}
|
|
/**
|
* 根据查询条件来删除数据
|
* @param btmType 业务类型名称
|
* @param conditionMap 查询条件
|
* @return 需要创建的CBO,CLO;需要修改的CBO,CLO;需要删除的CBO,CLO
|
* @throws VciBaseException 删除出错会抛出异常
|
*/
|
@Override
|
public <T> BatchCBO deleteByCondition(String btmType,
|
Map<String, String> conditionMap) throws VciBaseException {
|
if(conditionMap == null){
|
conditionMap = new HashMap<String, String>();
|
}
|
conditionMap.put(QUERY_FILTER_SECRET,BooleanEnum.FASLE.getValue());//查询的时候不能查询密级
|
List<BusinessObject> allCbos = queryCBO(btmType, conditionMap);
|
BatchCBO batchCbo = new BatchCBO();
|
if(allCbos.size()>0){
|
Map<String,List<BusinessObject>> btmBos = new HashMap<String, List<BusinessObject>>();
|
btmBos.put(btmType, allCbos);
|
checkCanDelete(btmBos);
|
Set<BusinessObject> allDeleteCbos = new HashSet<BusinessObject>();
|
allDeleteCbos.addAll(allCbos);
|
batchCbo.setDeleteCbos(allDeleteCbos);
|
}
|
if(allCbos.size()>0 && WebUtil.isPersistence()){
|
persistenceBatch(batchCbo);
|
}
|
return batchCbo;
|
}
|
|
/**
|
* 通过sql语句来删除---不到万不得已不用使用这个方法
|
* @param sql 防止SQL注入，值必须使用:xxx方式，如id=:idvalue，并在conditionMap里放置idvalue为key的数据
|
* @param conditionMap 查询条件
|
* @return 删除的数据量
|
* @throws VciBaseException 删除出错会抛出异常
|
*/
|
@Override
|
public BatchCBO deleteBySql(String sql, Map<String, String> conditionMap)
|
throws VciBaseException {
|
//很遗憾，平台不支持使用sql来删除
|
//所有我们需要先查询出来，然后校验是否可以删除
|
sql = sql.replace("delete", "select oid,btmname ");
|
if(sql.toLowerCase().indexOf(" from ") < 0){
|
throw new VciBaseException(msgCodePrefix + "sqlError",new String[]{sql});
|
}
|
BatchCBO batchCbo = new BatchCBO();
|
String selectSql = sql.substring(0,sql.toLowerCase().indexOf(" from "));
|
String fromSql = sql.substring(sql.toLowerCase().indexOf(" from "));
|
if(selectSql.toLowerCase().indexOf("btmname")<0){
|
selectSql += ",btmname ";
|
}
|
sql = selectSql + fromSql;
|
List<BusinessObject> allDelete =queryBySql(sql, conditionMap);
|
if(allDelete.size() == 0){
|
return batchCbo;//没有删除任何数据
|
}
|
//找btmType;
|
String btmType = ObjectTool.getBOAttributeValue(allDelete.get(0),"btmName");
|
Map<String,List<BusinessObject>> btmBos = new HashMap<String, List<BusinessObject>>();
|
btmBos.put(btmType, allDelete);
|
checkCanDelete(btmBos);
|
Set<BusinessObject> allDeleteCbos = new HashSet<BusinessObject>();
|
//我们需要从后台查询整个的内容才可以执行删除，
|
String oids = "";
|
for(BusinessObject cbo : allDelete){
|
oids += "'" + cbo.oid + "',";
|
}
|
conditionMap.clear();
|
conditionMap.put("oid", QueryOptionConstant.IN + "(" + WebUtil.removeComma(oids) + ")");
|
List<BusinessObject> inDbCbos = queryCBO(btmType, conditionMap);
|
|
allDeleteCbos.addAll(inDbCbos);
|
batchCbo.setDeleteCbos(allDeleteCbos);
|
if(allDeleteCbos.size()>0 && WebUtil.isPersistence()){
|
persistenceBatch(batchCbo);
|
}
|
return batchCbo;
|
}
|
|
/**
|
* 检验是否为最新的-
|
* @param obj 数据对象，里面必须包括主键和ts字段
|
* @return 相等时为true
|
* @throws VciBaseException 不符合要求会抛出异常
|
*/
|
@Override
|
public boolean checkTs(Object obj) throws VciBaseException {
|
Field pkField = WebUtil.getPkFieldForObj(obj.getClass());
|
if(pkField == null){
|
throw new VciBaseException("{0}对象中没有设置主键的属性",new Object[]{obj.getClass()});
|
}
|
String pkValue = WebUtil.getValueFromFieldForCbo(pkField, obj);
|
Field tsField = WebUtil.getTsField(obj.getClass());
|
if(tsField == null){
|
throw new VciBaseException("{0}对象中没有TS字段",new Object[]{obj.getClass()});
|
}
|
String ts = WebUtil.getValueFromFieldForCbo(tsField, obj);
|
Map<String,String> conditionMap = getOneQuery("oid", pkValue);
|
List<String> causeList = new ArrayList<>();
|
causeList.add("ts");
|
List<BusinessObject> cbos = queryCBO(WebUtil.getBtmTypeByObject(obj.getClass()), conditionMap,new PageHelper(-1),causeList);
|
if(CollectionUtils.isEmpty(cbos)){
|
return false;
|
}
|
if(ts.contains(".")){
|
ts = ts.substring(0,ts.lastIndexOf("."));
|
}
|
return cbos.get(0).ts == Long.valueOf(ts);
|
}
|
|
/**
|
* 根据业务类型来查询列表数据；
|
* @param btmType 业务类型名称
|
* @param conditionMap 查询条件
|
* @return 列表数据，数据是Map形式的，包含分页信息
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public DataGrid queryGridByBo(String btmType,
|
Map<String, String> conditionMap) throws VciBaseException {
|
return queryGridByBo(btmType,conditionMap,new PageHelper(-1,true));
|
}
|
|
|
/**
|
* 根据业务类型来查询列表数据；可以在pageHelper中设置是否查询总数
|
* @param btmType 业务类型名称
|
* @param conditionMap 查询条件
|
* @param ph 分页和排序组件
|
* @return 列表数据，数据是Map形式的，包含分页信息
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public DataGrid queryGridByBo(String btmType,
|
Map<String, String> conditionMap, PageHelper ph)
|
throws VciBaseException {
|
return queryGridByBo(btmType,conditionMap,ph,null);
|
}
|
|
/**
|
* 根据业务类型来查询列表数据；可以设置要查询的字段，包括参照和枚举字段；可以在pageHelper中设置是否查询总数
|
* @param btmType 业务类型名称
|
* @param conditionMap 查询条件
|
* @param ph 分页和排序组件
|
* @param clauseList 列表数据，数据是Map形式的，
|
* @return 列表数据，数据是Map形式的，包含分页信息
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public DataGrid queryGridByBo(String btmType,
|
Map<String, String> conditionMap, PageHelper ph,
|
List<String> clauseList) throws VciBaseException {
|
if(ph == null){
|
ph = new PageHelper(-1);
|
ph.setQueryTotal(true);
|
}
|
List<BusinessObject> allCbos = queryCBO(btmType, conditionMap, ph, clauseList);
|
DataGrid dg = new DataGrid();
|
if(allCbos.size()>0){
|
List<Map> mapList = cbos2Map(allCbos);
|
dg.setData(mapList);
|
//肯定是当前分页有值，才会有总数
|
if(ph.isQueryTotal()){
|
dg.setTotal(queryCount(btmType, conditionMap));
|
}
|
}
|
dg.setLimit(ph.getLimit());
|
dg.setPage(ph.getPage());
|
return dg;
|
}
|
|
/**
|
* 根据查询方案来查询列表数据；
|
* @param queryScheme 查询方案
|
* @param conditionMap 查询条件
|
* @return 列表数据，数据是Map形式的，包含分页信息
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public DataGrid queryGridByScheme(String queryScheme,
|
Map<String, String> conditionMap) throws VciBaseException {
|
return queryGridByScheme(queryScheme,conditionMap,null);
|
}
|
|
/**
|
* 根据查询方案来查询列表数据；
|
* @param queryScheme 查询方案
|
* @param conditionMap 查询条件
|
* @param replaceMap 替换查询方案的变量值
|
* @return 列表数据，数据是Map形式的，包含分页信息
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public DataGrid queryGridByScheme(String queryScheme,
|
Map<String, String> conditionMap, Map<String, String> replaceMap)
|
throws VciBaseException {
|
return queryGridByScheme(queryScheme,conditionMap,replaceMap,new PageHelper(-1,true),null);
|
}
|
|
|
/**
|
* 根据查询方案来查询列表数据；可以在pageHelper中设置是否查询总数，pageHelper的优先级最大；
|
* @param queryScheme 查询方案
|
* @param conditionMap 查询条件
|
* @param replaceMap 替换查询方案的变量值
|
* @return 列表数据，数据是Map形式的，包含分页信息
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public DataGrid queryGridByScheme(String queryScheme,
|
Map<String, String> conditionMap, Map<String, String> replaceMap,
|
PageHelper ph) throws VciBaseException {
|
return queryGridByScheme(queryScheme,conditionMap,replaceMap,ph,null);
|
}
|
|
/**
|
* 根据查询方案来查询列表数据，可以自定义查询的列，包括参照和枚举
|
* @param queryScheme 查询方案
|
* @param conditionMap 查询条件
|
* @param replaceMap 替换查询方案的变量值
|
* @param ph 分页和排序字段
|
* @param clauseList 查询的列，参照使用xx.yy；枚举使用xx_enumCode;
|
* @return 列表数据，数据是Map形式的，包含分页信息
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public DataGrid queryGridByScheme(String queryScheme,
|
Map<String, String> conditionMap, Map<String, String> replaceMap,
|
PageHelper ph, List<String> clauseList) throws VciBaseException {
|
if(ph == null){
|
ph = new PageHelper(-1,true);
|
}
|
List<BusinessObject> allCbos = queryCBOByScheme(queryScheme, conditionMap,replaceMap, ph, clauseList);
|
DataGrid dg = new DataGrid();
|
if(allCbos.size()>0){
|
List<Map> mapList = cbos2Map(allCbos);
|
dg.setData(mapList);
|
//肯定是当前分页有值，才会有总数
|
if(ph.isQueryTotal()){
|
dg.setTotal(queryCountByScheme(queryScheme, conditionMap, replaceMap));
|
}
|
}
|
dg.setLimit(ph.getLimit());
|
dg.setPage(ph.getPage());
|
return dg;
|
}
|
|
/**
|
* 查询对象的列表数据
|
* @param c 查询对象所属类
|
* @param conditionMap 查询条件
|
* @return 列表数据，数据是对象形式的，包含分页信息
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public DataGrid queryGridClass(Class c, Map<String, String> conditionMap)
|
throws VciBaseException {
|
return queryGridClass(c,conditionMap,new PageHelper(-1,true));
|
}
|
|
/**
|
* 查询对象的列表数据
|
* @param c 查询对象所属类
|
* @param conditionMap 查询条件
|
* @param ph 分页和排序字段，可以设置是否查询总数
|
* @return 列表数据，数据是对象形式的，包含分页信息
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public DataGrid queryGridClass(Class c, Map<String, String> conditionMap,
|
PageHelper ph) throws VciBaseException {
|
if(ph == null){
|
ph = new PageHelper(-1,true);
|
}
|
List allObjs = queryObject(c, conditionMap, ph);
|
DataGrid dg = new DataGrid();
|
if(allObjs.size()>0){
|
dg.setData(allObjs);
|
//肯定是当前分页有值，才会有总数
|
if(ph.isQueryTotal()){
|
dg.setTotal(queryCount(c, conditionMap));
|
}
|
}
|
dg.setLimit(ph.getLimit());
|
dg.setPage(ph.getPage());
|
return dg;
|
}
|
|
/**
|
* 通过查询方案查询对象的列表数据
|
* @param queryScheme 查询方案
|
* @param c 查询对象所属类
|
* @param conditionMap 查询条件
|
* @return 列表数据，数据是对象形式的，包含分页信息
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public DataGrid queryGridClassByScheme(String queryScheme, Class c,
|
Map<String, String> conditionMap,Map<String,String> replaceMap) throws VciBaseException {
|
return queryGridClassByScheme(queryScheme,c,conditionMap,replaceMap,new PageHelper(-1,true));
|
}
|
|
/**
|
* 通过查询方案查询对象的列表数据
|
* @param queryScheme 查询方案
|
* @param c 查询对象所属类
|
* @param conditionMap 查询条件
|
* @param ph 分页和排序字段，可以设置是否查询总数
|
* @return 列表数据，数据是对象形式的，包含分页信息
|
* @throws VciBaseException 查询出错会抛出异常
|
*/
|
@Override
|
public DataGrid queryGridClassByScheme(String queryScheme, Class c,
|
Map<String, String> conditionMap, Map<String,String> replaceMap,PageHelper ph)
|
throws VciBaseException {
|
if(ph == null){
|
ph = new PageHelper(-1,true);
|
}
|
List allObjs = queryObjectByScheme(queryScheme, c, conditionMap, ph, replaceMap);
|
DataGrid dg = new DataGrid();
|
if(allObjs.size()>0){
|
dg.setData(allObjs);
|
//肯定是当前分页有值，才会有总数
|
if(ph.isQueryTotal()){
|
dg.setTotal(queryCountByScheme(queryScheme, conditionMap, replaceMap));
|
}
|
}
|
dg.setLimit(ph.getLimit());
|
dg.setPage(ph.getPage());
|
return dg;
|
}
|
|
/**
|
* BusinessObject 转为HashMap
|
* @param cbos CBOS
|
* @return map
|
* @throws VciBaseException 转换出错会抛出异常
|
*/
|
@Override
|
public List<Map> cbos2Map(List<BusinessObject> cbos)
|
throws VciBaseException {
|
List<Map> mapList = new ArrayList<Map>();
|
for(BusinessObject cbo : cbos){
|
mapList.add(cbo2Map(cbo));
|
}
|
return mapList;
|
}
|
|
/**
|
* BusinessObject 转为HashMap
|
* @param cbo 业务数据对象
|
* @return map
|
* @throws VciBaseException 转换出错会抛出异常
|
*/
|
@Override
|
public Map cbo2Map(BusinessObject cbo) throws VciBaseException {
|
Map<String,String> map = new HashMap<String, String>();
|
WebUtil.copyValueToMapFromCbos(cbo, map);
|
return map;
|
}
|
|
|
/**
|
* map转为BusinessObject
|
* @param mapList map列表
|
* @return 业务数据列表
|
* @throws VciBaseException 转换出错会抛出异常
|
*/
|
@Override
|
public List<BusinessObject> map2Cbos(List<Map> mapList)
|
throws VciBaseException {
|
List<BusinessObject> cboList = new ArrayList<BusinessObject>();
|
for(Map map : mapList){
|
cboList.add(map2Cbo(map));
|
}
|
return cboList;
|
}
|
|
|
/**
|
* map转为BusinessObject
|
* @param map map
|
* @return 业务数据
|
* @throws VciBaseException 转换出错会抛出异常
|
*/
|
@Override
|
public BusinessObject map2Cbo(Map map) throws VciBaseException {
|
BusinessObject cbo = new BusinessObject();
|
WebUtil.copyValueToCboFromMap(cbo, map);
|
return cbo;
|
}
|
|
/**
|
* 批量保存业务类型和链接类型的信息
|
* @param batchCbos 批量数据容器
|
* @throws VciBaseException 保存出错
|
*/
|
@Override
|
public void persistenceBatch(BatchCBO batchCbos) throws VciBaseException {
|
persistenceBatch(batchCbos,false);
|
}
|
|
/**
|
* 批量保存业务类型和链接类型的信息---只有确保数据容器里有参照字段，枚举字段等内容的时候，才调用这个方法，因为这个方法性能低下
|
* @param batchCbos 批量数据容器
|
* @param isCheckReferColumn 是否校验是否含有参照字段
|
* @throws VciBaseException 保存出错
|
*/
|
@Override
|
public void persistenceBatch(BatchCBO batchCbos, boolean isCheckReferColumn)
|
throws VciBaseException {
|
if(batchCbos == null ){
|
return;
|
}
|
if(isCheckReferColumn){
|
deleteReferAttrInCbo(batchCbos.getCreateCbos());
|
deleteReferAttrInCbo(batchCbos.getUpdateCbos());
|
deleteReferAttrInCbo(batchCbos.getDeleteCbos());
|
}
|
try {
|
platformClientUtil.getBOFactoryService().batchCUDBOLO(cboArray2Bo(batchCbos.getCreateCboArray()),
|
cloArray2Lo(batchCbos.getCreateCloArray()),
|
cboArray2Bo(batchCbos.getUpdateCboArray()),
|
cloArray2Lo(batchCbos.getUpdateCloArray()),
|
cboArray2Bo(batchCbos.getDeleteCboArray()), cloArray2Lo(batchCbos.getDeleteCloArray()));
|
} catch (PLException e) {
|
throw WebUtil.getVciBaseException(e);
|
}
|
}
|
|
/**
|
* 转换为cbo
|
* @param cbos 客户端对象
|
* @return 业务对象
|
*/
|
private BusinessObject[] cboArray2Bo(BusinessObject[] cbos){
|
if(cbos == null ||cbos.length == 0){
|
return new BusinessObject[0];
|
}
|
BusinessObject[] bos = new BusinessObject[cbos.length];
|
for(int i = 0; i < cbos.length; i++){
|
bos[i] = cbos[i];
|
}
|
return bos;
|
}
|
|
/**
|
* 转换clob
|
* @param clos 客户端对象
|
* @return 业务对象
|
*/
|
private LinkObject[] cloArray2Lo(LinkObject[] clos){
|
if(clos == null ||clos.length == 0){
|
return new LinkObject[0];
|
}
|
LinkObject[] bos = new LinkObject[clos.length];
|
for(int i = 0; i < clos.length; i++){
|
bos[i] = clos[i];
|
}
|
return bos;
|
}
|
|
/**
|
* 删除枚举和参照的属性
|
* @param cbos 业务数据
|
*/
|
private void deleteReferAttrInCbo(Set<BusinessObject> cbos){
|
if(cbos !=null){
|
for(BusinessObject cbo : cbos){
|
BusinessObject bo = cbo;
|
List<AttributeValue> newAttr = new ArrayList<AttributeValue>();
|
if (bo.newAttrValList != null) {
|
for (int i = 0; i < bo.newAttrValList.length; ++i) {
|
AttributeValue av = bo.newAttrValList[i];
|
if (WebUtil.isNormalAttr(av.attrName)) {
|
if(av.attrVal == null){
|
av.attrVal = "";
|
}
|
newAttr.add(av);
|
}
|
}
|
}
|
bo.newAttrValList = newAttr.toArray(new AttributeValue[0]);
|
cbo = bo;
|
}
|
}
|
}
|
|
/**
|
* 使用主键获取对象
|
* @param oid 主键
|
* @param doClass 数据对象
|
* @return 数据对象
|
* @throws VciBaseException 参数为空，数据对象不存在会抛出异常
|
*/
|
@Override
|
public <T> T selectByOid(String oid, Class<T> doClass)
|
throws VciBaseException {
|
VciBaseUtil.alertNotNull(oid,"主键");
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put("oid", oid.trim());
|
conditionMap.put(QUERY_FILTER_SECRET,BooleanEnum.FASLE.getValue());
|
conditionMap.put(QUERY_FILTER_DATARIGHT,BooleanEnum.FASLE.getValue());
|
List<T> list = queryObject(doClass, conditionMap);
|
if(CollectionUtils.isEmpty(list)){
|
throw new VciBaseException("数据在系统中不存在{0}",new String[]{oid});
|
}
|
return list.get(0);
|
}
|
|
/**
|
* 使用主键获取对象
|
*
|
* @param oid 主键
|
* @param btmName 业务类型的名称
|
* @return cbo
|
* @throws VciBaseException 参数为空，数据不存在会抛出异常
|
*/
|
@Override
|
public BusinessObject selectCBOByOid(String oid, String btmName) throws VciBaseException {
|
VciBaseUtil.alertNotNull(oid,"主键",btmName,"业务类型");
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put("oid", oid.trim());
|
List<BusinessObject> cbos = queryCBO(btmName, conditionMap);
|
if(CollectionUtils.isEmpty(cbos)){
|
throw new VciBaseException("数据在系统中不存在{0}",new String[]{oid});
|
}
|
return cbos.get(0);
|
}
|
|
/**
|
* 使用主键集合获取对象
|
* @param oidCollection 主键集合
|
* @param doClass 数据对象的类
|
* @return 数据对象， 为空的时候列表为空，不是Null
|
* @throws VciBaseException 参数为空，查询出错会抛出异常
|
*/
|
@Override
|
public <T> List<T> selectByOidCollection(Collection<String> oidCollection,
|
Class<T> doClass) throws VciBaseException {
|
VciBaseUtil.alertNotNull(oidCollection,"主键集合");
|
Collection<Collection<String>> oidCollections = WebUtil.switchCollectionForOracleIn(oidCollection);
|
List<T> doList = new ArrayList<T>();
|
|
for(Collection<String> oids: oidCollections){
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put("oid",QueryOptionConstant.IN + "(" + WebUtil.toInSql(oids.toArray(new String[0])) + ")");
|
List<T> list = queryObject(doClass, conditionMap);
|
if(CollectionUtils.isEmpty(list)){
|
throw new VciBaseException("{0}条数据在系统中不存在",new String[]{String.valueOf(oids.size())});
|
}
|
doList.addAll(list);
|
}
|
return doList;
|
}
|
|
/**
|
* 使用主键集合获取对象
|
*
|
* @param oidCollection 主键集合
|
* @param btmName 业务类型的名称
|
* @return 业务数据的集合
|
* @throws VciBaseException 参数为空，查询出错会抛出异常
|
*/
|
@Override
|
public List<BusinessObject> selectCBOByOidCollection(Collection<String> oidCollection, String btmName) throws VciBaseException {
|
VciBaseUtil.alertNotNull(oidCollection,"主键集合",btmName,"业务类型");
|
Collection<Collection<String>> oidCollections = WebUtil.switchCollectionForOracleIn(oidCollection);
|
List<BusinessObject> doList = new ArrayList<BusinessObject>();
|
|
for(Collection<String> oids: oidCollections){
|
Map<String,String> conditionMap = new HashMap<String, String>();
|
conditionMap.put("oid",QueryOptionConstant.IN + "(" + WebUtil.toInSql(oids.toArray(new String[0])) + ")");
|
List<BusinessObject> list = queryCBO(btmName, conditionMap);
|
if(CollectionUtils.isEmpty(list)){
|
throw new VciBaseException("{0}条数据在系统中不存在",new String[]{String.valueOf(oids.size())});
|
}
|
doList.addAll(list);
|
}
|
return doList;
|
}
|
|
/**
|
* 使用新的查询封装器来查询
|
*
|
* @param queryWrapper 查询封装器
|
* @param doClass 对象的所属类
|
* @return 数据
|
* @throws VciBaseException 查询出错的会抛出异常
|
*/
|
@Override
|
public <T> List<T> selectByQueryWrapper(VciQueryWrapperForDO queryWrapper, Class<T> doClass) throws VciBaseException {
|
String sql= queryWrapper.getSelectFieldSql() + " from " + queryWrapper.getTableName() + " " + queryWrapper.getTableNick() + queryWrapper.getLinkTableSql() ;
|
String whereSql = queryWrapper.getWhereSql();
|
if(StringUtils.isNotBlank(whereSql)){
|
sql += " where " + whereSql;
|
}
|
return queryByOnlySqlForObj(sql,doClass);
|
}
|
|
/**
|
* 使用新的查询封装器来查询总数
|
*
|
* @param queryWrapper 查询封装器
|
* @param doClass 对象的所属类
|
* @return 数据
|
* @throws VciBaseException 查询出错的会抛出异常
|
*/
|
@Override
|
public <T> int countByQueryWrapper(VciQueryWrapperForDO queryWrapper, Class<T> doClass) throws VciBaseException {
|
VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(null,doClass);
|
BeanUtil.convert(queryWrapper,queryWrapperForDO);
|
queryWrapperForDO.clearPage();
|
queryWrapperForDO.wrapperSql();
|
String sql= queryWrapperForDO.getSelectFieldSql() + " from " + queryWrapperForDO.getTableName() + " " + queryWrapperForDO.getTableNick() + queryWrapperForDO.getLinkTableSql() ;
|
String whereSql = queryWrapperForDO.getWhereSql();
|
if(StringUtils.isNotBlank(whereSql)){
|
sql += " where " + whereSql;
|
}
|
return queryCountBySql("select count(*) from (" +sql + ")",null);
|
}
|
|
}
|
