private Expression createPunctuationExpression(String value) { return expressionProvider.createExpression("punctuation", punctuations.get(value)); }
private List<Expression> createDefaultExpressionIfNull(String value, String exp) { if (RuntimeUtilities.isNullOrEmpty(exp)) { return Collections.singletonList(expressionProvider.createExpression("unused", value)); } return expressionProvider.parseExpressions(exp); }
@Override public void setValues(Map<String, String> values) { if (values != null && !values.isEmpty()) { if (values.containsKey(expressionsQualifier)) { expressions = expressionProvider.parseExpressions(values.get(expressionsQualifier)); } setConversationOccurrenceQualifier(values); } }
@Override public Expression createExpression(String predicate, Object... values) { StringBuilder sb = new StringBuilder(predicate); if (values != null && values.length > 0) { sb.append("("); Arrays.stream(values).forEach(value -> sb.append(value).append(",")); sb.deleteCharAt(sb.length() - 1); sb.append(")"); } return parseExpression(sb.toString()); }
@Override public void extractAllValues(Expression exp, List<Value> ret) { if (exp instanceof Value) { ret.add((Value) exp); } else { Expression[] values = exp.getSubExpressions(); Arrays.stream(values).forEach(value -> { if (!(value instanceof Value)) { extractAllValues(value, ret); } else { ret.add((Value) value); } }); } } }
@Override public Expression parseExpression(String expression) { expression = expression.trim(); Expression exp; int indexOfOpening = expression.indexOf("("); int indexOfClosing = expression.lastIndexOf(")"); if (indexOfOpening > -1 && indexOfClosing > -1) { String tmp = expression.substring(0, indexOfOpening); exp = new Expression(tmp.trim()); try { String subExpressions = expression.substring(indexOfOpening + 1, indexOfClosing); List<Expression> expressions = parseExpressions(subExpressions); exp.setSubExpressions(expressions); } catch (Exception e) { log.error("Error while parsing Expression: %s, indexOfOpening: %s, indexOfClosing: %s, message: %s", expression, indexOfOpening, indexOfClosing, e.getLocalizedMessage()); } } else { exp = new Expression(expression); } return expressionFactory.getExpression(exp); }
@Override public void setValues(Map<String, String> values) { if (values != null && !values.isEmpty()) { if (values.containsKey(contextKeyQualifier)) { contextKey = values.get(contextKeyQualifier); } if (values.containsKey(contextTypeQualifier)) { contextType = values.get(contextTypeQualifier); if (values.get(contextTypeQualifier).equals(expressionsQualifier)) { expressions = expressionProvider.parseExpressions(values.get(expressionsQualifier)); } else if (values.get(contextTypeQualifier).equals(objectQualifier)) { object = new ObjectValue(values.get(objectKeyPathQualifier), values.get(objectValueQualifier)); } else { string = values.get(stringQualifier); } } } }
@Override public List<IFoundWord> lookupTerm(String value) { if (isEmailAddress(value)) { Expression emailExp = expressionProvider.createExpression("email", value); IWord emailExpression = new Word(value, Collections.singletonList(emailExp), ID); return Collections.singletonList(new FoundWord(emailExpression, false, 1.0)); } return IDictionary.NO_WORDS_FOUND; }
private ExecutionState evaluateInputExpressions(IData<String> data) { List<Expression> inputExpressions = Collections.emptyList(); if (data != null && data.getResult() != null) { inputExpressions = expressionProvider.parseExpressions(data.getResult()); } if (isInputEmpty(inputExpressions) || Collections.indexOfSubList(inputExpressions, expressions) > -1) { return SUCCESS; } else { return FAIL; } }
@Override public List<IFoundWord> lookupTerm(String value) { if (CharacterUtilities.isNumber(value, true)) { if (value.contains(",")) { value = value.replace(',', '.'); } Expression decimalExp = expressionProvider.createExpression("decimal", value); IWord word = new Word(value, Collections.singletonList(decimalExp), ID); return Collections.singletonList(new FoundWord(word, false, 1.0)); } return IDictionary.NO_WORDS_FOUND; }
private List<Expression> extractContextProperties(List<IData<Context>> contextDataList) { List<Expression> ret = new LinkedList<>(); contextDataList.forEach(contextData -> { String contextKey = contextData.getKey(); Context context = contextData.getResult(); String key = contextKey.substring((CONTEXT_IDENTIFIER + ":").length()); if (key.startsWith(PROPERTIES_IDENTIFIER) && context.getType().equals(Context.ContextType.expressions)) { ret.addAll(expressionProvider.parseExpressions(context.getValue().toString())); } }); return ret; }
@Override public List<IFoundWord> lookupTerm(String value) { final Date timeAsDate = LanguageUtilities.isTimeExpression(value); if (timeAsDate != null) { final String timeString = timeAsDate.toString(); Expression timeExp = expressionProvider.createExpression("time", timeAsDate.getTime()); IWord timeExpression = new Word(timeString, Collections.singletonList(timeExp), ID); return Collections.singletonList(new FoundWord(timeExpression, false, 1.0)); } return IDictionary.NO_WORDS_FOUND; }
static List<IDictionary> convertQuickReplies(List<QuickReply> quickReplies, IExpressionProvider expressionProvider) { List<IDictionary> ret = new LinkedList<>(); RegularDictionary dictionary = new RegularDictionary(); quickReplies.forEach(quickReply -> { String quickReplyValue = quickReply.getValue(); List<Expression> expressions = expressionProvider.parseExpressions(quickReply.getExpressions()); if (quickReplyValue.contains(" ")) { dictionary.addPhrase(quickReplyValue, expressions); } else { dictionary.addWord(quickReplyValue, expressions, 0); } }); ret.add(dictionary); return ret; }
@Override public List<IFoundWord> lookupTerm(final String value) { if (CharacterUtilities.isStringInteger(value)) { Expression integerExp = expressionProvider.createExpression("integer", value); IWord word = new Word(value, Collections.singletonList(integerExp), ID); return Collections.singletonList(new FoundWord(word, false, 1.0)); } return IDictionary.NO_WORDS_FOUND; }
private void storeResultInMemory(IConversationMemory.IWritableConversationStep currentStep, List<RawSolution> parsedSolutions) { if (!parsedSolutions.isEmpty()) { Solution solution = extractExpressions(parsedSolutions, includeUnused, includeUnknown).get(0); String expressions = solution.getExpressions(); if (appendExpressions && !expressions.isEmpty()) { IData<String> latestExpressions = currentStep.getLatestData(KEY_EXPRESSIONS_PARSED); if (latestExpressions != null) { expressions = StringUtilities.joinStrings(", ", latestExpressions.getResult(), expressions); } IData<String> expressionsData = new Data<>(KEY_EXPRESSIONS_PARSED, expressions); currentStep.storeData(expressionsData); currentStep.addConversationOutputString(KEY_EXPRESSIONS, expressions); List<String> intents = expressionProvider.parseExpressions(expressions).stream(). map(Expression::getExpressionName). collect(Collectors.toList()); Data<List<String>> intentData = new Data<>(KEY_INTENT, intents); currentStep.storeData(intentData); currentStep.addConversationOutputList(KEY_INTENT, intents); } } }
@Override public List<IFoundWord> lookupTerm(String value) { final String ordinalNumber = LanguageUtilities.isOrdinalNumber(value.toLowerCase()); if (!RuntimeUtilities.isNullOrEmpty(ordinalNumber)) { Expression ordinalNumberExp = expressionProvider.createExpression("ordinal_number", ordinalNumber); IWord word = new Word(ordinalNumber, Collections.singletonList(ordinalNumberExp), ID); return Collections.singletonList(new FoundWord(word, false, 1.0)); } return IDictionary.NO_WORDS_FOUND; }
case expressions: List<Expression> contextExpressions = expressionProvider. parseExpressions(context.getValue().toString()); success = Collections.indexOfSubList(contextExpressions, expressions) != -1; break;
aggregatedExpressions.addAll(expressionProvider.parseExpressions(expressionsData.getResult()));