private List<List<String>> getAllBehaviorRules(List<List<IData<List<String>>>> allData) { List<List<String>> allBehaviorRules = new LinkedList<>(); for (List<IData<List<String>>> dataList : allData) { for (IData<List<String>> data : dataList) { allBehaviorRules.add(data.getResult()); } } return allBehaviorRules; }
private boolean executeCallback(IData<List<String>> actionData) { if (callOnActions.isEmpty()) { return true; } if (actionData != null) { List<String> actions = actionData.getResult(); return !actions.isEmpty() && actions.stream().anyMatch(action -> callOnActions.contains(action)); } return false; }
private ExecutionState evaluateActions(IData<List<String>> data) { List<String> actions = Collections.emptyList(); if (data != null && data.getResult() != null) { actions = data.getResult(); } if (isActionEmpty(actions) || Collections.indexOfSubList(actions, this.actions) > -1) { return SUCCESS; } else { return FAIL; } }
private List<QuickReply> extractQuickReplies(List<IData<List<Map<String, String>>>> quickReplyDataList) { List<QuickReply> ret = new LinkedList<>(); quickReplyDataList.stream(). filter(Objects::nonNull). filter(IData::isPublic). forEach((quickReplyData) -> { List<Map<String, String>> resultList = quickReplyData.getResult(); ret.addAll(resultList.stream(). map((resultMap) -> new QuickReply(resultMap.get("value"), resultMap.get("expressions"), Boolean.parseBoolean(resultMap.get("isDefault")))). collect(Collectors.toList())); }); return ret; }
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; } }
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; }
private void addActionsToConversationMemory(IConversationMemory memory, List<BehaviorRule> successRules) { List<String> allCurrentActions = new LinkedList<>(); successRules.forEach(successRule -> successRule.getActions().stream(). filter(action -> !allCurrentActions.contains(action)).forEach(allCurrentActions::add)); var currentStep = memory.getCurrentStep(); List<String> actions = new LinkedList<>(); if (appendActions || allCurrentActions.isEmpty()) { IData<List<String>> latestActions = currentStep.getLatestData(KEY_ACTIONS); if (latestActions != null && latestActions.getResult() != null) { actions.addAll(latestActions.getResult()); } } actions.addAll(allCurrentActions.stream(). filter(action -> !actions.contains(action)).collect(Collectors.toList())); Data actionsData = new Data<>(KEY_ACTIONS, actions); actionsData.setPublic(true); currentStep.storeData(actionsData); currentStep.resetConversationOutput(KEY_ACTIONS); currentStep.addConversationOutputList(KEY_ACTIONS, actions); }
public static Map<String, Object> prepareContext(List<IData<Context>> contextDataList) { Map<String, Object> dynamicAttributesMap = new HashMap<>(); contextDataList.forEach(contextData -> { Context context = contextData.getResult(); Context.ContextType contextType = context.getType(); if (contextType.equals(Context.ContextType.object) || contextType.equals(Context.ContextType.string)) { String dataKey = contextData.getKey(); dynamicAttributesMap.put(dataKey.substring(dataKey.indexOf(":") + 1), context.getValue()); } }); return dynamicAttributesMap; } }
List result; if (data != null) { result = (List) data.getResult(); } else { result = new LinkedList();
private int countActionOccurrences(IConversationStepStack conversationStepStack, String action) { int count = 0; for (int i = 0; i < conversationStepStack.size(); i++) { IConversationStep conversationStep = conversationStepStack.get(i); IData<List<String>> latestData = conversationStep.getLatestData(KEY_ACTIONS); if (latestData != null) { List<String> actions = latestData.getResult(); if (actions.contains(action)) { count++; } } } return count; }
private void storeContextQuickReplies(IWritableConversationStep currentStep, List<IData<Context>> contextDataList) { contextDataList.forEach(contextData -> { String contextKey = contextData.getKey(); Context context = contextData.getResult(); String key = contextKey.substring((CONTEXT_IDENTIFIER + ":").length()); if (key.startsWith(QUICK_REPLIES_IDENTIFIER) && context.getType().equals(Context.ContextType.object)) { String contextQuickReplyKey = CONTEXT_IDENTIFIER + ":" + QUICK_REPLIES_IDENTIFIER + ":"; String quickRepliesKey = "context"; if (contextKey.contains(contextQuickReplyKey)) { quickRepliesKey = contextKey.substring(contextQuickReplyKey.length()); } if (context.getType().equals(Context.ContextType.object)) { List<QuickReply> quickReplies = convertMapToObjects((List<Map<String, String>>) context.getValue()); storeQuickReplies(currentStep, quickReplies, quickRepliesKey); } } }); }
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); } } }
private static ConversationMemorySnapshot.ConversationStepSnapshot iterateConversationStep(IConversationMemory.IConversationStep conversationStep) { ConversationMemorySnapshot.ConversationStepSnapshot conversationStepSnapshot = new ConversationMemorySnapshot.ConversationStepSnapshot(); if (!conversationStep.isEmpty()) { ConversationMemorySnapshot.PackageRunSnapshot packageRunSnapshot = new ConversationMemorySnapshot.PackageRunSnapshot(); conversationStepSnapshot.getPackages().add(packageRunSnapshot); for (IData data : conversationStep.getAllElements()) { ConversationMemorySnapshot.ResultSnapshot resultSnapshot = new ConversationMemorySnapshot.ResultSnapshot(data.getKey(), data.getResult(), data.getPossibleResults(), data.getTimestamp(), data.isPublic()); packageRunSnapshot.getLifecycleTasks().add(resultSnapshot); } } return conversationStepSnapshot; }
@Override public void executeTask(IConversationMemory memory) { IConversationMemory.IWritableConversationStep currentStep = memory.getCurrentStep(); IData<String> latestInput = currentStep.getLatestData(KEY_INPUT); if (latestInput == null) { return; } String input = latestInput.getResult(); String formattedInput = normalizer.normalizeInput(input, allowedChars, true, convertSpecialCharacter); currentStep.storeData(new Data<>("input:formatted", formattedInput)); currentStep.addConversationOutputString(KEY_INPUT, formattedInput); }
Context context = contextDatum.getResult(); if (contextDatum.getKey().equals(CONTEXT + ":" + contextKey)) { switch (context.getType()) {
private void templatingQuickReplies(IConversationMemory memory, List<IData<List<QuickReply>>> quickReplyDataList, Map<String, Object> contextMap) { quickReplyDataList.forEach(quickReplyData -> { List<QuickReply> quickReplies = quickReplyData.getResult(); List<QuickReply> preTemplatedQuickReplies = copyQuickReplies(quickReplies); quickReplies.forEach(quickReply -> { try { String preTemplatedValue = quickReply.getValue(); String postTemplatedValue = templatingEngine.processTemplate(preTemplatedValue, contextMap); quickReply.setValue(postTemplatedValue); String preTemplatedExpressions = quickReply.getExpressions(); String postTemplatedExpressions = templatingEngine.processTemplate(preTemplatedExpressions, contextMap); quickReply.setExpressions(postTemplatedExpressions); } catch (ITemplatingEngine.TemplateEngineException e) { log.error(e.getLocalizedMessage(), e); } }); templateData(memory, quickReplyData, quickReplyData.getKey(), preTemplatedQuickReplies, quickReplies); memory.getCurrentStep().addConversationOutputList(KEY_QUICK_REPLIES, quickReplies); }); }
@Override public void executeTask(IConversationMemory memory) { IWritableConversationStep currentStep = memory.getCurrentStep(); List<IData<Context>> contextDataList = currentStep.getAllData("context"); storeContextQuickReplies(currentStep, contextDataList); IData<List<String>> latestData = currentStep.getLatestData(KEY_ACTIONS); if (latestData == null) { return; } List<String> actions = latestData.getResult(); List<IOutputFilter> outputFilters = createOutputFilters(memory, actions); Map<String, List<OutputEntry>> outputs = outputGeneration.getOutputs(outputFilters); outputs.forEach((action, outputEntries) -> outputEntries.forEach(outputEntry -> { List<OutputValue> outputValues = outputEntry.getOutputs(); selectAndStoreOutput(currentStep, action, outputValues); storeQuickReplies(currentStep, outputEntry.getQuickReplies(), outputEntry.getAction()); })); }
@Override public void executeTask(IConversationMemory memory) { //parse user input to meanings final IData<String> inputData = memory.getCurrentStep().getLatestData(KEY_INPUT); if (inputData == null) { return; } List<IDictionary> temporaryDictionaries = prepareTemporaryDictionaries(memory); List<RawSolution> parsedSolutions; try { String userInput = inputData.getResult(); String normalizedUserInput = sentenceParser.normalize(userInput); storeNormalizedResultInMemory(memory.getCurrentStep(), normalizedUserInput); parsedSolutions = sentenceParser.parse(normalizedUserInput, temporaryDictionaries); } catch (InterruptedException e) { log.warn(e.getLocalizedMessage(), e); return; } storeResultInMemory(memory.getCurrentStep(), parsedSolutions); }
List<String> result = actionData.getResult(); if (result != null && result.contains(CONVERSATION_END)) { endConversation();