private static FormulaNode parseFilter(String filter) { if(Strings.isNullOrEmpty(filter)) { return new ConstantNode(true); } try { return FormulaParser.parse(filter); } catch (FormulaException e) { // Failed to parse filter, falling back to denied access return new ConstantNode(false); } }
private static FieldValue parseEnum(FormulaNode argument) { if(argument instanceof SymbolNode) { return new EnumValue(ResourceId.valueOf(((SymbolNode) argument).getName())); } else if(argument instanceof ConstantNode) { if(((ConstantNode) argument).getType() instanceof EnumType) { return ((ConstantNode) argument).getValue(); } else { return new EnumValue(ResourceId.valueOf(((ConstantNode) argument).asExpression())); } } throw new IllegalArgumentException("Expected symbol: " + argument); } }
private String resolveSymbol(ConstantNode constantNode) throws XSymbolException { String resolved; if (constantNode.getType() instanceof EnumType) { EnumValue enumValue = (EnumValue) constantNode.getValue(); resolved = symbolHandler.resolveSymbol(enumValue.getValueId().asString()); } else { resolved = symbolHandler.resolveSymbol(constantNode.getValue().toString()); } return resolved; } }
@Override public Slot<ColumnView> visitConstant(ConstantNode node) { return batch.addConstantColumn(filterLevel, rootFormClass, node.getValue()); }
private static boolean filterContainsPartner(String filter, ResourceId partnerFormId, ResourceId partnerId) { FormulaNode filterFormula = FormulaParser.parse(filter); SymbolNode expectedPartnerForm = new SymbolNode(partnerFormId); ConstantNode expectedPartnerRecord = new ConstantNode(partnerId.asString()); if (!(filterFormula instanceof FunctionCallNode)) { return false; } if (!(((FunctionCallNode) filterFormula).getFunction() instanceof EqualFunction)) { return false; } if (((FunctionCallNode) filterFormula).getArgumentCount() != 2) { return false; } FunctionCallNode equalFunctionCall = (FunctionCallNode) filterFormula; if (!(equalFunctionCall.getArgument(0 ) instanceof SymbolNode)) { return false; } if (!(equalFunctionCall.getArgument(1) instanceof ConstantNode)) { return false; } SymbolNode partnerFormNode = (SymbolNode) equalFunctionCall.getArgument(0); ConstantNode partnerFieldNode = (ConstantNode) equalFunctionCall.getArgument(1); if (!partnerFormNode.equals(expectedPartnerForm)) { return false; } if (!partnerFieldNode.equals(expectedPartnerRecord)) { return false; } return true; }
private void appendTo(FormulaNode formulaNode, StringBuilder xpath) { if (formulaNode instanceof ConstantNode) { ConstantNode constantNode = (ConstantNode) formulaNode; FieldValue value = constantNode.getValue(); xpath.append(xpathExpr); } else { xpath.append(constantNode.asExpression());
private List<ResourceId> getFieldIds(FormulaNode formulaNode) { List<ResourceId> fieldIds = new ArrayList<>(); if (formulaNode instanceof FunctionCallNode) { FunctionCallNode functionCall = (FunctionCallNode) formulaNode; for(FormulaNode arg : functionCall.getArguments()) { fieldIds.addAll(getFieldIds(arg)); } } else if (formulaNode instanceof SymbolNode) { SymbolNode symbolNode = (SymbolNode) formulaNode; fieldIds.add(ResourceId.valueOf(symbolNode.getName())); } else if (formulaNode instanceof ConstantNode) { ConstantNode constantNode = (ConstantNode) formulaNode; if (constantNode.getType() instanceof EnumType) { fieldIds.add(ResourceId.valueOf(constantNode.toString())); } } else if (formulaNode instanceof CompoundExpr) { CompoundExpr compoundExpr = (CompoundExpr) formulaNode; fieldIds.addAll(getFieldIds(compoundExpr.getValue())); fieldIds.addAll(getFieldIds(compoundExpr.getField())); } else if (formulaNode instanceof GroupNode) { GroupNode groupNode = (GroupNode) formulaNode; fieldIds.addAll(getFieldIds(groupNode.getExpr())); } return fieldIds; }
private FieldType validateExpr(FormulaNode formulaNode) { if(formulaNode instanceof ConstantNode) { return ((ConstantNode) formulaNode).getType(); } else if(formulaNode instanceof GroupNode) { return validateExpr(((GroupNode) formulaNode).getExpr()); } else if(formulaNode instanceof SymbolNode) { return validateReference(formulaNode); } else if(formulaNode instanceof CompoundExpr) { return validateReference(formulaNode); } else if(formulaNode instanceof FunctionCallNode) { return validateFunctionCall((FunctionCallNode) formulaNode); } else { throw new UnsupportedOperationException("type: " + formulaNode.getClass().getSimpleName()); } }
@Override public String toString() { return asExpression(); }
@Override public ColumnPlanNode visitConstant(ConstantNode node) { return new ConstantColumn(node.getValue(), new CountRecordsOp(formTree.getRootFormId())); }
private static FormulaNode dateValue(FilterConfig filter) { // GXT serializes the date value as unix time value in milliseconds long time = Long.parseLong(filter.getValue()); Date date = new Date(time); LocalDate localDate = new LocalDate(date); return new FunctionCallNode(DateFunction.INSTANCE, new ConstantNode(localDate.getYear()), new ConstantNode(localDate.getMonthOfYear()), new ConstantNode(localDate.getDayOfMonth())); }
private static FieldValue parseFieldValue(FormulaNode argument) { if(argument instanceof SymbolNode) { ResourceId id = ResourceId.valueOf(((SymbolNode) argument).getName()); if(id.getDomain() == CuidAdapter.ATTRIBUTE_DOMAIN) { return new EnumValue(id); } else { return TextValue.valueOf(id.asString()); } } else if(argument instanceof ConstantNode) { return ((ConstantNode) argument).getValue(); } throw new UnsupportedOperationException("constant value: " + argument); }
public static FormulaNode anyTrue(List<FormulaNode> nodes) { if(nodes.isEmpty()) { return new ConstantNode(false); } else { return binaryTree(OrFunction.INSTANCE, nodes); } }
/** * If this node is a literal value, for example "abc" or 42.0 or * DATE(2017, 1, 1), then return its value. Otherwise return {@code null}. */ private FieldValue parseLiteral(FormulaNode node) { if(node instanceof ConstantNode) { return ((ConstantNode) node).getValue(); } else if(node instanceof FunctionCallNode) { FunctionCallNode callNode = (FunctionCallNode) node; if(callNode.getFunction() == DateFunction.INSTANCE) { FieldValue year = parseLiteral(callNode.getArgument(0)); FieldValue month = parseLiteral(callNode.getArgument(1)); FieldValue day = parseLiteral(callNode.getArgument(2)); if(year != null && month != null || day != null) { return DateFunction.apply(year, month, day); } } } return null; }
private static ConstantNode numericValue(FilterConfig filter) { return new ConstantNode(Double.parseDouble(filter.getValue())); }
public static FormulaNode idConstant(ResourceId id) { return new ConstantNode(id.asString()); }
public static ConstantNode valueOf(FieldValue value) { if(value instanceof TextValue) { return new ConstantNode(((TextValue) value).asString()); } else if(value instanceof BooleanFieldValue) { return new ConstantNode(value == BooleanFieldValue.TRUE); } else if(value instanceof Quantity) { return new ConstantNode(value, new QuantityType()); } else if (value instanceof EnumValue) { return new ConstantNode(value, new EnumType()); } else { throw new IllegalArgumentException(value.getTypeClass().getId()); } }
private FormulaNode binaryFunction(FormulaFunction function) { FormulaNode left = new SymbolNode(fieldId); FormulaNode right; if(value instanceof EnumValue) { right = new ConstantNode(((EnumValue) value)); } else if(value instanceof Quantity) { right = new ConstantNode(((Quantity) value)); } else if(value instanceof TextValue) { right = new ConstantNode(((TextValue) value)); } else if(value instanceof ReferenceValue) { right = new SymbolNode(((ReferenceValue) value).getOnlyReference().getRecordId()); } else { throw new IllegalStateException("value: " + value); } return new FunctionCallNode(function, left, right); }
public static FormulaNode toFormula(FormulaNode field, List<FilterConfig> filters) { List<FormulaNode> filterExprs = new ArrayList<>(); for (FilterConfig filter : filters) { if(!isEmpty(filter)) { filterExprs.add(ColumnFilterParser.toFormula(field, filter)); } } if(filterExprs.isEmpty()) { return new ConstantNode(true); } else { return Formulas.allTrue(filterExprs); } }
public static FormulaNode parse(String expression) { if(Strings.isNullOrEmpty(expression)) { return new ConstantNode((String)null); } FormulaLexer lexer = new FormulaLexer(expression); FormulaParser parser = new FormulaParser(lexer); return parser.parse(); } }