@Override public Object filter(Object object, JinjavaInterpreter interpreter, String... arg) { if (arg.length != 1) { throw new InterpretException("filter cut expects 1 arg >>> " + arg.length); } String cutee = arg[0]; String origin = Objects.toString(object, ""); return StringUtils.replace(origin, cutee, ""); }
public static TemplateError fromException(Exception ex) { int lineNumber = -1; int startPosition = -1; if (ex instanceof InterpretException) { lineNumber = ((InterpretException) ex).getLineNumber(); startPosition = ((InterpretException) ex).getStartPosition(); } return new TemplateError(ErrorType.FATAL, ErrorReason.EXCEPTION, ErrorItem.OTHER, ExceptionUtils.getMessage(ex), null, lineNumber, startPosition, ex, BasicTemplateErrorCategory.UNKNOWN, ImmutableMap.of()); }
@Override public Object filter(Object object, JinjavaInterpreter interpreter, String... arg) { if (arg.length != 1) { throw new InterpretException("filter add expects 1 arg >>> " + arg.length); } try { BigDecimal base = new BigDecimal(Objects.toString(object)); BigDecimal addend = new BigDecimal(Objects.toString(arg[0])); return base.add(addend); } catch (Exception e) { throw new InterpretException("filter add error", e); } }
public static TemplateError fromSyntaxError(InterpretException ex) { return new TemplateError(ErrorType.FATAL, ErrorReason.SYNTAX_ERROR, ErrorItem.OTHER, ExceptionUtils.getMessage(ex), null, ex.getLineNumber(), ex.getStartPosition(), ex); }
protected static ChronoUnit getTemporalUnit(String temporalUnit) { String lowercase = temporalUnit.toLowerCase(); if (!unitMap.containsKey(temporalUnit)) { throw new InterpretException(String.format("%s is not a valid temporal unit", lowercase)); } return unitMap.get(lowercase); } }
@Override public Object filter(Object object, JinjavaInterpreter interpreter, String... arg) { if (object == null) { return false; } if (object instanceof Number) { if (arg.length != 1) { throw new InterpretException("filter divisible expects 1 arg >>> " + arg.length); } long factor = Long.parseLong(arg[0]); long value = ((Number) object).longValue(); if (value % factor == 0) { return true; } } return false; }
@Override public Object filter(Object var, JinjavaInterpreter interpreter, String... args) { try { if (var instanceof String) { return OBJECT_MAPPER.readValue((String) var, HashMap.class); } else { throw new InterpretException(String.format("%s filter requires a string parameter", getName())); } } catch (IOException e) { throw new InterpretException("Could not convert JSON string to object in `fromjson` filter.", e, interpreter.getLineNumber()); } }
@Override public Object filter(Object var, JinjavaInterpreter interpreter, String... args) { String input = (String) var; if (args.length != 1) { throw new InterpretException("frigga filter requires 1 arg (the name of the frigga part to return)"); } String methodName = "get" + args[0].substring(0, 1).toUpperCase() + args[0].substring(1); Method accessor; try { accessor = Names.class.getMethod(methodName); } catch (NoSuchMethodException e) { throw new InterpretException("frigga filter cannot find Frigga method: " + methodName, e); } Names names = Names.parseName(input); try { return accessor.invoke(names); } catch (IllegalAccessException e) { throw new InterpretException("frigga filter provided invalid name (illegal access)"); } catch (InvocationTargetException e) { throw new InterpretException("frigga filter provided failed to execute successfully", e); } }
@Override public Object filter(Object var, JinjavaInterpreter interpreter, String... args) { try { return OBJECT_MAPPER.writeValueAsString(var); } catch (JsonProcessingException e) { throw new InterpretException("Could not write object as string for `tojson` filter.", e, interpreter.getLineNumber()); } }
@Override public boolean evaluate(Object var, JinjavaInterpreter interpreter, Object... args) { if (args.length == 0) { throw new InterpretException(getName() + " test requires 1 argument"); } return var == args[0]; }
@Override public boolean evaluate(Object var, JinjavaInterpreter interpreter, Object... args) { if (var == null) { return false; } if (!Number.class.isAssignableFrom(var.getClass())) { return false; } if (args.length == 0 || args[0] == null || !Number.class.isAssignableFrom(args[0].getClass())) { throw new InterpretException(getName() + " test requires a numeric argument"); } return ((Number) var).intValue() % ((Number) args[0]).intValue() == 0; }
protected long parseDiffAmount(String... args) { if (args.length < 2) { throw new InterpretException(String.format("%s filter requires a number and a string parameter", getName())); } String firstArg = args[0]; Long diff = Longs.tryParse(firstArg); if (diff == null) { throw new InterpretException(String.format("%s filter requires a number parameter as first arg", getName())); } return diff; }
@SuppressWarnings("unchecked") @Override public Object filter(Object var, JinjavaInterpreter interpreter, String... args) { if (args.length != 0) { throw new InterpretException("min filter does not accept any arguments"); } if (!(var instanceof Collection)) { throw new InterpretException("min filter can only be used with a list type object"); } List<Double> casted = (List<Double>) ((Collection) var).stream() .map(v -> { try { return Double.valueOf(String.valueOf(v)); } catch (NumberFormatException e) { throw new InterpretException(format("min filter requires list of numeric values, %s given", v), e); } }) .collect(Collectors.toList()); if (casted.isEmpty()) { throw new InterpretException("min filter must be provided a list of numeric values with at least one value"); } Double min = Collections.min(casted); if (min % min.intValue() == 0) { return min.intValue(); } return min; }
@SuppressWarnings("unchecked") @Override public Object filter(Object var, JinjavaInterpreter interpreter, String... args) { if (args.length != 0) { throw new InterpretException("max filter does not accept any arguments"); } if (!(var instanceof Collection)) { throw new InterpretException("max filter can only be used with a list type object"); } List<Double> casted = (List<Double>) ((Collection) var).stream() .map(v -> { try { return Double.valueOf(String.valueOf(v)); } catch (NumberFormatException e) { throw new InterpretException(format("max filter requires list of numeric values, %s given", v), e); } }) .collect(Collectors.toList()); if (casted.isEmpty()) { throw new InterpretException("max filter must be provided a list of numeric values with at least one value"); } Double max = Collections.max(casted); if (max % max.intValue() == 0) { return max.intValue(); } return max; }
@Override public Object filter(Object var, JinjavaInterpreter interpreter, String... args) { if (!(var instanceof String)) { throw new InterpretException(String.format("%s filter requires a string as input", getName())); } if (args.length < 1) { throw new InterpretException(String.format("%s filter requires a datetime format parameter", getName())); } return Functions.stringToTime((String) var, args[0]); }
@Override public boolean evaluate(Object var, JinjavaInterpreter interpreter, Object... args) { if (!super.evaluate(var, interpreter, args)) { return false; } if (args.length == 0 || args[0] == null) { throw new InterpretException(getName() + " test requires an argument"); } return ((String) var).contains(args[0].toString()); }
protected ChronoUnit parseChronoUnit(String... args) { if (args.length < 2) { throw new InterpretException(String.format("%s filter requires a number and a string parameter", getName())); } String secondArg = args[1].toLowerCase(); return getTemporalUnit(secondArg); }
@Override public boolean evaluate(Object var, JinjavaInterpreter interpreter, Object... args) { if (!super.evaluate(var, interpreter, args)) { return false; } if (args.length == 0 || args[0] == null) { throw new InterpretException(getName() + " test requires an argument"); } return ((String) var).startsWith(args[0].toString()); }
@Override public Object filter(Object object, JinjavaInterpreter interpreter, String... arg) { if (arg.length != 1) { throw new InterpretException("filter multiply expects 1 arg >>> " + arg.length); return num.doubleValue() * Double.parseDouble((String) object); } catch (Exception e) { throw new InterpretException(object + " can't be dealed with multiply filter", e);
return new BigDecimal((String) object).abs(); } catch (Exception e) { throw new InterpretException(object + " can't be handled by abs filter", e);