package com.smtaiserver.smtaiserver.javaai.jsonflow.node;
|
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import org.apache.ibatis.ognl.Ognl;
|
import com.smtaiserver.smtaiserver.javaai.SMTJavaAIError;
|
import com.smtaiserver.smtaiserver.javaai.jsonflow.core.SMTJsonFlowExecArg;
|
import com.smtaiserver.smtaiserver.javaai.jsonflow.core.SMTJsonFlowManager;
|
import com.smtaiserver.smtaiserver.javaai.jsonflow.core.SMTJsonFlowNode;
|
import com.smtservlet.util.Json;
|
import com.smtservlet.util.SMTStatic;
|
|
|
|
public class SMTJsonFlowNodeCondJson extends SMTJsonFlowNode
|
{
|
protected enum SMTJsonFlowNodeCondType
|
{
|
AND,
|
OR
|
}
|
|
protected enum SMTJsonFlowNodeCondOP
|
{
|
include,
|
notInclude,
|
empty,
|
notEmpty,
|
startWith,
|
notStartWith,
|
endWith,
|
notEndWith,
|
eq,
|
neq,
|
gt,
|
lt,
|
gte,
|
lte
|
}
|
|
protected static class SMTJsonFlowNodeCondExpr
|
{
|
public SMTJsonFlowNodeCondOP _op;
|
public Object _leftExpr;
|
public Object _righExpr;
|
|
|
public SMTJsonFlowNodeCondExpr(Json jsonCondExpr) throws Exception
|
{
|
_op = SMTJsonFlowNodeCondOP.valueOf(jsonCondExpr.getJson("comparison_operation").asString());
|
_leftExpr = Ognl.parseExpression(jsonCondExpr.safeGetStr("left_value", "null"));
|
_righExpr = Ognl.parseExpression(jsonCondExpr.safeGetStr("right_value", "null"));
|
}
|
|
public SMTJavaAIError executeFlowNode(SMTJsonFlowExecArg execArg, boolean[] r_eq) throws Exception
|
{
|
OgnlRecMap ognlEnv = new OgnlRecMap(execArg);
|
Object leftValue = Ognl.getValue(_leftExpr, ognlEnv);
|
Object rightValue = Ognl.getValue(_righExpr, ognlEnv);
|
|
// 检查非大小判断
|
switch(_op)
|
{
|
case include:
|
return checkInclude(leftValue, rightValue, true, r_eq);
|
|
case notInclude:
|
return checkInclude(leftValue, rightValue, false, r_eq);
|
|
case empty:
|
return checkEmpty(leftValue, true, r_eq);
|
|
case notEmpty:
|
return checkEmpty(leftValue, false, r_eq);
|
|
case startWith:
|
return checkStartWith(leftValue, rightValue, true, r_eq);
|
|
case notStartWith:
|
return checkStartWith(leftValue, rightValue, false, r_eq);
|
|
case endWith:
|
return checkEndWith(leftValue, rightValue, true, r_eq);
|
|
case notEndWith:
|
return checkEndWith(leftValue, rightValue, false, r_eq);
|
default:
|
break;
|
}
|
|
// 检查大小判断
|
int[] result = new int[1];
|
SMTJavaAIError error = compareValue(leftValue, rightValue, result);
|
if(error != null)
|
return error;
|
|
if(result[0] == -2)
|
{
|
r_eq[0] = false;
|
return null;
|
}
|
|
switch(_op)
|
{
|
case eq:
|
r_eq[0] = result[0] == 0;
|
return null;
|
|
case neq:
|
r_eq[0] = result[0] != 0;
|
return null;
|
|
case gt:
|
r_eq[0] = result[0] > 0;
|
return null;
|
|
case lt:
|
r_eq[0] = result[0] < 0;
|
return null;
|
|
case gte:
|
r_eq[0] = result[0] >= 0;
|
return null;
|
|
case lte:
|
r_eq[0] = result[0] <= 0;
|
return null;
|
|
default:
|
break;
|
}
|
|
return null;
|
}
|
|
private SMTJavaAIError compareValue(Object leftValue, Object rightValue, int[] r_result)
|
{
|
|
if(leftValue == null || rightValue == null)
|
{
|
r_result[0] = (leftValue == null && rightValue == null) ? 0 : -2;
|
;
|
return null;
|
}
|
|
if(leftValue instanceof Integer || leftValue instanceof Double || leftValue instanceof Float)
|
{
|
try
|
{
|
double fLeft = SMTStatic.toDouble(leftValue);
|
double fRight = SMTStatic.toDouble(rightValue);
|
|
int result = 0;
|
if(fLeft < fRight)
|
result = -1;
|
else if(fLeft > fRight)
|
result = 1;
|
|
r_result[0] = result;
|
|
return null;
|
}
|
catch(Exception ex)
|
{
|
r_result[0] = -2;
|
return null;
|
}
|
}
|
|
String sLeft = SMTStatic.toString(leftValue);
|
String sRight = SMTStatic.toString(rightValue);
|
|
r_result[0] = sLeft.compareTo(sRight);
|
|
return null;
|
}
|
|
private SMTJavaAIError checkEmpty(Object leftValue, boolean isEmpty, boolean[] r_eq)
|
{
|
boolean result = false;
|
if(leftValue == null)
|
result = true;
|
else if(SMTStatic.isNullOrEmpty(SMTStatic.toString(leftValue)))
|
result = true;
|
|
if(!isEmpty)
|
result = !result;
|
|
r_eq[0] = result;
|
|
return null;
|
}
|
|
private SMTJavaAIError checkInclude(Object leftValue, Object rightValue, boolean isInclude, boolean[] r_eq)
|
{
|
if(leftValue == null || rightValue == null)
|
{
|
r_eq[0] = false;
|
return null;
|
}
|
|
String sLeft = SMTStatic.toString(leftValue);
|
String sRight = SMTStatic.toString(rightValue);
|
|
boolean result = sLeft.indexOf(sRight) >= 0;
|
if(!isInclude)
|
result = !result;
|
r_eq[0] = result;
|
|
return null;
|
}
|
|
private SMTJavaAIError checkStartWith(Object leftValue, Object rightValue, boolean isInclude, boolean[] r_eq)
|
{
|
if(leftValue == null || rightValue == null)
|
{
|
r_eq[0] = false;
|
return null;
|
}
|
|
String sLeft = SMTStatic.toString(leftValue);
|
String sRight = SMTStatic.toString(rightValue);
|
|
boolean result = sLeft.startsWith(sRight);
|
if(!isInclude)
|
result = !result;
|
r_eq[0] = result;
|
|
return null;
|
}
|
|
private SMTJavaAIError checkEndWith(Object leftValue, Object rightValue, boolean isInclude, boolean[] r_eq)
|
{
|
if(leftValue == null || rightValue == null)
|
{
|
r_eq[0] = false;
|
return null;
|
}
|
|
String sLeft = SMTStatic.toString(leftValue);
|
String sRight = SMTStatic.toString(rightValue);
|
|
boolean result = sLeft.startsWith(sRight);
|
if(!isInclude)
|
result = !result;
|
r_eq[0] = result;
|
|
return null;
|
}
|
|
}
|
|
protected static class SMTJsonFlowNodeCondItem
|
{
|
public SMTJsonFlowNodeCondType _condJoin;
|
public String _sourceHandle;
|
public List<SMTJsonFlowNode> _listDownNodes = new ArrayList<>();
|
public List<SMTJsonFlowNodeCondExpr> _listCondExpr = new ArrayList<>();
|
|
public SMTJsonFlowNodeCondItem(Json jsonCondItem) throws Exception
|
{
|
_sourceHandle = jsonCondItem.getJson("id").asString();
|
_condJoin = "and".equalsIgnoreCase(jsonCondItem.getJson("operator").asString()) ?
|
SMTJsonFlowNodeCondType.AND : SMTJsonFlowNodeCondType.OR;
|
|
for(Json jsonCondExpr : jsonCondItem.getJson("conditions").asJsonList())
|
{
|
SMTJsonFlowNodeCondExpr condExpr = new SMTJsonFlowNodeCondExpr(jsonCondExpr);
|
_listCondExpr.add(condExpr);
|
}
|
}
|
|
public void initEdge(SMTJsonFlowNode tagNode, String sourceHandle)
|
{
|
if(!_sourceHandle.equals(sourceHandle))
|
return;
|
_listDownNodes.add(tagNode);
|
}
|
|
public SMTJavaAIError executeFlowNode(SMTJsonFlowExecArg execArg, boolean[] r_eq) throws Exception
|
{
|
r_eq[0] = false;
|
if(_condJoin == SMTJsonFlowNodeCondType.OR)
|
{
|
for(SMTJsonFlowNodeCondExpr condExpr : _listCondExpr)
|
{
|
SMTJavaAIError error = condExpr.executeFlowNode(execArg, r_eq);
|
if(error != null)
|
return error;
|
if(r_eq[0])
|
return null;
|
}
|
return null;
|
}
|
else if(_condJoin == SMTJsonFlowNodeCondType.AND)
|
{
|
for(SMTJsonFlowNodeCondExpr condExpr : _listCondExpr)
|
{
|
SMTJavaAIError error = condExpr.executeFlowNode(execArg, r_eq);
|
if(error != null)
|
return error;
|
if(!r_eq[0])
|
return null;
|
}
|
}
|
|
return null;
|
}
|
}
|
|
private static class OgnlRecMap implements Map<String, Object>
|
{
|
private SMTJsonFlowExecArg _execArg;
|
|
public OgnlRecMap(SMTJsonFlowExecArg execArg)
|
{
|
_execArg = execArg;
|
}
|
|
@Override
|
public int size() {
|
return 0;
|
}
|
|
@Override
|
public boolean isEmpty() {
|
return false;
|
}
|
|
@Override
|
public boolean containsKey(Object key) {
|
return false;
|
}
|
|
@Override
|
public boolean containsValue(Object value) {
|
return false;
|
}
|
|
@Override
|
public Object get(Object key) {
|
try
|
{
|
String value = _execArg._jsonArgs.safeGetStr((String)key, null);
|
return value;
|
}
|
catch (Exception e)
|
{
|
throw new RuntimeException("get record value error : " + key, e);
|
}
|
|
}
|
|
@Override
|
public Object put(String key, Object value) {
|
return null;
|
}
|
|
@Override
|
public Object remove(Object key) {
|
return null;
|
}
|
|
@Override
|
public void putAll(Map<? extends String, ? extends Object> m) {
|
}
|
|
@Override
|
public void clear() {
|
}
|
|
@Override
|
public Set<String> keySet() {
|
return null;
|
}
|
|
@Override
|
public Collection<Object> values() {
|
return null;
|
}
|
|
@Override
|
public Set<Entry<String, Object>> entrySet() {
|
return null;
|
}
|
}
|
|
///////////////////////////////////////////////////////////////////////////////
|
protected String _sourceHandleElse;
|
protected List<SMTJsonFlowNode> _listDownNodesElse = new ArrayList<>();
|
protected List<SMTJsonFlowNodeCondItem> _listCondItem = new ArrayList<>();
|
|
@Override
|
public void initInstane(SMTJsonFlowManager manager, Json jsonNode) throws Exception
|
{
|
super.initInstane(manager, jsonNode);
|
|
Json jsonConds = jsonNode.getJsonPath("data|group_params|0|params|0|value", false);
|
|
for(Json jsonCond : jsonConds.asJsonList())
|
{
|
// 如果存在操作符则代表需要做条件判断
|
if(jsonCond.has("operator"))
|
{
|
SMTJsonFlowNodeCondItem condItem = new SMTJsonFlowNodeCondItem(jsonCond);
|
_listCondItem.add(condItem);
|
}
|
// 如果不存在操作符则代表else结果
|
else
|
{
|
_sourceHandleElse = jsonCond.getJson("id").asString();
|
}
|
}
|
}
|
|
@Override
|
public void initEdge(SMTJsonFlowNode tagNode, Json jsonEdge)
|
{
|
super.initEdge(tagNode, jsonEdge);
|
String sourceHandle = jsonEdge.safeGetStr("sourceHandle", "");
|
|
// 扫描并加入所有条件节点
|
for(SMTJsonFlowNodeCondItem condItem : _listCondItem)
|
{
|
condItem.initEdge(tagNode, sourceHandle);
|
}
|
|
// 如果else节点存在匹配关系，则加入else节点
|
if(_sourceHandleElse.equals(sourceHandle))
|
_listDownNodesElse.add(tagNode);
|
}
|
|
@Override
|
public void afterInstance() throws Exception
|
{
|
super.afterInstance();
|
|
if(_listCondItem.size() == 0)
|
throw new Exception("condtion is empty : " + this.getId());
|
|
for(SMTJsonFlowNodeCondItem condItem : _listCondItem)
|
{
|
if(condItem._listDownNodes.size() == 0)
|
throw new Exception("condtion node not any source handle : " + this.getId());
|
}
|
|
if(this._listDownNodesElse.size() == 0)
|
throw new Exception("condtion node not else source handle : " + this.getId());
|
}
|
|
@Override
|
public SMTJavaAIError executeFlowNode(SMTJsonFlowExecArg execArg) throws Exception
|
{
|
List<SMTJsonFlowNode> listDownNodes = null;
|
|
// 判断条件是否成立
|
boolean[] condEQ = new boolean[1];
|
for(SMTJsonFlowNodeCondItem condItem : _listCondItem)
|
{
|
SMTJavaAIError error = condItem.executeFlowNode(execArg, condEQ);
|
if(error != null)
|
return error;
|
|
if(condEQ[0])
|
{
|
listDownNodes = condItem._listDownNodes;
|
break;
|
}
|
}
|
|
// 如果前面的条件都不符合，则自动跳转到else节点
|
if(listDownNodes == null)
|
listDownNodes = _listDownNodesElse;
|
|
if(listDownNodes != null)
|
{
|
for(SMTJsonFlowNode flowNode : listDownNodes)
|
{
|
execArg._stackNodeExec.addLast(flowNode.createFlowNodeExec());
|
}
|
}
|
return null;
|
}
|
|
|
}
|
