def receive_message():
if request.method == 'GET':
token = request.args.get("hub.verify_token")
challenge = request.args.get("hub.challenge")
if token == 'secret':
return str(challenge)
return '400'
# Before allowing people to message your bot, Facebook has implemented a verify token
# that confirms all requests that your bot receives came from Facebook.
return verify_fb_token(token_sent)
# if the request was not get, it must be POST and we can just proceed with sending a message # back to user
else:
data = json.loads(request.data)
messaging_event = data['entry'][0]['messaging']
bot = Bot(ACCESS_TOKEN)
for message in messaging_event:
user_id = message['sender']['id']
text_input = message['message'].get('text')
if text_input in GREETINGS:
response_text = get_response()
response_text = 'Did you do your leetcode today?'
else:
response_text = 'I\'m still learning'
print('Message from user ID {} - {}'.format(user_id, text_input))
bot.send_text_message(user_id, response_text)
return '200'
class FacebookBot(object):
def __init__(self, access_token):
self._bot = Bot(access_token)
def send_text_message(self, recipient_id, response):
self._bot.send_text_message(recipient_id, response)
def handler(event, context):
print('received event: {}'.format(event))
bot = Bot(ACCESS_TOKEN)
method = event['context']['http-method']
queryparams = event['params']['querystring']
if method == "GET":
if queryparams['hub.verify_token'] == MESSENGER_VALIDATION_TOKEN:
return int(queryparams['hub.challenge'])
else:
return "Incorrect verify token"
print('method: POST')
for e in event['body-json']['entry']:
messaging = e['messaging']
for x in messaging:
if x.get('message'):
recipient_id = x['sender']['id']
if x['message'].get('text'):
message = x['message']['text']
payload_data = {}
payload_data['messages'] = []
content_data = {}
content_data['_id'] = e['id']
content_data['text'] = message
content_data['authorId'] = recipient_id
content_data['name'] = 'unknown'
content_data['received'] = time.time()
content_data['metadata'] = {}
content_data['actions'] = []
content_data['source'] = {}
content_data['source']['type'] = 'messenger'
payload_data['messages'].append(content_data)
print('sending message to orchestrator: {}'.format(
payload_data))
r = requests.post(ORCHESTRATOR_URL, json=payload_data)
print('got response from orchestrator: {} {}'.format(
r.status_code, r.json()))
fb_response = bot.send_text_message(recipient_id, r.json())
print('got response from facebook: {}'.format(fb_response))
if x['message'].get('attachments'):
for att in x['message'].get('attachments'):
bot.send_attachment_url(recipient_id, att['type'],
att['payload']['url'])
return "Success"
class MessengerBot(FlaskView):
def __init__(self):
self.ACCESS_TOKEN = 'EAAGZAKAkENXIBAOiHfF7Cv4dhejbd0AZB4ROgZAXs1EQvzVZBAAasq4f40KiBq8X3EYzZBSjAYsZAjvreEw4QaGc59xCuwKQW2Po0gLJZBQoHYZCF1ZCTd9Vfu2vYZAmE4BZB98SZBzc6rcoTwMqgZCuN0GGH3v5MesLLpswS3PDC0ZBJzTAZDZD'
self.VERIFY_TOKEN = 'TESTINGTOKEN'
self.bot = Bot(self.ACCESS_TOKEN)
def verify_fb_token(self,token_sent):
if token_sent == self.VERIFY_TOKEN:
return request.args.get("hub.challenge")
return 'Invalid verification token'
@route("/", methods=['GET', 'POST'])
def receive_message(self):
if request.method == 'GET':
"""Before allowing people to message your bot, Facebook has implemented a verify token
that confirms all requests that your bot receives came from Facebook."""
token_sent = request.args.get("hub.verify_token")
return self.verify_fb_token(token_sent)
# if the request was not get, it must be POST and we can just proceed with sending a message back to user
else:
# get whatever message a user sent the bot
output = request.get_json()
for event in output['entry']:
messaging = event['messaging']
for message in messaging:
if message.get('message'):
# Facebook Messenger ID for user so we know where to send response back to
recipient_id = message['sender']['id']
if message['message'].get('text') == "meme":
meme = requests.get("https://meme-api.herokuapp.com/gimme")
meme_url = meme.json()['url']
#response_sent_nontext = self.get_message()
self.send_meme(recipient_id, meme_url)
elif message['message'].get('text'):
self.send_message(recipient_id, check_weather.weather_check(message['message'].get('text')))
# if user sends us a GIF, photo,video, or any other non-text item
return "Message Processed"
# chooses a random message to send to the user
def get_message(self):
sample_responses = ["Chuj Ci w dupe pedale obsrany!", "Ssij jaja", "Pierdol się!"]
# return selected item to the user
return random.choice(sample_responses)
# uses PyMessenger to send response to user
def send_message(self, recipient_id, response):
# sends user the text message provided via input response parameter
self.bot.send_text_message(recipient_id, response)
return "success"
def send_meme(self,recipient_id, response):
self.bot.send_image_url(recipient_id, response)
return "success"
def support():
global client
if request.method == 'GET':
mode = request.args.get('hub.mode')
verify_tkn = request.args.get('hub.verify_token')
challenge = request.args.get('hub.challenge')
if mode == "subscribe" and verify_token(verify_tkn):
return challenge
if request.method == 'POST':
#handle_post_events(request) - if required
input_request_data = json.loads(request.data.decode('utf8'))
print("Input message - ", input_request_data)
if input_request_data["object"] == "page":
message_entries = input_request_data['entry']
for entry in message_entries:
if "messaging" in entry:
for event in entry["messaging"]:
if "message" in event:
message = event["message"]
sender_id = event["sender"]["id"]
recipient_id = event["recipient"]["id"]
if recipient_id == "483637655052155":
client = Bot(get_access_token("ESCHOOL"))
if "text" in message:
if (message["text"].upper() == "TEST BOT"):
testbot(sender_id)
else:
resp = talk(message["text"], sender_id)
print("Output Response - ", resp)
send_response(sender_id, resp)
else:
print("None text message or event -", message)
return "ok", 200
def fbtoken(**kwargs):
clientID = '467986423542306'
clientSecret = '2a8ee5a2df2701d062246b4546dbc1e3'
fbaccess_token = 'EAAGpoZASI8iIBAPpWSmlMyYoGZA8ZBDwf4YbToK9YHZCCEbRZB15nGdqMmH981eBdLdgUtZCVUnY6ZChUlKyONoKQYNumzMTkMZBQcamkYGJ359P4fmHebZCIjUCJEnNKpxKFZBQwxVt5XHdZBftxtQTk8XeCBBpEJZBvr8SBuZCVEAtHkAZDZD'
appLink = 'https://graph.facebook.com/oauth/access_token?client_id=' + clientID + '&client_secret=' + clientSecret + '&grant_type=client_credentials'
appToken = requests.get(appLink).json()['access_token']
bot = Bot(fbaccess_token)
metodo = frappe.local.request.method
print "METODO"
print metodo
cmd = frappe.local.form_dict.cmd
print time.localtime()
data = frappe.local.form_dict.data
print "API FBTOKEN"
print "CMD"
print cmd
print "DATA..."
print type(data)
print data
print "DATA ENTRY"
try:
data1 = json.loads(data)
print data1['entry']
except ValueError, e:
print False
def send_message(self, partner, text):
"""
Send message to user.
:param partner: res.partner record
:param text: the message content
:return: True if send message success
"""
recipient_id = partner.psid
page_id = partner.page_id
if not page_id and not recipient_id:
exceptions.MissingError("Can't send message to this partner.")
access_token = self._get_page_access_token(page_id)
response = Bot(access_token).send_text_message(recipient_id, text)
if response.get('error'):
raise exceptions.MissingError("Can't send message to Partner(%s).\n%s" % (response['error'], recipient_id))
return True
def __init__(self, platform):
if platform == "facebook":
self.platform = "facebook"
self.app = Flask(__name__)
self.facebook = Facebook(Bot(ACCESS_TOKEN), ACCESS_TOKEN,
VERIFY_TOKEN)
return
def create_facebook_bot(self):
if self._access_token is not None:
return Bot(self._access_token)
YLogger.error(
self,
"Facebook access token missing, unable to create facebook bot")
return None
def webhook():
body = json.load(request.body)
print body
bot = Bot(
'EAAJudOVDEOYBAOYJVj7sRGXnv4S5MaFrjSJjN8SZCHB269BQk7GUTzZCE8ZCrRpOv97ZC3wbVSzww3eYfpjRCPfBrmUZCHrouSj9M2M1ZAYqIJKxzXfrnfM7g8zeliyGdrl7BcnIftYZAsPQD3WZA2pRDcNM85ToJTCPjQ1cAQdgsQZDZD'
)
for entry in body['entry']:
for message in entry['messaging']:
if 'text' in message['message']:
recipient_id = message['sender']['id']
question = message['message']['text']
answer = _search(question)
bot.send_text_message(recipient_id, answer)
return None
def webhook(request, partner_id):
partner = Partner.objects.get(id=partner_id)
print(partner_id, partner.token, partner.secret, partner.page_id)
bot = Bot(partner.token, app_secret=partner.secret)
if request.method == 'GET':
verify_token = request.query_params.get('hub.verify_token')
mode = request.query_params.get('hub.mode')
challenge = request.query_params.get('hub.challenge')
if verify_token == "projectX" and mode == "subscribe" and challenge:
return HttpResponse(challenge)
else:
return HttpResponse(status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'POST':
data = request.data
# logger.info(data)
for event in data['entry']:
messaging = event['messaging']
for x in messaging:
if x.get(
'message'
): # print statements were failing to display it was in the error log
recipient_id = x['sender']['id']
if (recipient_id == partner.page_id):
next()
if x['message'].get('text'):
message = x['message']['text']
bot.send_text_message(recipient_id, message)
res = bot.send_text_message(recipient_id, message)
print(res)
if x['message'].get('attachment'):
bot.send_attachment_url(
recipient_id, x['message']['attachment']['type'],
x['message']['attachment']['payload']['url'])
def __init__(
self, user_id=FB_USER_ID, access_token=PAGE_ACCESS_TOKEN, level=logging.NOTSET
):
if access_token is None:
raise ValueError(
"access_token not provided, set the PAGE_ACCESS_TOKEN environment variable"
)
if access_token is None:
raise ValueError(
"user_id not provided, set the FB_USER_ID environment variable"
)
logging.Handler.__init__(self, level)
if FB_USER_ID is None:
raise ValueError("FB_USER_ID not set")
logging.Handler.__init__(self, level)
self.setFormatter(FacebookLoggerFormatter())
self.user_id = user_id
self.bot = Bot(access_token)
def run(self):
"""
Starts the bot server.
"""
self._event.clear()
self._bot = Bot(FLAGS.bot_access_token)
# TODO: Fix flask app to run in background thread.
# In fact, we need to switch to WSGI server in production.
#thread.start_new_thread(self._serve_http, ())
self._serve_http()
def listen():
"""This is the main function flask uses to
listen at the `/webhook` endpoint"""
if request.method == 'GET':
return verify_webhook(request)
elif request.method == 'POST':
payload = request.json
event = payload['entry'][0]['messaging']
for x in event:
if is_user_message(x) or is_postback_message(x):
if x.get('message'):
text = x['message']['text']
elif x.get('postback'):
text = x['postback']['title']
else:
return 'incorrect'
sender_id = x['sender']['id']
recipient_id = x['recipient']['id']
try:
credential, = MessengerCredential.search(
[('identifier', '=', recipient_id)], limit=1)
except ValueError:
return 'incorrect'
user_details_url = "https://graph.facebook.com/v2.6/%s" % sender_id
user_details_params = {'fields':'first_name,last_name,profile_pic', \
'access_token':credential.token}
user_details = requests.get(user_details_url,
user_details_params).json()
name_tupple = (user_details['first_name'],
user_details['last_name'])
full_name = ' '.join(name_tupple)
party = Party.check_if_exists(sender_id, full_name)
message = get_response_for_email(text, party, credential)
if not message:
message = get_response_for_phone(text, party, credential)
if not message:
try:
message, = Messenger.search(
[('name', 'ilike', '%' + text + '%'),
('owner', '=', credential.id)],
limit=1)
except ValueError:
print("i'm not ready to answer that!")
return 'incorrect'
bot = Bot(credential.token)
respond(bot, sender_id, text, message, credential, party)
return "ok"
return 'incorrect'
class FacebookLogger(logging.Handler):
def __init__(
self, user_id=FB_USER_ID, access_token=PAGE_ACCESS_TOKEN, level=logging.NOTSET
):
if access_token is None:
raise ValueError(
"access_token not provided, set the PAGE_ACCESS_TOKEN environment variable"
)
if access_token is None:
raise ValueError(
"user_id not provided, set the FB_USER_ID environment variable"
)
logging.Handler.__init__(self, level)
if FB_USER_ID is None:
raise ValueError("FB_USER_ID not set")
logging.Handler.__init__(self, level)
self.setFormatter(FacebookLoggerFormatter())
self.user_id = user_id
self.bot = Bot(access_token)
def emit(self, record: logging.LogRecord):
self.bot.send_text_message(self.user_id, self.format(record))
def send_quick_reply(message, quick_reply, recipient_id):
payload = {
'recipient': {
'id': recipient_id
},
"messaging_type": "RESPONSE",
"message": {
'text': message
},
"quick_replies": quick_reply
}
return Bot.send_raw(payload)
def send_message(self):
bot = Bot(ACCESS_TOKEN)
if self.imageURL:
bot.send_image_url(self.recipientID, self.imageURL)
bot.send_text_message(self.recipientID, self.response)
return 'success'
def process_fb():
""" Processes messages coming in via Facebook Messenger """
bot = Bot(FB_PAGE_ACCESS_TOKEN)
# used by FB to verify webhook
if request.method == 'GET':
if (request.args.get("hub.verify_token") == FB_VERIFY_TOKEN):
return request.args.get("hub.challenge")
if request.method == 'POST':
output = request.json
event = output['entry'][0]['messaging']
for x in event:
if (x.get('message') and x['message'].get('text')):
fb_message = x['message']['text']
recipient_id = x['sender']['id']
response = ask_regina(recipient_id, fb_message)
text = response['text']
intent = response['intent']
regina_answer = text.encode('ascii', 'replace')
bot.send_text_message(recipient_id, regina_answer)
else:
pass
return regina_answer
class Messenger:
VERIFY_TOKEN = 'TESTINGTOKEN'
ACCESS_TOKEN = 'EAAGXBJKgLyoBAOKdxLR391IqTyaKKJ7ZAxZAwrfuNgIr0OxhJywUnyIdaN3nSp4ZCmKLGi9ZAiiHTPzBW6ZAW2LIjgp1lK6qG0ZBrfx3vtBV7hbFd7ti8oA12potIB5o1hGqPW4V7ckeT8HNbxEs9Su2pZBbUZCYwuABP5O0XJuHmQZDZD'
bot = Bot(ACCESS_TOKEN)
def verify_fb_token(self, token_sent):
if token_sent == VERIFY_TOKEN:
return request.args.get("hub.challenge")
return 'Invalid verification token'
def send_message(self, recipient_id, response):
self.bot.send_text_message(recipient_id, response)
return "success"
def send_option_message(self, recipient_id, response, options):
buttons = []
for element in options:
button = Button(title=element, type='postback', payload='other')
buttons.append(button)
self.bot.send_button_message(recipient_id, response, buttons)
return "success"
class FacebookMessenger(Messenger):
""" Implementation of the messenger class using facebooks backend """
def __init__(self, authentication_token):
self.authentication_token = authentication_token
self.bot = FbBot(authentication_token)
def send(self, user_id: str, text: str):
""" Sends to the user_id (backend must understand) the text message"""
self.bot.send_text_message(user_id, text)
def mark_writing(self, user_id: str, write_on: bool):
""" Sends the user the writing notification"""
action = 'typing_on' if write_on else 'typing_off'
self.bot.send_action(user_id, action)
def mark_seen(self, user_id: str):
""" Sends the user the writing notification"""
self.bot.send_action(user_id, 'mark_seen')
def send_response(sender_id, message, session):
"""
This function sends a response to the user identified by sender_id.
Parameters:
sender_id: The psid of the user that sent the message.
message: The message sent by the user identified by psid.
"""
messenger_bot = MessengerBot(PAT)
messenger_bot.send_action(sender_id, 'mark_seen')
messenger_bot.send_action(sender_id, 'typing_on')
# TODO REFACTOR
meaning = witai_helpers.determine_meaning(message)
if meaning == 'general_price_information' or meaning == 'general_price_info':
response = 'We have the cheapest prices!'
elif meaning == 'operation_hours':
response = 'We are open M-Sat from 9am to 6pm.'
elif meaning == 'general_location_information':
reponse = "We are located on High Street right behind Tj's Country Place!"
elif meaning == 'general_service_information':
response = 'We offer custom framing at affordable prices!'
elif meaning == 'general_quality_information':
response = 'We are the best framers in central Ohio!'
elif meaning == 'general_bot_information':
send_information_buttons(sender_id)
return
elif meaning == 'rude_customer':
response = 'That was rude!'
elif meaning == 'Schedule appointment':
schedule_appointment(sender_id)
messenger_bot.send_action(sender_id, 'typing_off')
messenger_bot.send_text_message(sender_id, message)
def create_facebook_bot(self):
return Bot(self._access_token)
import random
from flask import Flask, request
from pymessenger.bot import Bot
import os
app = Flask(__name__, static_url_path='')
port = int(os.getenv('PORT', 8000))
ACCESS_TOKEN = 'EAAX5iE28QIgBALFWiNWGIuZCpgBzET4UcXZCkDg2m8G5yiTdcUsEib9HKxtb6iTLKfbAv3kFA6tl8XG5laOey8A3mWoh8Sz4lzhiFC2F3Lkm5IowjKejU0aA5mYlLnDQYpP6gZCphA0bLXgmJ5V7CCxUUkUkxXzm1KR7sKHFQZDZD'
VERIFY_TOKEN = 'V3rySaf3AndL0ngT00ken'
bot = Bot(ACCESS_TOKEN)
#We will receive messages that Facebook sends our bot at this endpoint
@app.route("/", methods=['GET', 'POST'])
def receive_message():
if request.method == 'GET':
"""Before allowing people to message your bot, Facebook has implemented a verify token
that confirms all requests that your bot receives came from Facebook."""
token_sent = request.args.get("hub.verify_token")
if token_sent is None:
return "Hello World"
return verify_fb_token(token_sent)
#if the request was not get, it must be POST and we can just proceed with sending a message back to user
else:
# get whatever message a user sent the bot
output = request.get_json()
for event in output['entry']:
messaging = event['messaging']
for message in messaging:
if message.get('message'):
__author__ = 'raphaelfettaya'
import os
from flask import Flask, request
from pymessenger.bot import Bot
from logic import answer, ExtractionError
from logger import get_logger
import threading
app = Flask(__name__)
BOT = Bot(os.environ["ACCESS_TOKEN"])
logger = get_logger(__name__)
@app.route('/', methods=['GET'])
def verify():
# when the endpoint is registered as a webhook, it must echo back
# the 'hub.challenge' value it receives in the query arguments
if request.args.get("hub.mode") == "subscribe" and request.args.get("hub.challenge"):
if not request.args.get("hub.verify_token") == os.environ["VERIFY_TOKEN"]:
return "Verification token mismatch", 403
return request.args["hub.challenge"], 200
return "Hello world", 200
def process_request(data):
# data = request.get_json()
pass
## Python libraries that we need to import for our bot
import botUtil
import courseUtil
from flask import Flask, request
from pymessenger.bot import Bot ## pymessenger is a Python wrapper for the Facebook Messenger API
app = Flask(
__name__
) ## This is how we create an instance of the Flask class for our app
ACCESS_TOKEN = 'EAAEXESyVKJkBAMQZAfEzTcFl70KAD7UVx9a53AWxHhjL6J1UdzaPUd1BcRfyuUkChP3xlZA3QMZAtZCuqzpjMVreHZAll6UaAZBypV6CkRTlLfgM0IxL5pF3CwGMF2mGdzwKe9GCgIl724bZCkZCtv8abszReP3ZBdL1r1m1kGJqVfRm5o9oB6hhK'
VERIFY_TOKEN = 'nmslwsnd' ## Replace 'VERIFY_TOKEN' with your verify token
bot = Bot(ACCESS_TOKEN) ## Create an instance of the bot
flag1 = False
flag2 = False
flag3 = False
m = botUtil.get_course_info()
m2 = botUtil.get_pre_req()
course_list = []
def verify_fb_token(token_sent):
## Verifies that the token sent by Facebook matches the token sent locally
if token_sent == VERIFY_TOKEN:
return request.args.get("hub.challenge")
return 'Invalid verification token'
# Chooses a message to send to the user
def get_message_text():
return "Hey, it looks like you're interested in HackRice! For more information, please visit http://hack.rice.edu"
import time
import random
import sys
import sqlite3 as sql
import json
import requests
# Telegram bot
bot = telebot.TeleBot(config.tg_token, skip_pending=True)
# Vkontakte bot
vk_session = vk_api.VkApi(token=config.token_vk)
vk = vk_session.get_api()
# Facebook bot
fb_bot = Bot(config.fb_access_token)
# Google sheets authorization
gc = gspread.service_account(filename=config.cred_final)
def send_msg_to_tg(message_data):
bot.send_message(config.group_id, message_data)
def get_email_from_message(message):
lines = message.split('\n')
email = ""
for line in lines:
if line.startswith("email:"):
from pymessenger.bot import Bot bot = Bot(<access_token>, <optional: app_secret>) bot.send_text_message(recipient_id, message)
import tempfile
import redis
import uuid
import string
from pydub import AudioSegment
# import speech_recognition as sr
from pymessenger.bot import Bot
import traceback
from pyDubMod import *
from timeout_dec import timeout_dec # timeout decorator
TOKEN= Facebook_Token
bot = Bot(TOKEN)
def shutil_which(pgm):
"""Python 2 backport of ``shutil.which()`` from Python 3"""
path = os.getenv('PATH')
for p in path.split(os.path.pathsep):
p = os.path.join(p, pgm)
if os.path.exists(p) and os.access(p, os.X_OK):
return p
def gettoken(uid):
red = redis.from_url(redis_url)
token = red.get(uid+"-access_token")
refresh = red.get(uid+"-refresh_token")
import os
from pymessenger.bot import Bot
from pymessenger import Element, Button
TOKEN = os.environ.get('TOKEN')
APP_SECRET = os.environ.get('APP_SECRET')
bot = Bot(TOKEN, app_secret=APP_SECRET)
recipient_id = os.environ.get('RECIPIENT_ID')
def test_wrong_format_message():
result = bot.send_text_message(recipient_id, {'text': "its a test"})
assert type(result) is dict
assert result.get('message_id') is None
def test_text_message():
result = bot.send_text_message(recipient_id, "test")
assert type(result) is dict
assert result.get('message_id') is not None
assert result.get('recipient_id') is not None
def test_elements():
image_url = 'https://lh4.googleusercontent.com/-dZ2LhrpNpxs/AAAAAAAAAAI/AAAAAAAA1os/qrf-VeTVJrg/s0-c-k-no-ns/photo.jpg'
elements = []
element = Element(title="Arsenal",
image_url=image_url,
import random
from flask import Flask, request
from pymessenger.bot import Bot
app = Flask(__name__)
FACEBOOK_ACCESS_TOKEN = 'EAAMoWPp4rwoBABiii4iDV8uSuZBl5MblHHtDhmbqw7lk93wwpirM53ZBeUWhseUWbxEsCsGGgpg2pfDUXuEhLL6LI3RWMBwm1IlFnP8B1q9ZC0QkEaWoAgCBn10g7no4VBlCyNJcVykHqImvZBwZClRe748ZA7ZCqh20qmkvrgvRwZDZD'
VERIFY_TOKEN = 'income_messenger'
bot = Bot(FACEBOOK_ACCESS_TOKEN)
def initialize(alfred, platform):
if platform == "facebook":
alfred.app = app
import facebook_routes
app.run()
return alfred
def send_image_message(recipient_id, img_url):
bot = Bot(ACCESS_TOKEN)
print(img_url)
re = bot.send_image_url(recipient_id, img_url)
print(re)
"""
This bot listens to port 5002 for incoming connections from Facebook. It takes
in any messages that the bot receives and echos it back.
"""
import os
from flask import Flask, request
from pymessenger.bot import Bot
import json
app = Flask(__name__)
PAT = "EAAdGfq5c0sQBABeCdZC1yPfodlelFzO2vT3JZCua81ABlE4LilswQXiXWNZBz59ICIC79vyzbsd18djPmoNZAMdlEox7JwKr8zmoiyzCGeDgHh1NR7dahMoTJ8eqgmnZC40C13hLCxsAgsAQBgm16ER9ItqkyrkUcMZCOFxg3LuwZDZD"
VT = "90293269"
bot = Bot(PAT)
@app.route("/", methods=['GET', 'POST'])
def hello():
if request.method == 'GET':
if request.args.get("hub.verify_token") == VT:
return request.args.get("hub.challenge")
else:
return 'Invalid verification token'
if request.method == 'POST':
output = request.get_json()
for event in output['entry']:
messaging = event['messaging']
for x in messaging:
if x.get('message'):
recipient_id = x['sender']['id']
if x['message'].get('text'):
elements = [{
class ChatStep(abc.ABC):
MAX_ITEMS_FOR_SUGGESTIONS = 6
MAX_ITEMS_FOR_BUTTONS = 4
STORAGE_DATETIME_FORMAT = '%Y%m%d_%H%M'
def __init__(self, session):
self.session = session
self.bot = Bot(settings.FB_PAGE_ACCESS_TOKEN)
@staticmethod
@abc.abstractmethod
def get_name():
raise NotImplementedError()
@abc.abstractmethod
def send_message(self):
raise NotImplementedError()
@abc.abstractmethod
def handle_user_response(self, handle_user_response):
raise NotImplementedError()
@staticmethod
def _extract_text(messaging_event):
text = messaging_event.get('message', {}).get('text', None)
if text:
text = text.strip()
return text
@staticmethod
def _extract_selected_button(messaging_event):
return messaging_event.get('postback', {}).get('payload', None)
@staticmethod
def _is_quick_reply(messaging_event):
payload = messaging_event.get('message', {}).get('quick_reply', {}).get('payload', None)
return payload is not None
@staticmethod
def _extract_selected_quick_reply(messaging_event):
return messaging_event.get('message', {}).get('quick_reply', {}).get('payload', None)
def _set_step_data(self, data, key=None):
if key is None:
key = self.get_name()
self.session.steps_data[key] = data
self.session.save()
def _send_message(self, message):
recipient_id = self.session.user_id
logger.info("Sending message to %s: %s", recipient_id, message)
self.bot.send_text_message(recipient_id, message)
def _send_buttons(self, message, buttons):
recipient_id = self.session.user_id
logger.info("Sending buttons message to %s: %s", recipient_id, message)
resp = self.bot.send_button_message(recipient_id, message, buttons)
logger.info("Got %s", resp)
def _send_suggestions(self, message, suggestions):
recipient_id = self.session.user_id
logger.info("Sending suggestions message to %s: %s", recipient_id, message)
suggestions_payload = []
for suggestion in suggestions:
suggestions_payload.append({
'content_type': 'text',
'title': suggestion['text'],
'payload': suggestion['payload'],
})
message_payload = {
'text': message,
'quick_replies': suggestions_payload
}
print(message_payload)
resp = self.bot.send_message(recipient_id, message_payload)
logger.info("Got %s", resp)
def call_handle_user_response(self, messaging_event):
text = self._extract_text(messaging_event)
if text and "ביי" in text:
return "terminate"
return self.handle_user_response(messaging_event)
def __init__(self, session):
self.session = session
self.bot = Bot(settings.FB_PAGE_ACCESS_TOKEN)
