package foundation.data.rule.exists;
|
|
import java.util.HashSet;
|
import java.util.Set;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
import foundation.data.entity.Entity;
|
import foundation.data.entity.EntitySet;
|
import foundation.persist.NamedSQL;
|
import foundation.server.config.DBaseType;
|
import foundation.util.Util;
|
|
public class ExistsRule {
|
|
private DBaseType dbaseType;
|
private String id;
|
private String name;
|
private String dataName;
|
private String targetTableName;
|
private String selectField;
|
private String filter;
|
private String dateFrom;
|
private String dateTo;
|
private Set<String> filterFields;
|
private NamedSQL templateSQL;
|
|
|
public ExistsRule() {
|
|
}
|
|
public void load(Entity entity) throws Exception {
|
id = entity.getString("id");
|
name = entity.getString("name");
|
dataName = entity.getString("data_name");
|
targetTableName = entity.getString("target_table_name");
|
selectField = entity.getString("select_field");
|
filter = entity.getString("filter");
|
dateFrom = entity.getString("date_from");
|
dateTo = entity.getString("date_to");
|
|
init(filter);
|
}
|
|
private void init(String filter) throws Exception {
|
//1. 解析过滤条件（字段）filter Meta
|
filterFields = new HashSet<String>();
|
String field = "" ;
|
|
if (Util.isEmpty(filter)) {
|
return ;
|
}
|
|
Pattern paramsPattern = Pattern.compile("(?<=\\{)[^\\}]*(?=\\})");
|
Matcher paramsMatcher = paramsPattern.matcher(filter);
|
|
while (paramsMatcher.find()) {
|
field = paramsMatcher.group();
|
|
if (Util.isEmpty(field)) {
|
continue;
|
}
|
|
filterFields.add(field);
|
}
|
|
//2. 创建SQL
|
templateSQL = NamedSQL.getInstance(dbaseType, "getExistsEntity");
|
templateSQL.setParam("selectField", selectField);
|
templateSQL.setParam("tableName", targetTableName);
|
}
|
|
public EntitySet exec(Entity entity, EntitySet errorSet) throws Exception {
|
//1. 根据模板创建运行时SQL
|
NamedSQL namedSQL = templateSQL;
|
|
//2. 将当前数据的过滤条件设置到SQL中
|
String realFilter = concatDateExists(entity);
|
|
if (!filterFields.isEmpty()) {
|
NamedSQL filterSQL = new NamedSQL(dbaseType, realFilter);
|
|
for (String field : filterFields) {
|
filterSQL.setParam(field, entity.getString(field));
|
}
|
|
namedSQL.setParam("filter", filterSQL.toString());
|
}
|
else {
|
namedSQL.setParam("filter", realFilter);
|
}
|
|
namedSQL.setParam("id", entity.getString("id"));
|
|
//3. 查询存在规则下的其他数据
|
EntitySet entitySet = namedSQL.getEntitySet();
|
|
if (entitySet.isEmpty()) {
|
return errorSet;
|
}
|
|
if (errorSet == null || errorSet.isEmpty()) {
|
errorSet = entitySet;
|
}
|
else {
|
for(Entity oneError : entitySet) {
|
errorSet.append(oneError);
|
}
|
}
|
|
return errorSet;
|
}
|
|
private String concatDateExists(Entity entity) {
|
String realFilter = filter;
|
String dateFromValue = "", dateToValue = "";
|
|
if(Util.isEmpty(dateFrom) && Util.isEmpty(dateTo)) {
|
return realFilter;
|
}
|
|
realFilter = realFilter + " and ( ";
|
|
if (!Util.isEmpty(dateFrom)) {
|
dateToValue = entity.getString(dateTo);
|
realFilter = realFilter + dateFrom + " < " + Util.quotedStr(dateToValue);
|
}else {
|
realFilter = realFilter + " 1 <> 1 ";
|
}
|
|
realFilter = realFilter + " or ";
|
|
if (!Util.isEmpty(dateTo)) {
|
dateFromValue = entity.getString(dateFrom);
|
realFilter = realFilter + dateTo + " > " + Util.quotedStr(dateFromValue);
|
}else {
|
realFilter = realFilter + " 1 <> 1 ";
|
}
|
|
realFilter = realFilter + ") ";
|
|
return realFilter;
|
}
|
|
public String getName() {
|
return name;
|
}
|
|
public String getDataName() {
|
return dataName;
|
}
|
|
public String getTargetTableName() {
|
return targetTableName;
|
}
|
|
public String getSelectField() {
|
return selectField;
|
}
|
|
public String getFilter() {
|
return filter;
|
}
|
|
public String getDateFrom() {
|
return dateFrom;
|
}
|
|
public String getDateTo() {
|
return dateTo;
|
}
|
|
public void setDBaseType(DBaseType dbaseType) {
|
this.dbaseType = dbaseType;
|
}
|
|
public String getId() {
|
return id;
|
}
|
|
}
|
