package foundation.dao;
|
|
import java.io.IOException;
|
import java.math.BigDecimal;
|
import java.net.URLDecoder;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Set;
|
|
import javax.servlet.http.HttpServletRequest;
|
|
import foundation.dao.version.VersionRequest;
|
import foundation.data.meta.field.FieldsRuntime;
|
import foundation.data.meta.property.MetaType;
|
import foundation.data.object.DataJoin;
|
import foundation.data.object.DataJoins;
|
import foundation.data.object.DataObject;
|
import foundation.data.object.IParamProvider;
|
import foundation.handler.DataPool;
|
import foundation.handler.DataPoolType;
|
import foundation.json.JArrayReader;
|
import foundation.json.JObjectReader;
|
import foundation.json.JSONReader;
|
import foundation.json.JType;
|
import foundation.route.Operation;
|
import foundation.server.config.DBaseType;
|
import foundation.token.IOnlineUser;
|
import foundation.translator.ITranslator;
|
import foundation.translator.Translator;
|
import foundation.util.MapList;
|
import foundation.util.Util;
|
import foundation.variant.provider.DataEvent;
|
import foundation.variant.provider.IVariantsProvider;
|
import foundation.variant.provider.VariantProviderType;
|
|
public class DataReader extends JObjectReader implements IVariantsProvider, IParamProvider {
|
|
private static Set<String> excludeNames;
|
private static Set<Character> stopChars;
|
private Operation operation;
|
private DataPool dataPool;
|
private Domain domain;
|
private MapList<String, String> params;
|
|
|
static {
|
excludeNames = new HashSet<String>();
|
excludeNames.add("dataname");
|
excludeNames.add("filter");
|
excludeNames.add("orderby");
|
excludeNames.add("page");
|
|
stopChars = new HashSet<Character>();
|
stopChars.add(' ');
|
stopChars.add('\r');
|
stopChars.add('\n');
|
}
|
|
public DataReader(Operation operation, DataPool dataPool) throws Exception {
|
super();
|
|
//1.
|
this.operation = operation;
|
this.dataPool = dataPool;
|
|
DataPoolType type = dataPool.getType();
|
|
if (DataPoolType.Get == type) {
|
loadGetRequestData(dataPool);
|
}
|
else if (DataPoolType.Post == type) {
|
loadPostRequestData(dataPool);
|
}
|
else if (DataPoolType.MultiPart == type) {
|
loadMultiPartParams();
|
}
|
}
|
|
private void loadGetRequestData(DataPool dataPool) throws Exception {
|
params = dataPool.getParams();
|
|
domain = new Domain(this, operation);
|
domain.setEmpty(true);
|
|
loadDomain(domain);
|
}
|
|
private void loadPostRequestData(DataPool dataPool) throws Exception {
|
//1. read JSON body
|
JObjectReader jObjectReader = dataPool.getJObjectReader();
|
this.items = jObjectReader.getItems();
|
|
//2. read parameters
|
params = dataPool.getParams();
|
|
//3. read domain
|
domain = new Domain(this, operation);
|
loadDomain(domain);
|
}
|
|
private void loadMultiPartParams() {
|
params = dataPool.getParams();
|
}
|
|
public synchronized Domain getDomain() throws Exception {
|
return domain;
|
}
|
|
public void loadDomain(Domain domain) throws Exception {
|
//1. empty
|
boolean empty = isEmpty();
|
domain.setEmpty(empty);
|
|
//2. token
|
String token = getString(IDataLetter.Token);
|
domain.setToken(token);
|
|
//3. data name and partial name
|
String dataName = getString(IDataLetter.DataName);
|
|
if (!Util.isEmpty(dataName)) {
|
int pos = dataName.indexOf(".");
|
|
if (pos > 0) {
|
String partialName = dataName.substring(pos + 1);
|
dataName = dataName.substring(0, pos);
|
|
domain.setPartialName(partialName);
|
}
|
|
domain.setDataName(dataName);
|
}
|
|
//4. parent id and id
|
String parentId = getString(IDataLetter.ParentID);
|
domain.setParentId(parentId);
|
|
String id = getString(IDataLetter.ID);
|
domain.setId(id);
|
|
//5.
|
String operator = getString(IDataLetter.Operator);
|
if (Util.isEmpty(operator)) {
|
operator = operation.getOperator();
|
}
|
|
domain.setOperator(operator);
|
|
OperatorCode operatorCode = OperatorCode.parse(operator);
|
domain.setOperatorCode(operatorCode);
|
|
//6. meta code
|
boolean attachMeta = getBoolean(IDataLetter.AttachMeta, false);
|
MetaType metaType = attachMeta ? MetaType.Unknow : MetaType.None;
|
if (MetaType.Unknow == metaType && OperatorCode.GetBatch.equals(operatorCode)) {
|
metaType = MetaType.List;
|
}
|
|
domain.setMetaType(metaType);
|
|
String scene = getString(IDataLetter.Scene);
|
domain.setScene(scene);
|
|
//7. host
|
String hostId = getString(IDataLetter.HostID);
|
domain.setHostId(hostId);
|
|
if (has(IDataLetter.HostItems)) {
|
Set<String> hostItems = new HashSet<String>();
|
JArrayReader array = getReader(IDataLetter.HostItems, JType.Array);
|
|
for (JSONReader value: array) {
|
String itemName = value.getString(null);
|
if (itemName == null) {
|
continue;
|
}
|
|
itemName = itemName.toLowerCase();
|
hostItems.add(itemName);
|
}
|
|
domain.setHostItems(hostItems);
|
}
|
}
|
|
public VersionRequest loadVersionRequest() {
|
if (!has(IDataLetter.Version)) {
|
return null;
|
}
|
|
VersionRequest versionRequest = domain.getVersionRequest();
|
|
if (versionRequest == null) {
|
versionRequest = new VersionRequest();
|
domain.setVersionRequest(versionRequest);
|
}
|
|
JObjectReader versionReader = getReader(IDataLetter.Version, JType.Object);
|
|
String get = versionReader.getString("get");
|
String compare = versionReader.getString("compare");
|
versionRequest.set(get, compare);
|
|
return versionRequest;
|
}
|
|
public void loadFilterFromJSON(DataObject dataObject, Filter filter) throws Exception {
|
FieldsRuntime meta = dataObject.getTableFieldMetas();
|
DBaseType dbaseType = dataObject.getDbaseType();
|
String tableName = dataObject.getTableOrViewName();
|
DataJoins dataJoins = dataObject.getDataJoins();
|
|
//1. 如果直接指定ID，读取ID
|
String id = domain.getId();
|
if (!Util.isEmpty(id)) {
|
filter.add(getFullFieldName(tableName, "id"), id);
|
}
|
|
//2. 如果指定了MasterID, 读取MasterID
|
String masterId = domain.getParentId();
|
if (!Util.isEmpty(masterId)) {
|
filter.add(getFullFieldName(tableName, "parent_id"), masterId);
|
}
|
|
//3. 从过滤条件中读取
|
if (!has(IDataLetter.Filter)) {
|
return;
|
}
|
|
JType dataType = getType(IDataLetter.Filter);
|
|
//3.1 read string
|
if (JType.String == dataType) {
|
String value = getString(IDataLetter.Filter);
|
value = decodeString(value);
|
doReadOneFilerLineFromJSON(dbaseType, tableName, dataJoins, value, filter);
|
}
|
//3.2 read array
|
else if (JType.Array == dataType) {
|
JArrayReader array = getReader(IDataLetter.Filter, JType.Array);
|
|
for (JSONReader line: array) {
|
doReadOneFilerLineFromJSON(dbaseType, tableName, dataJoins, meta, line, filter);
|
}
|
}
|
//3.3 read object
|
else if (JType.Object == dataType) {
|
JSONReader line = getReader(IDataLetter.Filter, JType.Object);
|
doReadOneFilerLineFromJSON(dbaseType, tableName, dataJoins, meta, line, filter);
|
}
|
}
|
|
private void doReadOneFilerLineFromJSON(DBaseType dbaseType, String tableName, DataJoins dataJoins, String value, Filter filter) {
|
int pos = value.indexOf(DataJoin.TableJoinConnector);
|
|
if (pos >= 0) {
|
value = value.replace(DataJoin.TableJoinConnector, ".");
|
}
|
|
filter.add(value);
|
}
|
|
private void doReadOneFilerLineFromJSON(DBaseType dbaseType, String tableName, DataJoins dataJoins, FieldsRuntime meta, JSONReader line, Filter filter) throws Exception {
|
String fieldName = line.getString(IDataLetter.Filter_Field);
|
String value = line.getString(IDataLetter.Filter_Value);
|
String operator = line.getString(IDataLetter.Filter_Operator);
|
|
if (Util.isEmpty(fieldName) || Util.isEmpty(value)) {
|
return;
|
}
|
|
int pos = 0;
|
|
//1. 如果表中包含该字段，直接加入
|
if (meta.contains(fieldName)) {
|
ITranslator translator = meta.getValueTranslator(fieldName);
|
JType valueType = line.getType(IDataLetter.Filter_Value);
|
|
//1.1 如果是 2023-08-20 >= date <= 2023-08-25 这种类型
|
if (JType.Array == valueType) {
|
List<String> list = line.getStringList(IDataLetter.Filter_Value);
|
|
if (list.size() != 2) {
|
return;
|
}
|
|
String left = getFullFieldName(tableName, fieldName) + ">=" + translator.toSqlString(dbaseType, list.get(0));
|
String right = getFullFieldName(tableName, fieldName) + "<=" + translator.toSqlString(dbaseType, list.get(1));
|
filter.add("(" + left + " and " + right + ")");
|
return;
|
}
|
|
//1.2 如果是 code = 00001 这种类型
|
value = URLDecoder.decode(value, "UTF-8");
|
value = translator.toSqlString(dbaseType, value);
|
filter.add(getFullFieldName(tableName, fieldName), operator, value);
|
return;
|
}
|
//2. 检查 Join 表
|
else if ((pos = fieldName.indexOf(DataJoin.TableJoinConnector)) > 0) {
|
tableName = fieldName.substring(0, pos);
|
fieldName = fieldName.substring(pos + 2);
|
|
meta = dataJoins.getJoinFieldsMeta(tableName);
|
if (meta == null) {
|
return;
|
}
|
|
ITranslator translator = meta.getValueTranslator(fieldName);
|
if (translator == null) {
|
return;
|
}
|
|
value = URLDecoder.decode(value, "UTF-8");
|
value = translator.toSqlString(dbaseType, value);
|
|
filter.add(getFullFieldName(tableName, fieldName), operator, value);
|
}
|
//3. 自定义SQL中的字段，有可能存在.的情况
|
else if (fieldName.indexOf(".") > 0) {
|
tableName = fieldName.substring(pos);
|
value = URLDecoder.decode(value, "UTF-8");
|
|
filter.add(fieldName, operator, Translator.toSqlString(dbaseType, value));
|
}
|
}
|
|
public static String getFullFieldName(String tableName, String fieldName) {
|
if (Util.isEmpty(tableName)) {
|
return fieldName;
|
}
|
|
return tableName + "." + fieldName;
|
}
|
|
public void loadPageOrderByFromJSON(DataObject dataObject, Page page, OrderBy orderBy) throws Exception {
|
//1. read page
|
if (has(IDataLetter.Page)) {
|
JObjectReader pageReader = getReader("page", JType.Object);
|
|
//1.1 如果请求分页参数为空，不需要加上分页
|
if (pageReader != null) {
|
Integer pageSize = pageReader.getInteger(IDataLetter.Page_Size, null);
|
page.setPageSize(pageSize);
|
|
Integer pageNo = pageReader.getInteger(IDataLetter.Page_No, null);
|
page.setPageNo(pageNo);
|
}
|
}
|
else {
|
//2. 如果不传分页参数，不需要加上分页
|
page.setEmpty(true);
|
}
|
|
//2. read order by
|
if (has(IDataLetter.OrderBy)) {
|
String value = getString(IDataLetter.OrderBy);
|
|
if (!Util.isEmpty(value)) {
|
orderBy.add(value);
|
}
|
else {
|
OrderBy defaultOrderBy = dataObject.getDefaultOrderBy();
|
orderBy.addAll(defaultOrderBy);
|
}
|
}
|
|
//3 add page order by
|
if ((!page.isEmpty()) && (orderBy.isEmpty())) {
|
FieldsRuntime meta = dataObject.getBatchBrowseFieldMetas();
|
|
if (meta.contains(OrderBy.PageOrderByField)) {
|
String tableName = dataObject.getTableOrViewName();
|
if (!Util.isEmpty(tableName)) {
|
orderBy.add(tableName + "." + OrderBy.PageOrderByField);
|
}
|
}
|
}
|
}
|
|
public void loadOrderByFromJSON(DataObject dataObject, OrderBy orderBy) throws Exception {
|
if (has(IDataLetter.OrderBy)) {
|
String value = getString(IDataLetter.OrderBy);
|
|
if (!Util.isEmpty(value)) {
|
orderBy.add(value);
|
}
|
else {
|
OrderBy defaultOrderBy = dataObject.getDefaultOrderBy();
|
orderBy.addAll(defaultOrderBy);
|
}
|
}
|
}
|
|
public Domain loadFilterPageOrderByFromJSON(DataObject dataObject, Filter filter, Page page, OrderBy orderBy) throws Exception {
|
//1. load filter
|
loadFilterFromJSON(dataObject, filter);
|
|
//2. load page and order by
|
loadPageOrderByFromJSON(dataObject, page, orderBy);
|
|
//3. return
|
return domain;
|
}
|
|
private String decodeString(String value) {
|
try {
|
value = URLDecoder.decode(value, "UTF-8");
|
return value;
|
}
|
catch (Exception e) {
|
return value;
|
}
|
}
|
|
public DataPackage getDataPackage() throws Exception {
|
return domain.getDataPackage();
|
}
|
|
public VersionRequest getVersionRequest() {
|
return domain.getVersionRequest();
|
}
|
|
public Operation getOperation() {
|
return operation;
|
}
|
|
public String getOperator() {
|
if (operation == null) {
|
return null;
|
}
|
|
return operation.getOperator();
|
}
|
|
public void loadOneParameter(String name, String value) {
|
params.add(name, value);
|
}
|
|
@Override
|
public boolean has(String name) {
|
boolean result = super.has(name);
|
|
if (result) {
|
return result;
|
}
|
|
if (params == null) {
|
return result;
|
}
|
|
result = params.contains(name);
|
return result;
|
}
|
|
@Override
|
public JType getType(String name) {
|
JType result = super.getType(name);
|
|
if (JType.Empty != result) {
|
return result;
|
}
|
|
result = params.contains(name) ? JType.String : JType.Empty;
|
return result;
|
}
|
|
@Override
|
public String getString(String name) {
|
String result = super.getString(name);
|
|
if ((result == null) && (params != null)) {
|
result = params.get(name);
|
}
|
|
return result;
|
}
|
public BigDecimal getBigDecimal(String name, BigDecimal defaultValue) {
|
String result = super.getString(name);
|
|
if ((Util.isEmpty(result)) && (params != null)) {
|
return defaultValue;
|
}
|
|
return new BigDecimal(result);
|
}
|
|
public String getRequestBody() throws IOException {
|
if (dataPool == null) {
|
return null;
|
}
|
|
return dataPool.getBody();
|
}
|
|
@Override
|
public String getProviderName() {
|
return this.getClass().getSimpleName();
|
}
|
|
@Override
|
public VariantProviderType getProviderType() {
|
return VariantProviderType.Transiant;
|
}
|
|
@Override
|
public boolean containsVariant(String name) {
|
if (name == null) {
|
return false;
|
}
|
|
if (excludeNames.contains(name.toLowerCase())) {
|
return false;
|
}
|
|
return has(name);
|
}
|
|
@Override
|
public Object getVariantValue(DataEvent dataEvent, String name) {
|
return getString(name);
|
}
|
|
@Override
|
public Set<String> getVariantNames() {
|
Set<String> result = new HashSet<String>();
|
|
Set<String> keys = items.getKeySet();
|
|
for (String name: keys) {
|
if (excludeNames.contains(name.toLowerCase())) {
|
continue;
|
}
|
|
result.add(name);
|
}
|
|
return result;
|
}
|
|
public DataPool getDataPool() {
|
return dataPool;
|
}
|
|
public void setDataPool(DataPool dataPool) {
|
this.dataPool = dataPool;
|
}
|
|
public String getBody() throws IOException {
|
return dataPool.getBody();
|
}
|
|
public HttpServletRequest getRequest() {
|
return dataPool.getRequest();
|
}
|
|
public IOnlineUser getUser() {
|
return dataPool.getUser();
|
}
|
|
}
|
