@Override public <T> IData<T> createData(String key, T value, List<T> possibleValues) { return new Data<>(key, value, possibleValues); } }
private List<IData<Context>> createContextData(Map<String, Context> context) { List<IData<Context>> contextData = new LinkedList<>(); if (context != null) { for (String key : context.keySet()) { contextData.add(new Data<>(KEY_CONTEXT + ":" + key, context.get(key))); } } return contextData; }
@Override public <T> IData<T> createData(String key, T value, boolean isPublic) { Data<T> data = new Data<>(key, value); data.setPublic(isPublic); return data; }
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); }
@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))); } }
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 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); } }
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 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 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; }
IWritableConversationStep currentStep = conversationMemory.getCurrentStep(); if (!"".equals(message.trim())) { initialData = new Data<>(KEY_INPUT + ":initial", message); initialData.setPublic(true); lifecycleData.add(initialData);
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; }