def __add_on_connection_close_callback(self):
"""This method adds an on close callback that will be invoked by pika
when RabbitMQ closes the connection to the publisher unexpectedly.
"""
log_debug('Adding connection close callback')
self._connection.add_on_close_callback(self.__on_connection_closed)
def get_athlete(name_athlete):
"""
Get info of athlete
:param name_athlete: str
:return:
"""
if not name_athlete:
return 'nhập tên vận động viên'
connection = Connection().get_connection()
try:
cursor = connection.cursor() # prepare an object cursor
query = """
SELECT * FROM athlete WHERE name='{}';
""".format(name_athlete.strip().lower())
log_debug(query)
cursor.execute(query)
result = cursor.fetchall()
result = answer_athele(name_athlete, result)
# cursor.close()
# del cursor
# connection.close()
return result
except MySQLError as ex:
connection.close()
log_error("Can't get if of athlete with name - {}: {}".format(name_athlete, ex))
return []
def check_exists_create(fb_id, page_id):
"""
Check user is exists, if not create new one
:param fb_id: str
:param page_id: str
:return:
"""
connection = Connection().get_connection()
try:
cursor = connection.cursor() # prepare an object cursor
query = """
SELECT * FROM follower WHERE fb_id={};
""".format(fb_id)
log_debug(query)
cursor.execute(query)
result = cursor.fetchone()
if not result:
query = """
INSERT INTO follower (fb_id, page_id)
VALUES ('{}', '{}');
""".format(fb_id, page_id)
log_debug(query)
cursor.execute(query)
cursor.close()
del cursor
connection.commit()
# connection.close()
except MySQLError as ex:
# connection.close()
log_error("Can't check exists then create one: {}".format(ex))
def __add_on_channel_close_callback(self):
"""This method tells pika to call the on_channel_closed method if
RabbitMQ unexpectedly closes the channel.
"""
log_debug('Adding channel close callback')
self._channel.add_on_close_callback(self.__on_channel_closed)
def convert_facebook(self, recipient_id: str = "", content: str = '', obj: list = None):
"""
message send by format facebook
:return:
"""
page_id = recipient_id.split("_")[1]
fb_id = recipient_id.split("_")[0]
data = json.dumps({
"recipient": {
"id": fb_id
},
"message": {
"attachment": {
"type": "image",
"payload": {
"url": content,
"is_reusable": True
}
}
}
})
pages = self.connect.get("pages")
if pages:
pages = json.loads(pages)
access_token = [_.get("page_token") for _ in pages if
str(_.get("page_id")) == page_id][0]
params = {
"access_token": "{}".format(access_token)
}
request = requests.post(FACEBOOK_API_ENDPOINT + "me/messages", params=params,
headers=self.headers,
data=data)
log_debug('############## %s ##############' % request.text)
else:
log_debug("############## Can't get pages ##############")
def __add_on_cancel_callback(self):
"""Add a callback that will be invoked if RabbitMQ cancels the consumer
for some reason. If RabbitMQ does cancel the consumer,
on_consumer_cancelled will be invoked by pika.
"""
log_debug('Adding consumer cancellation callback')
self._channel.add_on_cancel_callback(self.__on_consumer_cancelled)
def __open_channel(self):
"""Open a new channel with RabbitMQ by issuing the Channel.Open RPC
command. When RabbitMQ responds that the channel is open, the
on_channel_open callback will be invoked by pika.
"""
log_debug('Creating a new channel')
self._connection.channel(on_open_callback=self.__on_channel_open)
def convert_zalo(self,
recipient_id: str = "",
content: str = "",
obj: list = None):
"""
message send by format facebook
:return:
"""
log_debug(recipient_id)
def __on_exchange_declareok(self, unused_frame):
"""Invoked by pika when RabbitMQ has finished the Exchange.Declare RPC
command.
:param pika.Frame.Method unused_frame: Exchange.DeclareOk response frame
"""
log_debug('Exchange declared')
self.__setup_queue(self.QUEUE)
def __setup_queue(self, queue_name):
"""Setup the queue on RabbitMQ by invoking the Queue.Declare RPC
command. When it is complete, the on_queue_declareok method will
be invoked by pika.
:param str|unicode queue_name: The name of the queue to declare.
"""
log_debug('Declaring queue {}'.format(queue_name))
self._channel.queue_declare(self.__on_queue_declareok, queue_name)
def __on_connection_open(self, unused_connection):
"""This method is called by pika once the connection to RabbitMQ has
been established. It passes the handle to the connection object in
case we need it, but in this case, we'll just mark it unused.
:type unused_connection: pika.SelectConnection
"""
log_debug('Connection opened')
self.__add_on_connection_close_callback()
self.__open_channel()
def __on_consumer_cancelled(self, method_frame):
"""Invoked by pika when RabbitMQ sends a Basic.Cancel for a consumer
receiving messages.
:param pika.frame.Method method_frame: The Basic.Cancel frame
"""
log_debug(
'Consumer was cancelled remotely, shutting down: {}'.format(method_frame))
if self._channel:
self._channel.close()
def __setup_exchange(self, exchange_name):
"""Setup the exchange on RabbitMQ by invoking the Exchange.Declare RPC
command. When it is complete, the on_exchange_declareok method will
be invoked by pika.
:param str|unicode exchange_name: The name of the exchange to declare
"""
log_debug('Declaring exchange {}'.format(exchange_name))
self._channel.exchange_declare(self.__on_exchange_declareok, exchange_name,
self.EXCHANGE_TYPE)
def __on_channel_open(self, channel):
"""This method is invoked by pika when the channel has been opened.
The channel object is passed in so we can make use of it.
Since the channel is now open, we'll declare the exchange to use.
:param pika.channel.Channel channel: The channel object
"""
log_debug('Channel opened')
self._channel = channel
self.__add_on_channel_close_callback()
self.__setup_exchange(self.EXCHANGE)
self.__start_consuming()
def __start_consuming(self):
"""This method sets up the consumer by first calling
add_on_cancel_callback so that the object is notified if RabbitMQ
cancels the consumer. It then issues the Basic.Consume RPC command
which returns the consumer tag that is used to uniquely identify the
consumer with RabbitMQ. We keep the value to use it when we want to
cancel consuming. The on_message method is passed in as a callback pika
will invoke when a message is fully received.
"""
log_debug('Issuing consumer related RPC commands')
self.__add_on_cancel_callback()
self._consumer_tag = self._channel.basic_consume(
self.__on_message, self.QUEUE)
def handle(self, data):
"""
Handle message from user
"""
# endpoint for processing incoming messaging events
# log_debug(data)
log_debug(data)
if data.get("source") == "facebook":
if data.get("object") == "page":
for entry in data.get("entry"):
for messaging_event in entry['messaging']:
log_debug('handle - souce = "facebook"')
log_debug('+++++++++++++++++++++++++++++++++++++++')
self.handle_message_facebook(messaging_event)
return
if data.get("source") == "zalo":
if data.get("event_name") == "user_send_text":
if data.get('message'):
log_debug('handle - source = "zalo"')
log_debug('+++++++++++++++++++++++++++++++++++++++')
self.handle_message_zalo(data)
return
def get_ranking():
"""
Get ranking
:return:
"""
connection = Connection().get_connection()
try:
cursor = connection.cursor() # prepare an object cursor
query = """
SELECT * FROM ranking ORDER BY position ASC;
"""
log_debug(query)
cursor.execute(query)
result = cursor.fetchall()
result = answer_ranking(result)
# cursor.close()
# del cursor
# connection.close()
return result
except MySQLError as ex:
connection.close()
log_error("Can't get ranking: {}".format(ex))
return []
def get_snips(self, sentence):
"""
get snips in sentence
:param sentence: str
:return:
{
"intent": "schedule",
"sentence": "lịch thi đấu ngày mai",
"entity": {
date_start: ngay mai
}
}
"""
res = dict()
log_debug('############# PREPROCESSING ##############')
sentence = unicodedata.normalize("NFC", sentence.lower())
log_debug("Sentence after preprocessing: {}".format(sentence))
log_debug('############# NER ##############')
entity = self.nlu.parse_nlu(sentence)
log_debug("Entity: {}".format(entity))
sentence = sentence.replace(
entity["is_name"][0],
'vận động viên') if entity["is_name"] else sentence
sentence = sentence.replace(entity["is_name"][0], entity["is_name"][0] + ' bộ môn') if \
entity["is_name"] else sentence
log_debug('############# CLASSIFICATION ##############')
intent = self.intent.predict(sentence, entity)
log_debug("Intent: {}".format(intent))
res["sentence"] = sentence
res["entity"] = entity
res["intent"] = intent
return res
def convert_facebook(self,
recipient_id: str = "",
content: str = "",
obj: list = None):
"""
message send by format facebook
:return:
"""
page_id = recipient_id.split("_")[1]
fb_id = recipient_id.split("_")[0]
list_product = []
for item in obj:
product = {
"title":
"%s" % item.get("title"),
"image_url":
"%s" % item.get("image_url")
if item.get("image_url") is not None else IMAGE_URL,
"default_action": {
"type":
"web_url",
"url":
"%s" % item.get("product_url")
if item.get("product_url") is not None else WEB_URL,
"webview_height_ratio":
"tall",
},
}
if content != "default":
product.update({
"buttons": [{
"type": "postback",
"title": TITLE,
"payload": PRODUCT + "_%s" % item.get("id")
}]
})
list_product.append(product)
list_product = list_product[:10]
data = json.dumps({
"recipient": {
"id": fb_id
},
"message": {
"attachment": {
"type": "template",
"payload": {
"template_type": "generic",
"elements": list_product
}
}
}
})
print(data)
pages = self.connect.get("pages")
if pages:
pages = json.loads(pages)
access_token = [
_.get("page_token") for _ in pages
if str(_.get("page_id")) == page_id
][0]
params = {"access_token": "{}".format(access_token)}
request = requests.post(FACEBOOK_API_ENDPOINT + "me/messages",
params=params,
headers=self.headers,
data=data)
log_debug("############## %s ##############" % request.text)
else:
log_debug("############## Can't get pages ##############")
