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 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; } }
public static ConversationMemorySnapshot convertConversationMemory(IConversationMemory conversationMemory) { ConversationMemorySnapshot snapshot = new ConversationMemorySnapshot(); if (conversationMemory.getUserId() != null) { snapshot.setUserId(conversationMemory.getUserId()); } if (conversationMemory.getConversationId() != null) { snapshot.setConversationId(conversationMemory.getConversationId()); } snapshot.setBotId(conversationMemory.getBotId()); snapshot.setBotVersion(conversationMemory.getBotVersion()); snapshot.setConversationState(conversationMemory.getConversationState()); for (IConversationMemory.IConversationStep redoStep : conversationMemory.getRedoCache()) { ConversationMemorySnapshot.ConversationStepSnapshot redoStepSnapshot = iterateConversationStep(redoStep); snapshot.getRedoCache().push(redoStepSnapshot); } for (int i = conversationMemory.getAllSteps().size() - 1; i >= 0; i--) { IConversationMemory.IConversationStep conversationStep = conversationMemory.getAllSteps().get(i); snapshot.getConversationSteps().add(iterateConversationStep(conversationStep)); } snapshot.getConversationOutputs().addAll(conversationMemory.getConversationOutputs()); snapshot.getConversationProperties().putAll(conversationMemory.getConversationProperties()); return snapshot; }
@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) throws LifecycleException { IConversationMemory.IWritableConversationStep currentStep = memory.getCurrentStep(); IData<String> expressionsData = currentStep.getLatestData(EXPRESSIONS_PARSED_IDENTIFIER); List<IData<Context>> contextDataList = currentStep.getAllData(CONTEXT_IDENTIFIER); if (!override && memory.getConversationProperties().containsKey(name)) { continue; memory.getConversationProperties().put(name, new Property(name, templatedObj, scope)); templateDataObjects.put(PROPERTIES_IDENTIFIER, memory.getConversationProperties().toMap()); IConversationStepStack previousSteps = memory.getPreviousSteps(); if (previousSteps.size() > 0) { actionsData = previousSteps.get(0).getLatestData(ACTIONS_IDENTIFIER);
@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; }
private LinkedList<IOutputFilter> createOutputFilters(IConversationMemory memory, List<String> actions) { return actions.stream().map(action -> new OutputFilter(action, countActionOccurrences(memory.getPreviousSteps(), action))). collect(Collectors.toCollection(LinkedList::new)); }
final IConversationMemory conversationMemory = loadConversationMemory(conversationId); checkConversationMemoryNotNull(conversationMemory, conversationId); if (!botId.equals(conversationMemory.getBotId())) { String message = "Supplied botId (%s) is incompatible with conversationId (%s)"; message = String.format(message, botId, conversationId); IBot bot = botFactory.getBot(environment, conversationMemory.getBotId(), conversationMemory.getBotVersion()); if (bot == null) { String msg = "Bot not deployed (environment=%s, conversationId=%s, version=%s)"; msg = String.format(msg, environment, conversationMemory.getBotId(), conversationMemory.getBotVersion()); response.resume(new NotFoundException(msg)); return; createPropertiesHandler(conversationMemory.getUserId()), returnConversationMemory -> { SimpleConversationMemorySnapshot memorySnapshot =
private void storePropertiesPermanently() throws IResourceStore.ResourceStoreException { Properties longTermConversationProperties = conversationMemory.getConversationProperties().values().stream() .filter(property -> property.getScope() == Scope.longTerm) .filter(property -> property.getValue() != null) .collect(Collectors.toMap(Property::getName, Property::getValue, (a, b) -> b, Properties::new)); propertiesHandler.mergeProperties(longTermConversationProperties); }
boolean occurredInAnyStep(IConversationMemory memory, String dataKey, ValueEvaluation valueEvaluation) { List<IData<String>> allLatestData = memory.getAllSteps().getAllLatestData(dataKey); return allLatestData.stream().anyMatch(latestData -> valueEvaluation.evaluate(latestData) == SUCCESS); }
private IConversationMemory loadAndValidateConversationMemory(String botId, String conversationId) throws ResourceStoreException, ResourceNotFoundException, IllegalAccessException { var conversationMemory = loadConversationMemory(conversationId); checkConversationMemoryNotNull(conversationMemory, conversationId); if (!botId.equals(conversationMemory.getBotId())) { throw new IllegalAccessException("Supplied botId is incompatible to conversationId"); } return conversationMemory; }
@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; }
propertyValue = propertyInstruction.getValue(); memory.getConversationProperties().put(propertyName, new Property(propertyName, propertyValue, scope)); memory.getCurrentStep().storeData(contextData);
private List<IDictionary> prepareTemporaryDictionaries(IConversationMemory memory) { IConversationMemory.IConversationStepStack previousSteps = memory.getPreviousSteps(); List<IDictionary> temporaryDictionaries = Collections.emptyList(); if (previousSteps.size() > 0) { List<IData<List<Map<String, String>>>> data = previousSteps.get(0).getAllData("quickReplies"); if (data != null) { List<QuickReply> quickReplies = extractQuickReplies(data); temporaryDictionaries = convertQuickReplies(quickReplies, expressionProvider); } } return temporaryDictionaries; }
private void removeOldInvalidProperties() { IConversationProperties conversationProperties = conversationMemory.getConversationProperties(); Map<String, Property> filteredConversationProperties = conversationProperties.entrySet().stream() .filter(property -> property.getValue().getScope() != Scope.step) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); conversationProperties.clear(); conversationProperties.putAll(filteredConversationProperties); }
@Override public ExecutionState execute(IConversationMemory memory, List<BehaviorRule> trace) { boolean success; List<List<IData<List<String>>>> allData = memory.getAllSteps().getAllData(BEHAVIOR_RULES_SUCCESS); if (allData != null) { final int actualTimesOccurred = countTimesOccurred(getAllBehaviorRules(allData)); boolean isMin = true; boolean isMax = true; if (minTimesOccurred != -1) { isMin = actualTimesOccurred >= minTimesOccurred; } if (maxTimesOccurred != -1) { isMax = actualTimesOccurred <= maxTimesOccurred; } success = isMin && isMax; } else { success = false; } if (success) { state = ExecutionState.SUCCESS; } else { state = ExecutionState.FAIL; } return state; }
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 loadLongTermProperties(IConversationMemory conversationMemory) throws LifecycleException { try { Properties properties = propertiesHandler.loadProperties(); if (properties.containsKey(KEY_USER_INFO)) { Object userInfo = properties.get(KEY_USER_INFO); if (userInfo instanceof Map) { conversationMemory.getConversationProperties(). put(KEY_USER_INFO, new Property(KEY_USER_INFO, userInfo, Scope.conversation)); } } conversationMemory.getConversationProperties().putAll(convertProperties(properties)); } catch (IResourceStore.ResourceStoreException | IResourceStore.ResourceNotFoundException e) { throw new LifecycleException(e.getLocalizedMessage(), e); } }
@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))); } }