def receive_message():
try:
return WEB_CLIENT.receive_message(request)
except Exception as e:
outputLog(None, "Error receiving webchat message", e)
YLogger.exception(None, "Web client error", e)
return "500"
def receive_message():
try:
return ALEXA_CLIENT.receive_message(request)
except Exception as e:
outputLog(None, "Alexa failed receiving message", e)
YLogger.exception(None, "Alexa Error", e)
def extract_list_info(self, tag):
items = []
for child in tag.children:
if child.name is None:
pass
elif child.name == 'item':
for childs_child in child.children:
if isinstance(childs_child, Tag):
items.append(self.extract_item_info(childs_child))
elif isinstance(childs_child, NavigableString):
childs_child_text = childs_child.strip()
if childs_child_text:
items.append({'type': 'text', 'text': childs_child_text})
else:
outputLog(self, "Unknown list tag %s" % child.name)
data = {'type': 'list', 'items': items}
self.extract_class_attr(tag, data)
self.extract_id_attr(tag, data)
return data
def _upload_users(self, yaml_data, verbose=False):
if 'users' in yaml_data:
for user_name in yaml_data['users'].keys():
auth_user = AuthoriseUser(name=user_name)
result = self.storage_engine.session.add(auth_user)
yaml_obj = yaml_data['users'][user_name]
if 'roles' in yaml_obj:
roles_list = yaml_obj['roles']
splits = roles_list.split(",")
for role_name in splits:
role_name = role_name.strip()
user_role = UserRole(user=user_name, role=role_name)
if verbose is True:
outputLog(self, user_role)
self.storage_engine.session.add(user_role)
if 'groups' in yaml_obj:
groups_list = yaml_obj['groups']
splits = groups_list.split(",")
for group_name in splits:
group_name = group_name.strip()
user_group = UserGroup(user=user_name,
group=group_name)
if verbose is True:
outputLog(self, user_group)
self.storage_engine.session.add(user_group)
def _handle_intent_request(self, client_context, request):
if 'intent' not in request:
raise Exception("Invalid request, intent missing!")
intent = request['intent']
if 'name' not in intent:
raise Exception("Invalid intent, name missing!")
intent_name = intent['name']
outputLog(self, "Handling [%s] intent..." % intent_name)
if intent_name == 'AMAZON.CancelIntent':
return self._handle_cancel_request(client_context,
self._should_leave(intent_name))
elif intent_name == 'AMAZON.StopIntent':
return self._handle_stop_request(client_context,
self._should_leave(intent_name))
elif intent_name == 'AMAZON.HelpIntent':
return self._handle_help_request(client_context)
else:
value = self._extract_question(intent)
question = self._add_intent(intent_name, value)
return self._handle_reply_request(client_context, question)
def poll_and_answer(self):
running = True
sleepy_time = self._configuration.client_configuration.polling_interval
try:
if self._configuration.client_configuration.follow_followers is True:
YLogger.debug(self, "Following followers")
self._follow_followers()
if self._configuration.client_configuration.respond_to_directs:
YLogger.debug(self, "Checking direct messages")
self._check_directs()
YLogger.debug(self, "Sleeping for %d at %s" %(sleepy_time, datetime.datetime.now().strftime("%H:%M:%S")))
except KeyboardInterrupt:
running = False
except RateLimitError:
outputLog(self, "Rate limit exceeded, check logs!")
YLogger.error(self, "Rate limit exceeded, sleeping for %d seconds", self._rate_limit_sleep)
sleepy_time = self._rate_limit_sleep
except Exception as excep:
YLogger.exception(self, "Poll and answer error", excep)
time.sleep(sleepy_time)
return running
def load_storage(self):
self._storage = StorageFactory()
if self.configuration.client_configuration.storage is not None:
YLogger.debug(None, "Loading Storage Factory")
self._storage.load_engines_from_config(self.configuration.client_configuration.storage)
else:
outputLog(self, "No storage defined!")
def receive_message():
try:
return GOOGLE_CLIENT.receive_message(request)
except Exception as e:
outputLog(None, "Failure receiving message", e)
YLogger.exception(None, "Google Error", e)
def extract_button_info(self, tag):
text = None
url = None
postback = None
for child in tag.children:
if child.name is None:
pass
elif child.name == 'text':
text = child.text
elif child.name == 'url':
url = child.text
elif child.name == 'postback':
postback = child.text
else:
outputLog(self, "Unknown button tag %s" % child.name)
data = {"type": "button", "text": text, "url": url, "postback": postback}
self.extract_class_attr(tag, data)
self.extract_id_attr(tag, data)
return data
def extract_card_info(self, tag):
image = None
title = None
subtitle = None
buttons = []
for child in tag.children:
if child.name is None:
pass
elif child.name == 'image':
image = child.text
elif child.name == 'title':
title = child.text
elif child.name == 'subtitle':
subtitle = child.text
elif child.name == 'button':
button = self.extract_button_info(child)
buttons.append(button)
else:
outputLog(self, "Unknown card tag [%s]" % child.name)
data = {"type": "card", "image": image, "title": title, "subtitle": subtitle, "buttons": buttons}
self.extract_class_attr(tag, data)
self.extract_id_attr(tag, data)
return data
def ping_service(ping_app: Flask, config: PingResponderConfig):
if config.ssl_cert_file is not None and \
config.ssl_key_file is not None:
context = (config.ssl_cert_file, config.ssl_key_file)
outputLog(None, "Healthcheck running in https mode")
try:
ping_app.run(host=config.host,
port=config.port,
debug=config.debug,
ssl_context=context)
except Exception as error:
print("Healthcheck failed to start:", error)
else:
outputLog(None, "Healthcheck running in http mode, careful now !")
try:
ping_app.run(host=config.host,
port=config.port,
debug=config.debug)
except Exception as error:
print("Healthcheck failed to start:", error)
def init_ping_response(ping_responder):
if ping_responder.config.host is None:
YLogger.info(None, "No REST configuration for ping responder")
outputLog(None,
"Healthcheck now running as part of REST Service...")
return
outputLog(None, "Healthcheck now running as separate REST Service...")
ping_app = Flask(ping_responder.config.name)
if ping_responder.config.url is not None:
@ping_app.route(ping_responder.config.url, methods=['GET'])
def ping(): # pylint: disable=unused-variable
return jsonify(ping_responder.ping())
if ping_responder.config.shutdown is not None:
@ping_app.route(ping_responder.config.shutdown, methods=['GET'])
def shutdown(): # pylint: disable=unused-variable
ping_responder.stop_ping_service()
return 'Server shutting down...'
ping_responder.start_ping_service(ping_app)
def __init__(self, argument_parser=None):
self._host = None
self._port = None
self._queue = None
self._max_buffer = None
self._server_socket = None
self._client_connection = None
EventBotClient.__init__(self, "Socket", argument_parser)
if self._host is not None and \
self._port is not None and \
self._queue is not None:
outputLog(
self, "TCP Socket Client server now listening on %s:%d" %
(self._host, self._port))
self._server_socket = self.create_socket_connection(
self._host, self._port, self._queue, self._max_buffer)
self._renderer = JSONRenderer(self)
else:
outputLog(
self,
"TCP Socket Client configuration not defined, unable to create socket!"
)
def write_yaml(self, filename, data):
outputLog(self, "Writing new config file to [%s]" % filename)
try:
with open(filename, 'w') as outfile:
yaml.dump(data, outfile, default_flow_style=False)
except Exception as excep:
outputLog(self, "Failed to write new config file [%s] - [%s]" % (filename, str(excep)))
def __init__(self, argument_parser=None):
FlaskRestBotClient.__init__(self, 'alexa', argument_parser)
YLogger.debug(self, "Alexa Client is running....")
self._load_intent_mappings()
outputLog(self, "Alexa Client loaded")
def connect(self):
if self._telegram_token is not None:
self.create_updater(self._telegram_token)
self.register_handlers()
return True
outputLog(self, "No telegram token defined, unable to connect")
return False
def _process_config_line(self, line, verbose):
line = line.strip()
if line[0] != '#':
processor = self._get_entity(line)
self.storage_engine.session.add(processor)
if verbose is True:
outputLog(self, line)
return True
return False
def process_line(self, name, fields, verbose=False):
if fields and len(fields) == 2:
result = self.add_to_lookup(fields[0].upper(), fields[1].upper())
if verbose is True:
outputLog(
self, "Key=[%s], Value={%s]" %
(fields[0].upper(), fields[1].upper()))
return result
return False
def __init__(self, argument_parser=None):
self._access_token = None
FlaskRestBotClient.__init__(self, 'facebook', argument_parser)
YLogger.debug(self, "Facebook Client is running....")
self._facebook_bot = self.create_facebook_bot()
outputLog(self, "Facebook Client loaded")
def unregister_with_healthchecker(self):
if self.config.unregister is not None:
try:
url = "%s?name=%s" % (self.config.unregister, self._client.id)
requests.get(url)
except Exception as e:
outputLog(self, e)
YLogger.error(None, "Unable to unregister with healthchecker")
def __init__(self, argument_parser=None):
FlaskRestBotClient.__init__(self, 'twilio', argument_parser)
YLogger.debug(self, "Twilio Client is running....")
self.get_license_keys()
self._twilio_client = self.create_twilio_client()
outputLog(self, "Twilio Client loaded")
def to_aiml(self):
if self.actiontype == 'web_url':
aiml = "<link>"
aiml += "<text>%s</text>" % self.label
if self.payload is not None:
aiml += "<url>%s</url>" % self.payload
aiml += "</link>"
return aiml
outputLog(None, "Unknown Default Action type [%s]" % self.actiontype)
return None
def to_aiml(self):
if self.actiontype == 'web_url':
aiml = "<button>"
aiml += "<text>%s</text>" % self.label
if self.payload is not None:
aiml += "<url>%s</url>" % self.payload
aiml += "</button>"
return aiml
outputLog(self, "Unknown Button type [%s]" % self.actiontype)
return None
def display_debug_info(self):
if self._errors is not None:
outputLog(
self,
"Found a total of %d errors in your grammars, check your errors store"
% len(self._errors))
if self._duplicates is not None:
outputLog(
self,
"Found a total of %d duplicates in your grammars, check your duplicates store"
% len(self._duplicates))
def _handle_launch_request(self, client_context):
outputLog(self, "Handling launch...")
if self.configuration.client_configuration.launch_srai is not None:
reply = self._ask_question(
client_context,
self.configuration.client_configuration.launch_srai)
else:
reply = self.configuration.client_configuration.launch_text
return self._create_response(reply)
def initiate_logging(self, arguments):
if arguments.logging is not None:
try:
with open(arguments.logging, 'r+', encoding="utf-8") as yml_data_file:
logging_config = yaml.load(yml_data_file, Loader=yaml.FullLoader)
logging.config.dictConfig(logging_config)
YLogger.info(self, "Now logging under configuration")
except Exception as excep:
YLogger.exception(self, "Failed to open logging configuration [%s]", excep, arguments.logging)
else:
outputLog(self, "Warning. No logging configuration file defined, using defaults...")
def load_qandas(self, defaults_qandas):
if self.arguments.args.qandas is not None:
try:
reader = CSVFileReader(self.arguments.args.qandas)
reader.process_lines("qandas", self)
return
except Exception as excep:
outputLog(
self,
"Using q&a defaults, as unable to load file [%s], reason[%s]"
% (self.arguments.args.qandas, str(excep)))
self._qandas = defaults_qandas[:]
def run(self, app=None):
outputLog(
self, "%s Client running on http://%s:%s" %
(self.id, self.configuration.client_configuration.host,
self.configuration.client_configuration.port))
self.startup()
if self.configuration.client_configuration.debug is True:
outputLog(self, "%s Client running in debug mode" % self.id)
if self.configuration.client_configuration.ssl_cert_file is not None and \
self.configuration.client_configuration.ssl_key_file is not None:
context = (self.configuration.client_configuration.ssl_cert_file,
self.configuration.client_configuration.ssl_key_file)
outputLog(self, "%s Client running in https mode" % self.id)
app.run(host=self.configuration.client_configuration.host,
port=self.configuration.client_configuration.port,
debug=self.configuration.client_configuration.debug,
ssl_context=context)
else:
outputLog(
self,
"%s Client running in http mode, careful now !" % self.id)
app.run(host=self.configuration.client_configuration.host,
port=self.configuration.client_configuration.port,
debug=self.configuration.client_configuration.debug)
self.shutdown()
def run(args=None):
parser = ConfigurationWriter.create_arguments()
try:
app = ConfigurationWriter()
if args is None:
app.execute(parser.parse_args())
else:
app.execute(args)
except Exception as excep:
outputLog(None, "Error: [%s]" % str(excep))
parser.print_help()
def _load_services_from_file(self, filename, verbose):
with open(filename, "r+") as file:
yaml_data = yaml.load(file, Loader=yaml.FullLoader)
service_data = yaml_data['service']
service = self._get_entity(service_data)
self.storage_engine.session.add(service)
if verbose is True:
outputLog(
self, "[%s] = [%s]" %
(service_data['name'], service_data['service_class']))
return True
