package com.lf.server.service.all;
|
|
import com.baomidou.mybatisplus.annotation.TableName;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.lf.server.entity.ctrl.IdNameEntity;
|
import com.lf.server.entity.ctrl.TabEntity;
|
import com.lf.server.entity.data.DictEntity;
|
import com.lf.server.entity.data.DomainEntity;
|
import com.lf.server.helper.AesHelper;
|
import com.lf.server.helper.ClassHelper;
|
import com.lf.server.helper.StringHelper;
|
import com.lf.server.mapper.all.BaseQueryMapper;
|
import com.lf.server.mapper.all.BasicMapper;
|
import com.lf.server.mapper.all.GeomBaseMapper;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* 父查询服务类
|
* @author WWW
|
*/
|
@Service
|
public class BaseQueryService implements BaseQueryMapper {
|
@Autowired
|
BaseQueryMapper baseQueryMapper;
|
|
/**
|
* 表名Map
|
*/
|
private static Map<String, String> tabMap = new HashMap<String, String>(3);
|
|
/**
|
* 获取父Mapper
|
*
|
* @param name Mapper名
|
* @return BaseMapper
|
*/
|
public BasicMapper getBasicMapper(String name) {
|
if (StringHelper.isEmpty(name)) {
|
return null;
|
}
|
|
Object obj = ClassHelper.getBean(name.trim() + "Mapper");
|
if (!(obj instanceof BasicMapper)) {
|
return null;
|
}
|
|
return (BasicMapper) obj;
|
}
|
|
/**
|
* 获取空间父Mapper
|
*
|
* @param name Mapper名
|
* @return GeomBaseMapper
|
*/
|
public GeomBaseMapper getGeoBaseMapper(String name) {
|
if (StringHelper.isEmpty(name)) {
|
return null;
|
}
|
|
Object obj = ClassHelper.getBean(name.trim() + "Mapper");
|
if (!(obj instanceof GeomBaseMapper)) {
|
return null;
|
}
|
|
return (GeomBaseMapper) obj;
|
}
|
|
/**
|
* 添加过滤条件
|
*
|
* @param wrapper QueryWrapper
|
* @param filter 原始过滤条件字符串
|
*/
|
public void addFilterWrapper(QueryWrapper wrapper, String filter) {
|
if (StringHelper.isEmpty(filter)) {
|
return;
|
}
|
|
String[] strs = filter.trim().split(" (?i)and ");
|
for (String str : strs) {
|
int start = str.indexOf(" ");
|
if (start == -1) {
|
continue;
|
}
|
int end = str.indexOf(" ", start + 1);
|
if (end == -1) {
|
continue;
|
}
|
|
String field = str.substring(0, start).trim();
|
String express = str.substring(start + 1, end).trim().toLowerCase();
|
String value = str.substring(end + 1).trim();
|
|
addWrapper(wrapper, field, express, getObjectVal(value));
|
}
|
}
|
|
/**
|
* 获取值对象
|
*
|
* @param value 值
|
* @return 对象
|
*/
|
private Object getObjectVal(String value) {
|
if (StringHelper.isInteger(value)) {
|
return Long.parseLong(value);
|
}
|
|
if (StringHelper.isNumeric(value)) {
|
return Double.parseDouble(value);
|
}
|
|
return value.replace("'", "");
|
}
|
|
/**
|
* 添加包装器
|
*
|
* @param wrapper QueryWrapper
|
* @param field 字段
|
* @param express 表达式
|
* @param value 值
|
*/
|
private void addWrapper(QueryWrapper wrapper, String field, String express, Object value) {
|
switch (express) {
|
case "like":
|
wrapper.like(field, value);
|
break;
|
case ">":
|
wrapper.gt(field, value);
|
break;
|
case ">=":
|
wrapper.ge(field, value);
|
break;
|
case "<>":
|
wrapper.ne(field, value);
|
break;
|
case "=":
|
wrapper.eq(field, value);
|
break;
|
case "<":
|
wrapper.lt(field, value);
|
break;
|
case "<=":
|
wrapper.le(field, value);
|
break;
|
default:
|
break;
|
}
|
}
|
|
/**
|
* 添加空间过滤条件
|
*
|
* @param basicMapper 父Mapper
|
* @param wrapper QueryWrapper
|
* @param wkt WKT（著名文本）
|
* @param srid 空间引用标识符
|
* @throws Exception 异常
|
*/
|
public void addGeomWrapper(BasicMapper basicMapper, QueryWrapper wrapper, String wkt, Integer srid) throws Exception {
|
if (basicMapper instanceof GeomBaseMapper && !StringHelper.isEmpty(wkt) && srid != null) {
|
wkt = AesHelper.decrypt(wkt);
|
wrapper.apply(String.format("ST_Intersects(geom, ST_PolygonFromText('%s', %d))", wkt, srid));
|
}
|
}
|
|
/**
|
* 根据Mapper获取表名
|
*
|
* @param basicMapper Mapper
|
* @return 表名
|
*/
|
public String getTabName(BasicMapper basicMapper) {
|
String className = ClassHelper.getClassName(basicMapper);
|
if (tabMap.containsKey(className)) {
|
return tabMap.get(className);
|
}
|
|
return getTabName(className);
|
}
|
|
/**
|
* 根据Mapper获取表名
|
*
|
* @param className Mapper类名
|
* @return 表名
|
*/
|
private String getTabName(String className) {
|
Class clazz = ClassHelper.getEntityClass(className);
|
if (clazz == null) {
|
return null;
|
}
|
|
TableName annotation = (TableName) clazz.getAnnotation(TableName.class);
|
|
String tabName = annotation.value();
|
if (tabName != null && !tabMap.containsKey(className)) {
|
tabMap.put(className, tabName);
|
}
|
|
return tabName;
|
}
|
|
@Override
|
public List<IdNameEntity> selectUserFuzzy(String name) {
|
name = StringHelper.getLikeStr(name);
|
|
return baseQueryMapper.selectUserFuzzy(name);
|
}
|
|
@Override
|
public List<IdNameEntity> selectDepFuzzy(String name) {
|
name = StringHelper.getLikeStr(name);
|
|
return baseQueryMapper.selectDepFuzzy(name);
|
}
|
|
@Override
|
public List<TabEntity> selectTabs() {
|
return baseQueryMapper.selectTabs();
|
}
|
|
@Override
|
public List<DictEntity> selectFields(String ns, String tab) {
|
return baseQueryMapper.selectFields(ns, tab);
|
}
|
|
@Override
|
public List<DomainEntity> selectDomains(String ns, String tab) {
|
return baseQueryMapper.selectDomains(ns, tab);
|
}
|
}
|
