def test_call_GeneralRest_response_empty(self):
service_config = BrainServiceConfiguration("__PUBLISHEDREST__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDREST__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._host = TemplateWordNode("hostname")
root.append(node)
service = ServiceFactory.get_service("__PUBLISHEDREST__")
service.set_response("")
self.assertEqual("", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
self.assertEqual("", node.resolve(self._client_context))
def test_node_GeneralRest(self):
ServiceFactory.clear()
root = TemplateNode()
self.assertIsNotNone(root)
self.assertIsNotNone(root.children)
self.assertEqual(len(root.children), 0)
node = TemplateSRAIXNode()
self.assertIsNotNone(node)
node._default = "unknown"
node._host = TemplateWordNode("hostname")
node._method = TemplateWordNode("POST")
node._query = TemplateWordNode('"userid":"1234567890"')
node._header = TemplateWordNode('"Content-Type":"application/json"')
node._body = TemplateWordNode("Hello")
self.assertEqual("hostname", node._host.word)
root.append(node)
self.assertEqual(len(root.children), 1)
with self.assertRaises(Exception):
node.resolve_to_string(self._client_context)
self.assertEqual(
'[SRAIX (host=hostname, default=unknown, method=POST, ' +
'query={"userid":"1234567890"}, header={"Content-Type":"application/json"}, '
+ 'body=Hello)]', node.to_string())
def test_call_PublishedBot_response_default(self):
service_config = BrainServiceConfiguration("__PUBLISHEDBOT__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDBOT__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._botName = "testbot"
node._userId = TemplateWordNode('1234567890')
node._default = "unknown"
node.append(TemplateWordNode("Hello"))
root.append(node)
service = ServiceFactory.get_service("__PUBLISHEDBOT__")
service.set_response("")
self.set_collection_botnames()
self.assertEqual("unknown", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
self.assertEqual("unknown", node.resolve(self._client_context))
self.assertEqual("unknown",
question.property('__SUBAGENT_EXTBOT__.testbot'))
def test_call_CustomService_response_default(self):
service_config = BrainServiceConfiguration("mock")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['mock'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._service = "mock"
node._default = "unknown"
node.append(TemplateWordNode("Hello"))
root.append(node)
service = ServiceFactory.get_service("mock")
service.set_response("")
self.assertEqual("unknown", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
self.assertEqual("unknown", node.resolve(self._client_context))
self.assertEqual("unknown", question.property('__SUBAGENT__.mock'))
def test_call_GeneralRest(self):
service_config = BrainServiceConfiguration("__PUBLISHEDREST__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDREST__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._host = TemplateWordNode("hostname")
node._method = TemplateWordNode("POST")
node._query = TemplateWordNode('"userid":"1234567890"')
node._header = TemplateWordNode('"Content-Type":"application/json"')
node._body = TemplateWordNode("Hello")
root.append(node)
self.assertEqual("asked", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
self.assertEqual("asked", node.resolve(self._client_context))
self.assertEqual("asked", question.property('__SUBAGENT_BODY__'))
def set_service_config(self):
service1 = BrainServiceConfiguration("ask")
service1._classname = "programy.services.rest.GenericRESTService"
service1._host = "localhost"
service2 = BrainServiceConfiguration("test")
service2._classname = "programy.services.rest.GenericRESTService"
service2._host = "localhost"
services_config = BrainServicesConfiguration()
services_config._services = {"ask": service1, "test": service2}
ServiceFactory.preload_services(services_config)
def test_load_services(self):
service_config = BrainServiceConfiguration("mock")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['mock'] = service_config
ServiceFactory.preload_services(brain_config.services)
self.assertIsNotNone(ServiceFactory.get_service("mock"))
self.assertIsInstance(ServiceFactory.get_service("mock"), MockService)
def test_load_services(self):
service_config = BrainServiceConfiguration("mock")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['mock'] = service_config
ServiceFactory.preload_services(brain_config.services)
self.assertIsNotNone(ServiceFactory.get_service("mock"))
self.assertIsInstance(ServiceFactory.get_service("mock"), MockService)
def test_call_GeneralRest_only_host(self):
service_config = BrainServiceConfiguration("__PUBLISHEDREST__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDREST__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._host = TemplateWordNode("hostname")
root.append(node)
self.assertEqual("asked", node.resolve(self._client_context))
def test_call_PublishedBot_deleteValiables(self):
service_config = BrainServiceConfiguration("__PUBLISHEDBOT__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDBOT__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._botId = "testBot"
node._deleteVariable = TemplateWordNode('true')
node.append(TemplateWordNode("Hello"))
root.append(node)
self.assertEqual("asked", node.resolve(self._client_context))
def test_call_PublishedBot_response_none(self):
service_config = BrainServiceConfiguration("__PUBLISHEDBOT__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDBOT__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._botId = "testBot"
node.append(TemplateWordNode("Hello"))
root.append(node)
service = ServiceFactory.get_service("__PUBLISHEDBOT__")
service.set_response(None)
self.assertIsNone(node.resolve(self._client_context))
def test_call_CustomService_response_none(self):
service_config = BrainServiceConfiguration("mock")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['mock'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._service = "mock"
node.append(TemplateWordNode("Hello"))
root.append(node)
service = ServiceFactory.get_service("mock")
service.set_response(None)
self.assertEqual(None, node.resolve(self._client_context))
def _published_REST_interface(self, client_context):
self.method = None
self.query = None
self.header = None
self.body = None
self.host = self._host.resolve(client_context)
if self._method is None:
self.method = 'GET'
else:
self.method = self._method.resolve(client_context)
if self._query is not None:
shift_text = self._query.resolve(client_context)
self.query = self._delete_shift_code(shift_text)
if self._header is not None:
shift_text = self._header.resolve(client_context)
self.header = self._delete_shift_code(shift_text)
if self._body is not None:
self.body = self._body.resolve(client_context)
resolved = self.resolve_children_to_string(client_context)
YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved)
bot_service = ServiceFactory.get_service(self.SERVICE_PUBLISHED_REST)
bot_service.host = self.host
bot_service.method = self.method
try:
if self.query is None:
bot_service.query = self.query
else:
bot_service.query = ast.literal_eval("{" + self.query + "}")
if self.header is None:
bot_service.header = self.header
else:
bot_service.header = ast.literal_eval("{" + self.header + "}")
bot_service.body = self.body
response = bot_service.ask_question(client_context, resolved)
YLogger.debug(client_context, "SRAIX host [%s] return [%s]", self.host, response)
except Exception:
YLogger.debug(client_context, "SRAIX Rest parameter convet failed")
response = ''
conversation = client_context.bot.get_conversation(client_context)
status_code = ''
try:
status_code = bot_service.get_status_code()
except NotImplementedError:
pass
if conversation.has_current_question() is True:
conversation.current_question().set_property('__SUBAGENT_STATUS_CODE__', status_code)
if response is not None:
if response == '' and self.default is not None:
response = self.default
variableName = "__SUBAGENT_BODY__"
if conversation.has_current_question() is True:
conversation.current_question().set_property(variableName, response)
return response
def test_call_PublishedBot_only_botname(self):
service_config = BrainServiceConfiguration("__PUBLISHEDBOT__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDBOT__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._botName = "testbot"
node._userId = TemplateWordNode('1234567890')
root.append(node)
node.append(TemplateWordNode("Hello"))
self.set_collection_botnames()
self.assertEqual("asked", node.resolve(self._client_context))
def test_call_service(self):
service_config = BrainServiceConfiguration("mock")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['mock'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node.service = "mock"
root.append(node)
node.append(TemplateWordNode("Hello"))
self.assertEqual("asked", node.resolve(self._client_context))
def test_call_service(self):
service_config = BrainServiceConfiguration("mock")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['mock'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node.service = "mock"
root.append(node)
node.append(TemplateWordNode("Hello"))
self.assertEqual("asked", node.resolve(self.bot, self.clientid))
def resolve_to_string(self, client_context):
resolved = self.resolve_children_to_string(client_context)
YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved)
if self._service is not None:
bot_service = ServiceFactory.get_service(self._service)
response = bot_service.ask_question(client_context, resolved)
YLogger.debug(client_context, "SRAIX service [%s] return [%s]", self._service, response)
return response
else:
YLogger.error(client_context, "Sorry SRAIX does not currently have an implementation for [%s]", self._service)
return ""
def resolve_to_string(self, client_context):
resolved = self.resolve_children_to_string(client_context)
YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved)
if self._service is not None:
bot_service = ServiceFactory.get_service(self._service)
response = bot_service.ask_question(client_context, resolved)
YLogger.debug(client_context, "SRAIX service [%s] return [%s]", self._service, response)
return response
else:
YLogger.error(client_context, "Sorry SRAIX does not currently have an implementation for [%s]", self._service)
return ""
def resolve_to_string(self, client_context):
conversation = client_context.bot.get_conversation(client_context)
if conversation.has_current_question() is True:
conversation.current_question().set_property('__SUBAGENT_STATUS_CODE__', '')
if self._service is not None:
resolved = self.resolve_children_to_string(client_context)
YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved)
bot_service = ServiceFactory.get_service(self.service)
response = bot_service.ask_question(client_context, resolved)
YLogger.debug(client_context, "SRAIX service [%s] return [%s]", self.service, response)
status_code = ''
try:
status_code = bot_service.get_status_code()
except NotImplementedError:
pass
if conversation.has_current_question() is True:
conversation.current_question().set_property('__SUBAGENT_STATUS_CODE__', status_code)
if response is not None:
if conversation.has_current_question() is False:
if self.default is not None:
response = self.default
else:
variableName = "__SUBAGENT__"
if response != '':
try:
response_json = json.loads(response)
save_dic = {self.service: response_json}
conversation.current_question().set_property(variableName, json.dumps(save_dic))
except Exception:
variableName += ".%s" % self.service
conversation.current_question().set_property(variableName, response)
else:
if self.default is not None:
response = self.default
variableName += ".%s" % self.service
conversation.current_question().set_property(variableName, response)
return response
elif self._botName is not None:
response = self._published_Bot_interface(client_context)
return response
elif self._host is not None:
response = self._published_REST_interface(client_context)
return response
else:
YLogger.debug(client_context, "Sorry SRAIX does not currently have an implementation for [%s]", self._service)
return ''
def test_call_PublishedBot_topic(self):
service_config = BrainServiceConfiguration("__PUBLISHEDBOT__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDBOT__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._botId = "testBot"
node.append(TemplateWordNode("Hello"))
root.append(node)
conversation = self._client_context.bot.get_conversation(
self._client_context)
conversation.set_property('topic', 'morning')
self.assertEqual("asked", node.resolve(self._client_context))
node._topic = TemplateWordNode("evening")
self.assertEqual("asked", node.resolve(self._client_context))
def test_call_PublishedBot(self):
service_config = BrainServiceConfiguration("__PUBLISHEDBOT__")
service_config._classname = 'programytest.services.test_service.MockService'
brain_config = BrainConfiguration()
brain_config.services._services['__PUBLISHEDBOT__'] = service_config
ServiceFactory.preload_services(brain_config.services)
root = TemplateNode()
node = TemplateSRAIXNode()
node._botName = "testbot"
node._locale = TemplateWordNode('ja-JP')
node._time = TemplateWordNode('2019-01-01T00:00:00+09:00')
node._userId = TemplateWordNode('1234567890')
node._topic = TemplateWordNode('*')
node._deleteVariable = TemplateWordNode('false')
node._metadata = TemplateWordNode('1234567890')
node._config = TemplateWordNode('{"config":{"logLevel":"debug"}}')
node.append(TemplateWordNode("Hello"))
root.append(node)
self.set_collection_botnames()
self.assertEqual("asked", node.resolve(self._client_context))
conversation = self._client_context.bot.get_conversation(
self._client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(
self._client_context, "Hello",
self._client_context.bot.sentence_splitter)
conversation.record_dialog(question)
self.assertIsNotNone(conversation.current_question())
service = ServiceFactory.get_service("__PUBLISHEDBOT__")
service.set_response('{"response": "asked"}')
self.assertEqual("asked", node.resolve(self._client_context))
self.assertEqual('{"testbot": {"response": "asked"}}',
question.property('__SUBAGENT_EXTBOT__'))
def resolve_to_string(self, bot, clientid):
resolved = self.resolve_children_to_string(bot, clientid)
if logging.getLogger().isEnabledFor(logging.DEBUG):
logging.debug("[%s] resolved to [%s]", self.to_string(), resolved)
if self._service is not None:
bot_service = ServiceFactory.get_service(self._service)
response = bot_service.ask_question(bot, clientid, resolved)
if logging.getLogger().isEnabledFor(logging.DEBUG):
logging.debug("SRAIX service [%s] return [%s]", self._service,
response)
return response
else:
if logging.getLogger().isEnabledFor(logging.ERROR):
logging.error(
"Sorry SRAIX does not currently have an implementation for [%s]",
self._service)
return ""
def load_services(self, configuration):
ServiceFactory.preload_services(configuration.services)
def load_services(self, configuration):
ServiceFactory.preload_services(configuration.services)
def _published_Bot_interface(self, client_context):
self.locale = None
self.time = None
self.userId = None
self.topic = None
self.deleteVariable = None
self.metadata = None
self.config = None
conversation = client_context.bot.get_conversation(client_context)
if self._locale is not None:
self.locale = self._locale.resolve(client_context)
if self._time is not None:
self.time = self._time.resolve(client_context)
if self._userId is not None:
self.userId = self._userId.resolve(client_context)
if self._topic is not None:
self.topic = self._topic.resolve(client_context)
if self._topic is None or self.topic == '*':
if conversation.property('topic') is not '*':
self.topic = conversation.property('topic')
if self._deleteVariable is None:
self.deleteVariable = None
else:
self.deleteVariable = self._deleteVariable.resolve(client_context)
if self.deleteVariable.upper() == 'TRUE':
self.deleteVariable = True
else:
self.deleteVariable = False
if self._metadata is not None:
self.metadata = self._metadata.resolve(client_context)
if self._config is not None:
shift_text = self._config.resolve(client_context)
self.config = self._delete_shift_code(shift_text)
resolved = self.resolve_children_to_string(client_context)
YLogger.debug(client_context, "[%s] resolved to [%s]",
self.to_string(), resolved)
bot_service = ServiceFactory.get_service(self.SERVICE_PUBLISHED_BOT)
bot_service.botId = self.botId
bot_service.botHost = self.botHost
bot_service.locale = self.locale
bot_service.time = self.time
bot_service.userId = self.userId
bot_service.topic = self.topic
bot_service.deleteVariable = self.deleteVariable
bot_service.metadata = self.metadata
bot_service.config = self.config
response = bot_service.ask_question(client_context, resolved)
YLogger.debug(client_context, "SRAIX botid [%s] return [%s]",
self._botId, response)
status_code = ''
try:
status_code = bot_service.get_status_code()
except NotImplementedError:
pass
if conversation.has_current_question() is True:
conversation.current_question().set_property(
'__SUBAGENT_STATUS_CODE__', status_code)
if response is not None:
if conversation.has_current_question() is False:
if response == '' and self.default is not None:
response = self.default
else:
variableName = "__SUBAGENT_EXTBOT__"
if response != '':
try:
response_dic = json.loads(response)
save_dic = {self._botId: response_dic}
conversation.current_question().set_property(
variableName, json.dumps(save_dic))
response_data = response_dic['response']
if type(response_data) is dict:
response = json.dumps(response_data)
else:
response = response_data
except Exception:
if self.default is not None:
response = self.default
else:
response = ''
else:
if self.default is not None:
response = self.default
variableName += ".%s" % self._botId
conversation.current_question().set_property(
variableName, response)
return response
def parse_expression(self, graph, expression):
mode_count = 0
if 'method' in expression.attrib:
YLogger.warning(self, "'method' attrib not supported in sraix, moved to config, see documentation")
if 'query' in expression.attrib:
YLogger.warning(self, "'query' attrib not supported in sraix, moved to config, see documentation")
if 'header' in expression.attrib:
YLogger.warning(self, "'header' attrib not supported in sraix, moved to config, see documentation")
if 'body' in expression.attrib:
YLogger.warning(self, "'body' attrib not supported in sraix, moved to config, see documentation")
if 'botName' in expression.attrib:
bot_name = expression.attrib['botName']
if graph.aiml_parser.brain.botnames.botInfo(bot_name) is None:
raise ParserException("BotName[%s] not found" % bot_name, xml_element=expression, nodename='sraix')
mode_count += 1
self._botName = bot_name
if 'locale' in expression.attrib:
YLogger.warning(self, "'locale' attrib not supported in sraix, moved to config, see documentation")
if 'time' in expression.attrib:
YLogger.warning(self, "'time' attrib not supported in sraix, moved to config, see documentation")
if 'userId' in expression.attrib:
YLogger.warning(self, "'userId' attrib not supported in sraix, moved to config, see documentation")
if 'topic' in expression.attrib:
YLogger.warning(self, "'topic' attrib not supported in sraix, moved to config, see documentation")
if 'deleteVariable' in expression.attrib:
YLogger.warning(self, "'deleteVariable' attrib not supported in sraix, moved to config, see documentation")
if 'metadata' in expression.attrib:
YLogger.warning(self, "'metadata' attrib not supported in sraix, moved to config, see documentation")
if 'config' in expression.attrib:
YLogger.warning(self, "'config' attrib not supported in sraix, moved to config, see documentation")
if 'service' in expression.attrib:
service_name = expression.attrib['service']
if ServiceFactory.service_exists(service_name) is False:
raise ParserException("Service[%s] not found" % service_name, xml_element=expression, nodename='sraix')
mode_count += 1
self._service = service_name
if 'default' in expression.attrib:
self._default = expression.attrib['default']
head_text = self.get_text_from_element(expression)
self.parse_text(graph, head_text)
for child in expression:
tag_name = TextUtils.tag_from_text(child.tag)
if tag_name == 'host':
mode_count += 1
self._host = self._parse_template_node(graph, child, 'host', False)
elif tag_name == 'method':
self._method = self._parse_template_node(graph, child, 'method', False)
elif tag_name == 'query':
self._query = self._parse_template_node(graph, child, 'query', True)
elif tag_name == 'header':
self._header = self._parse_template_node(graph, child, 'header', True)
elif tag_name == 'body':
self._body = self._parse_template_node(graph, child, 'body', False)
elif tag_name == 'botName':
YLogger.warning(self, "'botName' element not supported in sraix, moved to config, see documentation")
elif tag_name == 'locale':
self._locale = self._parse_template_node(graph, child, 'locale', False)
elif tag_name == 'time':
self._time = self._parse_template_node(graph, child, 'time', False)
elif tag_name == 'userId':
self._userId = self._parse_template_node(graph, child, 'userId', False)
elif tag_name == 'topic':
self._topic = self._parse_template_node(graph, child, 'topic', False)
elif tag_name == 'deleteVariable':
self._deleteVariable = self._parse_template_node(graph, child, 'deleteVariable', False)
elif tag_name == 'metadata':
self._metadata = self._parse_template_node(graph, child, 'metadata', False)
elif tag_name == 'config':
self._config = self._parse_template_node(graph, child, 'config', True)
elif tag_name == 'service':
YLogger.warning(self, "'service' element not supported in sraix, moved to config, see documentation")
elif tag_name == 'default':
YLogger.warning(self, "'default' element not supported in sraix, moved to config, see documentation")
else:
graph.parse_tag_expression(child, self)
tail_text = self.get_tail_from_element(child)
self.parse_text(graph, tail_text)
if mode_count == 0:
raise ParserException("Missing type attribute or host element", xml_element=expression, nodename='sraix')
elif mode_count > 1:
raise ParserException("Node has Multiple type attribute or host element", xml_element=expression, nodename='sraix')
def _published_REST_interface(self, client_context):
self.host = None
self.method = None
self.query = None
self.header = None
self.body = None
if self._host is not None:
self.host = self._host.resolve(client_context)
if self._method is not None:
self.method = self._method.resolve(client_context)
if self._query is not None:
shift_text = self._query.resolve(client_context)
self.query = self._delete_shift_code(shift_text)
if self._header is not None:
shift_text = self._header.resolve(client_context)
self.header = self._delete_shift_code(shift_text)
if self._body is not None:
self.body = self._body.resolve(client_context)
resolved = self.resolve_children_to_string(client_context)
YLogger.debug(client_context, "[%s] resolved to [%s]",
self.to_string(), resolved)
error_msg = None
if self._template is None:
exec_params = RestParameters(self.host)
if exec_params.host is None:
error_msg = "sraix subagent-rest : invalid host parameter [%s]" % self.host
if error_msg is None and self.body is not None:
exec_params.set_body(self.body)
if error_msg is None and self.method is not None:
if exec_params.set_method(self.method) is False:
error_msg = "sraix subagent-rest : invalid method parameter [%s]" % self.method
if error_msg is None and self.query is not None:
if exec_params.set_query(self.query) is False:
error_msg = "sraix subagent-rest : invalid query parameter [%s]" % self.query
if error_msg is None and self.header is not None:
if exec_params.set_header(self.header) is False:
error_msg = "sraix subagent-rest : invalid locale parameter [%s]" % self.header
else:
restParams = client_context.brain.rest_templates.rest_template(
self._template)
if restParams is None:
error_msg = "sraix subagent-rest : REST-Template[%s] not found" % self._template
YLogger.debug(client_context, error_msg)
raise Exception(error_msg)
exec_params = copy.copy(restParams)
if self.host is not None:
if exec_params.change_host(self.host) is False:
error_msg = "sraix subagent-rest : invalid host parameter [%s]" % self.host
if error_msg is None and self.body is not None:
exec_params.join_body(self.body)
if error_msg is None and self.method is not None:
if exec_params.set_method(self.method) is False:
error_msg = "sraix subagent-rest : invalid method parameter [%s]" % self.method
if error_msg is None and self.query is not None:
if exec_params.join_query(self.query) is False:
error_msg = "sraix subagent-rest : invalid query parameter [%s]" % self.query
if error_msg is None and self.header is not None:
if exec_params.join_header(self.header) is False:
error_msg = "sraix subagent-rest : invalid header parameter [%s]" % self.header
if error_msg is not None:
YLogger.debug(client_context, error_msg)
raise Exception(error_msg)
rest_service = ServiceFactory.get_service(self.SERVICE_PUBLISHED_REST)
rest_service.params = exec_params
if self._timeout is None:
timeout = self.SRAIX_DEFAULT_TIMEOUT
else:
timeout = self._timeout
response = rest_service.ask_question(client_context, resolved, timeout)
YLogger.debug(client_context, "SRAIX host [%s] return [%s]",
exec_params.host, response)
conversation = client_context.bot.get_conversation(client_context)
status_code = ''
latency = ''
try:
status_code = rest_service.get_status_code()
except NotImplementedError:
pass
try:
latency = rest_service.get_latency()
except NotImplementedError:
pass
if conversation.has_current_question() is True:
conversation.current_question().set_property(
'__SUBAGENT_STATUS_CODE__', status_code)
conversation.current_question().set_property(
'__SUBAGENT_LATENCY__', latency)
if response is not None:
if response == '' and self.default is not None:
response = self.default
variableName = "__SUBAGENT_BODY__"
if conversation.has_current_question() is True:
conversation.current_question().set_property(
variableName, response)
return response
def _published_Bot_interface(self, client_context):
self.locale = None
self.time = None
self.userId = None
self.topic = None
self.deleteVariable = None
self.metadata = None
self.config = None
if self._userId is not None:
self.userId = self._userId.resolve(client_context)
if self._locale is not None:
self.locale = self._locale.resolve(client_context)
if self._time is not None:
self.time = self._time.resolve(client_context)
if self._topic is not None:
self.topic = self._topic.resolve(client_context)
if self._deleteVariable is not None:
self.deleteVariable = self._deleteVariable.resolve(client_context)
if self._config is not None:
shift_text = self._config.resolve(client_context)
self.config = self._delete_shift_code(shift_text)
if self._metadata is not None:
self.metadata = self._metadata.resolve(client_context)
bot_service = ServiceFactory.get_service(self.SERVICE_PUBLISHED_BOT)
botInfo = client_context.brain.botnames.botInfo(self.botName)
if botInfo is None:
error_msg = "sraix subagent-bot : botName[%s] not found" % self.botName
YLogger.debug(client_context, error_msg)
raise Exception(error_msg)
conversation = client_context.bot.get_conversation(client_context)
exec_botInfo = copy.copy(botInfo)
error_msg = None
if self.userId is None or self.userId == '':
self.userId = conversation.current_question().property('__USER_USERID__')
if self.userId is None or self.userId == '':
error_msg = "sraix subagent-bot : no userId parameter"
if error_msg is None and self.locale is not None:
if exec_botInfo.set_locale(self.locale) is False:
error_msg = "sraix subagent-bot : invalid locale parameter [%s]" % self.locale
if error_msg is None and self.time is not None:
if exec_botInfo.set_time(self.time) is False:
error_msg = "sraix subagent-bot : invalid time parameter [%s]" % self.time
if error_msg is None and self.topic is not None:
if exec_botInfo.set_topic(self.topic) is False:
error_msg = "sraix subagent-bot : invalid topic parameter [%s]" % self.topic
if error_msg is None and self.deleteVariable is not None:
if exec_botInfo.set_deleteVariable(self.deleteVariable) is False:
error_msg = "sraix subagent-bot : invalid deleteVariable parameter [%s]" % self.deleteVariable
if error_msg is None and self.config is not None:
if exec_botInfo.set_config(self.config) is False:
error_msg = "sraix subagent-bot : invalid config parameter [%s]" % self.config
if error_msg is None and self.metadata is not None:
if exec_botInfo.join_metadata(self.metadata) is False:
error_msg = "sraix subagent-bot : invalid metadata parameter [%s]" % self.metadata
if error_msg is not None:
YLogger.debug(client_context, error_msg)
raise Exception(error_msg)
resolved = self.resolve_children_to_string(client_context)
YLogger.debug(client_context, "[%s] resolved to [%s]", self.to_string(), resolved)
bot_service.botInfo = exec_botInfo
bot_service.userId = self.userId
response = bot_service.ask_question(client_context, resolved)
YLogger.debug(client_context, "SRAIX botName [%s] return [%s]", self._botName, response)
status_code = ''
try:
status_code = bot_service.get_status_code()
except NotImplementedError:
pass
if conversation.has_current_question() is True:
conversation.current_question().set_property('__SUBAGENT_STATUS_CODE__', status_code)
if response is not None:
if conversation.has_current_question() is False:
if response == '' and self.default is not None:
response = self.default
else:
variableName = "__SUBAGENT_EXTBOT__"
if response != '':
try:
response_dic = json.loads(response)
save_dic = {self._botName: response_dic}
conversation.current_question().set_property(variableName, json.dumps(save_dic, ensure_ascii=False))
response_data = response_dic['response']
if type(response_data) is dict:
response = json.dumps(response_data, ensure_ascii=False)
else:
response = response_data
except Exception:
if self.default is not None:
response = self.default
else:
response = ''
else:
if self.default is not None:
response = self.default
variableName += ".%s" % self._botName
conversation.current_question().set_property(variableName, response)
return response
def load_services(self, brain_configuration):
ServiceFactory.preload_services(brain_configuration.services)
