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); }
private void selectAndStoreOutput(IWritableConversationStep currentStep, String action, List<OutputValue> outputValues) { List<QuickReply> quickReplies = new LinkedList<>(); IntStream.range(0, outputValues.size()).forEach(index -> { OutputValue outputValue = outputValues.get(index); List<Object> possibleValueAlternatives = outputValue.getValueAlternatives(); Object randomValue = chooseRandomly(possibleValueAlternatives); if (randomValue instanceof Map) { Map<String, String> randomValueMap = new LinkedHashMap<>((Map) randomValue); randomValueMap.put("type", outputValue.getType()); if (OUTPUT_TYPE_QUICK_REPLY.equals(outputValue.getType())) { quickReplies.add(new QuickReply(randomValueMap.get(KEY_VALUE), randomValueMap.get(KEY_EXPRESSIONS), Boolean.parseBoolean(randomValueMap.getOrDefault(KEY_IS_DEFAULT, "false")))); } randomValue = randomValueMap; } String outputKey = createOutputKey(action, outputValues, outputValue, index); IData<Object> outputData = dataFactory.createData(outputKey, randomValue, possibleValueAlternatives); outputData.setPublic(true); currentStep.storeData(outputData); currentStep.addConversationOutputList(MEMORY_OUTPUT_IDENTIFIER, Collections.singletonList(randomValue)); }); if (!quickReplies.isEmpty()) { storeQuickReplies(currentStep, quickReplies, action); } }
currentStep.addConversationOutputList(KEY_OUTPUT, Collections.singletonList(output.getResult()));
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); }); }
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 void storeQuickReplies(IWritableConversationStep currentStep, List<QuickReply> quickReplies, String action) { if (!quickReplies.isEmpty()) { String outputQuickReplyKey = StringUtilities. joinStrings(":", MEMORY_QUICK_REPLIES_IDENTIFIER, action); IData outputQuickReplies = dataFactory.createData(outputQuickReplyKey, quickReplies); outputQuickReplies.setPublic(true); currentStep.storeData(outputQuickReplies); currentStep.addConversationOutputList(MEMORY_QUICK_REPLIES_IDENTIFIER, quickReplies); } }
private static void addConversationStartAction(IWritableConversationStep currentStep) { List<String> conversationEndArray = Collections.singletonList(CONVERSATION_START); currentStep.storeData(new Data<>(KEY_ACTIONS, conversationEndArray)); currentStep.addConversationOutputList(KEY_ACTIONS, conversationEndArray); }