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); } }
@Override public Property put(String key, Property property) { if (conversationMemory != null) { String propertiesKey = KEY_PROPERTIES + ":" + key; IConversationMemory.IWritableConversationStep currentStep = conversationMemory.getCurrentStep(); currentStep.storeData(new Data<>(propertiesKey, Collections.singletonList(property))); Map<String, Object> propertyMap = new LinkedHashMap<>(); propertyMap.put(property.getName(), property.getValue()); propertiesMap.putAll(propertyMap); currentStep.addConversationOutputMap(KEY_PROPERTIES, propertyMap); } return super.put(key, property); }
currentStep.storeData(httpResponseData); currentStep.addConversationOutputMap(KEY_HTTP_CALLS, Map.of(responseObjectName, responseObject));
currentStep.storeData(dataFactory.createData(PROPERTIES_EXTRACTED_IDENTIFIER, properties, true));
memory.getCurrentStep().storeData(contextData);
public static IConversationMemory convertConversationMemorySnapshot(ConversationMemorySnapshot snapshot) { ConversationMemory conversationMemory = new ConversationMemory(snapshot.getConversationId(), snapshot.getBotId(), snapshot.getBotVersion(), snapshot.getUserId()); conversationMemory.setConversationState(snapshot.getConversationState()); conversationMemory.getConversationProperties().putAll(snapshot.getConversationProperties()); List<IConversationMemory.IConversationStep> redoSteps = iterateRedoCache(snapshot.getRedoCache()); for (IConversationMemory.IConversationStep redoStep : redoSteps) { conversationMemory.getRedoCache().add(redoStep); } List<ConversationMemorySnapshot.ConversationStepSnapshot> conversationSteps = snapshot.getConversationSteps(); for (int i = 0; i < conversationSteps.size(); i++) { ConversationOutput conversationOutput = snapshot.getConversationOutputs().get(i); ConversationMemorySnapshot.ConversationStepSnapshot conversationStepSnapshot = conversationSteps.get(i); if (i > 0) { conversationMemory.startNextStep(conversationOutput); } for (ConversationMemorySnapshot.PackageRunSnapshot packageRunSnapshot : conversationStepSnapshot.getPackages()) { for (ConversationMemorySnapshot.ResultSnapshot resultSnapshot : packageRunSnapshot.getLifecycleTasks()) { Data data = new Data(resultSnapshot.getKey(), resultSnapshot.getResult(), resultSnapshot.getPossibleResults(), resultSnapshot.getTimestamp(), resultSnapshot.isPublic()); conversationMemory.getCurrentStep().storeData(data); } } } return conversationMemory; }
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 List<IConversationMemory.IConversationStep> iterateRedoCache(List<ConversationMemorySnapshot.ConversationStepSnapshot> redoSteps) { List<IConversationMemory.IConversationStep> conversationSteps = new LinkedList<>(); for (ConversationMemorySnapshot.ConversationStepSnapshot redoStep : redoSteps) { IConversationMemory.IWritableConversationStep conversationStep = new ConversationStep(new ConversationOutput()); conversationSteps.add(conversationStep); for (ConversationMemorySnapshot.PackageRunSnapshot packageRunSnapshot : redoStep.getPackages()) { for (ConversationMemorySnapshot.ResultSnapshot resultSnapshot : packageRunSnapshot.getLifecycleTasks()) { Data data = new Data(resultSnapshot.getKey(), resultSnapshot.getResult(), resultSnapshot.getPossibleResults(), resultSnapshot.getTimestamp(), resultSnapshot.isPublic()); conversationStep.storeData(data); } } } return conversationSteps; }
private void mergeConversationMemory(IConversationMemory currentConversationMemory, ConversationMemorySnapshot callbackMemorySnapshot) { if (callbackMemorySnapshot != null && !callbackMemorySnapshot.getConversationSteps().isEmpty()) { var currentStep = currentConversationMemory.getCurrentStep(); var callbackConversationMemory = convertConversationMemorySnapshot(callbackMemorySnapshot); var currentCallbackStep = callbackConversationMemory.getCurrentStep(); Set<String> callbackKeys = currentCallbackStep.getAllKeys(); for (String callbackKey : callbackKeys) { currentStep.storeData(currentCallbackStep.getData(callbackKey)); } } }
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 void storeResultIfNotEmpty(IConversationMemory memory, String key, List<BehaviorRule> result) { if (!result.isEmpty()) { memory.getCurrentStep().storeData(new Data<>(key, convert(result))); } }
private void executePackages(List<IData> data) throws LifecycleException { for (IExecutablePackage executablePackage : executablePackages) { data.stream().filter(Objects::nonNull). forEach(datum -> conversationMemory.getCurrentStep().storeData(datum)); ILifecycleManager lifecycleManager = executablePackage.getLifecycleManager(); lifecycleManager.executeLifecycle(conversationMemory); } } }
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); }
private void storeTemplatedData(IConversationMemory memory, String originalKey, String templateAppendix, Object dataValue) { String newOutputKey = joinStrings(":", originalKey, templateAppendix); IData processedData = dataFactory.createData(newOutputKey, dataValue); memory.getCurrentStep().storeData(processedData); }
private void storeNormalizedResultInMemory(IConversationMemory.IWritableConversationStep currentStep, String normalizedInput) { if (!RuntimeUtilities.isNullOrEmpty(normalizedInput)) { IData<String> expressionsData = new Data<>(KEY_INPUT_NORMALIZED, normalizedInput); currentStep.storeData(expressionsData); currentStep.addConversationOutputString(KEY_INPUT, normalizedInput); } }
@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); }
private void templateData(IConversationMemory memory, IData dataText, String dataKey, Object preTemplated, Object postTemplated) { storeTemplatedData(memory, dataKey, PRE_TEMPLATED, preTemplated); storeTemplatedData(memory, dataKey, POST_TEMPLATED, postTemplated); memory.getCurrentStep().storeData(dataText); }