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 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 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; }
Map<String, Object> contextMap) { outputDataList.forEach(output -> { String outputKey = output.getKey(); TemplateMode templateMode = outputKey.startsWith(KEY_OUTPUT) ? TemplateMode.TEXT : null; if (templateMode == null) { Object preTemplated = output.getResult(); Object postTemplated = null; output.setResult(postTemplated); templateData(memory, output, outputKey, preTemplated, postTemplated); currentStep.addConversationOutputList(KEY_OUTPUT, Collections.singletonList(output.getResult()));
if (!"".equals(message.trim())) { initialData = new Data<>(KEY_INPUT + ":initial", message); initialData.setPublic(true); lifecycleData.add(initialData); currentStep.addConversationOutputString(KEY_INPUT, message); List<String> result = actionData.getResult(); if (result != null && result.contains(CONVERSATION_END)) { endConversation();
@Override public void storeData(IData data) { store.put(data.getKey(), data); }
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); } }
@Override public <T> IData<T> getLatestData(String prefix) { List<IData> elements = getAllElements(); Collections.reverse(elements); for (IData element : elements) { if (element.getKey().startsWith(prefix)) { return element; } } return null; }
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); } }
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; }
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; } }
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 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 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 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 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); }
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; }