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 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)); } } }
@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); }
private void storeResultIfNotEmpty(IConversationMemory memory, String key, List<BehaviorRule> result) { if (!result.isEmpty()) { memory.getCurrentStep().storeData(new Data<>(key, convert(result))); } }
IData data = memory.getCurrentStep().getLatestData("result_size"); List result; if (data != null) {
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 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); }
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); }
@Override public Map<String, Object> convert(IConversationMemory memory) { Map<String, Object> ret = new LinkedHashMap<>(); List<IData<Context>> contextDataList = memory.getCurrentStep().getAllData(KEY_CONTEXT); var contextMap = prepareContext(contextDataList); var memoryMap = convertMemoryItems(memory); var conversationProperties = memory.getConversationProperties(); if (!contextMap.isEmpty()) { ret.put(KEY_CONTEXT, contextMap); ret.putAll(contextMap); } if (!conversationProperties.isEmpty()) { ret.put(KEY_PROPERTIES, conversationProperties.toMap()); } if (!memoryMap.isEmpty()) { ret.put(KEY_MEMORY, convertMemoryItems(memory)); } return ret; }
@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); }
private static Map<String, Object> convertMemoryItems(IConversationMemory memory) { Map<String, Object> props = new HashMap<>(); IWritableConversationStep currentStep; IConversationStep lastStep; currentStep = memory.getCurrentStep(); var current = currentStep.getConversationOutput(); props.put(KEY_CURRENT, current); var last = new ConversationOutput(); if (memory.getPreviousSteps().size() > 0) { lastStep = memory.getPreviousSteps().get(0); last = lastStep.getConversationOutput(); } props.put(KEY_LAST, last); var past = memory.getConversationOutputs(); if (past.size() > 1) { past = past.subList(1, past.size()); } else { past = new LinkedList<>(); } props.put(KEY_PAST, past); return props; } }
@Override public void init(Map<String, Context> context) throws LifecycleException { setConversationState(ConversationState.READY); addConversationStartAction(conversationMemory.getCurrentStep()); loadLongTermProperties(conversationMemory); executePackages(new LinkedList<>(createContextData(context))); }
templateData(memory, output, outputKey, preTemplated, postTemplated); IWritableConversationStep currentStep = memory.getCurrentStep(); currentStep.addConversationOutputList(KEY_OUTPUT, Collections.singletonList(output.getResult()));
@Override public void executeTask(IConversationMemory memory) { IWritableConversationStep currentStep = memory.getCurrentStep(); List<IData<Object>> outputDataList = currentStep.getAllData(KEY_OUTPUT); List<IData<List<QuickReply>>> quickReplyDataList = currentStep.getAllData(KEY_QUICK_REPLIES); final Map<String, Object> contextMap = memoryItemConverter.convert(memory); if (!outputDataList.isEmpty()) { currentStep.resetConversationOutput(KEY_OUTPUT); } templateOutputTexts(memory, outputDataList, contextMap); if (!quickReplyDataList.isEmpty()) { currentStep.resetConversationOutput(KEY_QUICK_REPLIES); } templatingQuickReplies(memory, quickReplyDataList, contextMap); }
@Override public void executeTask(IConversationMemory memory) { IData<List<String>> actionData = memory.getCurrentStep().getLatestData(KEY_ACTIONS); if (!executeCallback(actionData)) { return; } var request = new ConversationDataRequest(); request.setConversationMemorySnapshot(convertConversationMemory(memory)); var response = conversationCallback.doExternalCall(callback, request, timeoutInMillis); if (String.valueOf(response.getHttpCode()).startsWith("2")) { //check for success, http code 2xx mergeConversationMemory(memory, response.getConversationMemorySnapshot()); } else { String msg = "ConversationCallback was (%s) but should have been 2xx. Return value as been ignored"; msg = String.format(msg, response.getHttpCode()); log.warn(msg); } }
@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 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 ExecutionState execute(IConversationMemory memory, List<BehaviorRule> trace) { IData<List<String>> data; switch (occurrence) { case currentStep: data = memory.getCurrentStep().getLatestData(KEY_ACTIONS); state = evaluateActions(data); break; case lastStep: IConversationMemory.IConversationStepStack previousSteps = memory.getPreviousSteps(); if (previousSteps.size() > 0) { data = previousSteps.get(0).getLatestData(KEY_ACTIONS); state = evaluateActions(data); } else { state = FAIL; } break; case anyStep: state = occurredInAnyStep(memory, KEY_ACTIONS, this::evaluateActions) ? SUCCESS : FAIL; break; case never: state = occurredInAnyStep(memory, KEY_ACTIONS, this::evaluateActions) ? FAIL : SUCCESS; break; } return state; }
@Override public ExecutionState execute(IConversationMemory memory, List<BehaviorRule> trace) { IData<String> data; switch (occurrence) { case currentStep: data = memory.getCurrentStep().getLatestData(KEY_EXPRESSIONS); state = evaluateInputExpressions(data); break; case lastStep: IConversationStepStack previousSteps = memory.getPreviousSteps(); if (previousSteps.size() > 0) { data = previousSteps.get(0).getLatestData(KEY_EXPRESSIONS); state = evaluateInputExpressions(data); } else { state = FAIL; } break; case anyStep: state = occurredInAnyStep(memory, KEY_EXPRESSIONS, this::evaluateInputExpressions) ? SUCCESS : FAIL; break; case never: state = occurredInAnyStep(memory, KEY_EXPRESSIONS, this::evaluateInputExpressions) ? FAIL : SUCCESS; break; } return state; }