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 []