def __handle_api_response(self, response, node_data): variable_data = self.state.get("var_data", {}) # if isinstance(variable_data, str): # variable_data = json.loads(variable_data) variable_name = node_data.get("VariableName", "") logger.debug(f"Variable Name is {variable_name}") logger.debug(f"Response from api is {response} {response.__class__}") logger.debug( f"Variable Data is {variable_data} {variable_data.__class__}") if response is None: # get fallback node since api call failed next_node_id = self.__get_next_node_id(data={}, state=self.state, node_data=node_data) next_node_key = self.state.get("flow_id", "") + "." + next_node_id next_node_data = AnaNode(next_node_key).get_contents() else: variable_data[variable_name] = response # variable_data = Util.merge_dicts(variable_data, {variable_name : # response}) self.state["var_data"] = variable_data next_node_id = self.__get_next_node_id(data=variable_data, state=self.state, node_data=node_data) next_node_key = self.state.get("flow_id", "") + "." + next_node_id next_node_data = AnaNode(next_node_key).get_contents() return {"id": next_node_key, "data": next_node_data}
def handle_handover(self, event): # from event payload determine the next node # convert this node into message # send this message to user # update state with new_node_id as current_node_id # respond with 200 ok status success current_node_id = self.state.get("current_node_id") next_node_data = AnaNode(current_node_id).get_next_node_data(self.message_data, self.state) next_node_id = next_node_data.get("node_id") self.state["current_node_id"] = next_node_id node_data = AnaNode(next_node_id).get_contents() data = AnaConverter(self.state).get_messages_data(node_data, self.message_data) messages_data = data.get("user_messages") self.meta_data["id"] = "" messages = [Message(meta=self.meta_data, data=data).trim() for data in messages_data] # message = Message(meta=self.meta_data, data=message_data).trim() user_response = Util.send_messages(messages=messages, sending_to="USER") if user_response: Util.update_state(meta_data=self.meta_data, state=self.state, is_handover=True) Util.log_events(meta_data=self.meta_data, state=self.state, events=data.get("publish_events", [])) return []
def get_next_node(self, node_data): next_node_id = node_data.get('NextNodeId', '') #Fallback node id variable_data = self.state.get("var_data", {}) buttons = node_data.get("Buttons") for button in buttons: root_key = re.split(r'\.|\[', button.get("ConditionMatchKey"))[0] logger.debug( f"Variable Data received for condition call is {variable_data}" ) # if isinstance(variable_data, str): # try: # variable_data = json.loads(variable_data) # except Exception as err: # logger.error(f"Error parsing variable_data {variable_data}") # variable_data = {} logger.debug( f"Variable Data after dict conversion is {variable_data}") if variable_data.get(root_key) is None: continue path = button.get("ConditionMatchKey") obj = {root_key: variable_data[root_key]} variable_value = Util.deep_find(obj, path) match_operator = button.get("ConditionOperator") match_value = AnaHelper.verb_replacer(text=button.get( "ConditionMatchValue", ""), state=self.state) logger.debug( f"variable_value {variable_value} {variable_value.__class__} match_operator {match_operator} match_value {match_value}" ) condition_matched = AnaHelper.is_condition_match( variable_value, match_operator, match_value) logger.debug(f"Condition matched is {condition_matched}") if condition_matched: variable_data = self.state.get("var_data", {}) node_variable_name = node_data.get("VariableName") if node_variable_name: button_variable_value = button.get("VariableValue") button_variable_value = AnaHelper.verb_replacer( text=button_variable_value, state=self.state) variable_data[node_variable_name] = button_variable_value next_node_id = button["NextNodeId"] break next_node_key = self.state.get("flow_id", "") + "." + next_node_id node_data = AnaNode(next_node_key).get_contents() return {"id": next_node_key, "data": node_data}
def get_next_node(self, node_data): current_flow_id = self.state.get("flow_id", "") self.state["previous_flow_id"] = current_flow_id new_flow_id = node_data.get("TargetBotId") self.state["flow_id"] = new_flow_id next_node_id = node_data.get("TargetNodeId") if next_node_id: next_node_key = new_flow_id + "." + next_node_id else: next_node_key = new_flow_id + "." + config["first_node_key"] next_node_data = AnaNode(next_node_key).get_contents() return {"id": next_node_key, "data": next_node_data}
def __get_current_node(self): """ Gets the current node based on the state """ get_started_node = self.state.get( "flow_id", "") + "." + flow_config["first_node_key"] current_node_id = self.state.get( "current_node_id", get_started_node) # give first_node as default node = AnaNode(current_node_id).get_contents() return {"node": node, "publish_events": []}
def __get_node(self, message_data): """ Get next_node(ANA output node) to send to user depending on current_node and the incoming message. If it's a first time user, next_node is first_node """ get_started_node = self.state.get( "flow_id", "") + "." + flow_config["first_node_key"] next_node_id = get_started_node event_data = [] if bool(self.state.get("current_node_id")): # user already in ana flow current_node_id = self.state.get( "current_node_id", get_started_node) # give first_node as default next_node_data = AnaNode(current_node_id).get_next_node_data( message_data, self.state) event_data = next_node_data.get("publish_events", []) next_node_id = next_node_data["node_id"] var_data = self.state.get("var_data", {}) new_var_data = next_node_data.get("input_data", {}) logger.debug(f"var_data type is {type(var_data)} {var_data}") logger.debug( f"new_var_data type is {type(var_data)} {new_var_data}") logger.debug(f"var_data type is {type(var_data)} {var_data}") logger.debug( f"new_var_data type is {type(new_var_data)} {new_var_data}") final_var_data = Util.merge_dicts(var_data, new_var_data) self.state["var_data"] = final_var_data self.state["new_var_data"] = new_var_data # self.state["current_node_id"] = next_node_id node = AnaNode(next_node_id).get_contents() return {"node": node, "publish_events": event_data}
def handle_intent_to_handover(self, event): # from state get current_node_id # check if it's handofftoagent type node # process this node as combination node and get message data # fill meta and construct message # respond with this message node_id = self.state.get("current_node_id") node_contents = AnaNode(node_id).get_contents() data = CombinationProcessor(self.state).process_node(node_contents) messages = data.get("user_messages", []) message_data = {} if messages: message_data = messages[0] message = Message(meta=self.meta_data, data=message_data).trim() return [message]
def __handle_delivery_events(self, event): sender = SenderType.get_name(self.meta_data["senderType"]) sending_to = None if sender == "AGENT": sending_to = "USER" elif sender == "USER": node_key = self.state.get("current_node_id") is_agent_node = AnaNode(node_key).check_if_agent_node() if is_agent_node: sending_to = "AGENT" logger.debug(f"Typing event forwarded to {sending_to} meta {self.meta_data} event {event}") message = Message(meta=self.meta_data, events=[event]).trim() Util.send_messages(messages=[message], sending_to=sending_to) return []