def __init__(self, ggly: Ggly, access_token: str, verify_token: str):
super().__init__()
if access_token is None:
logging.warning(
"Facebook access token not set. You will not be able to use messenger bot."
)
self.verify_token = verify_token
self.bot = Bot(access_token)
self.ggly = ggly
self.work_dir = get_work_dir()
def start(port=5000):
ql.initialize_static_questions(TREE)
app.run(port=port)
request_endpoint = '{0}/me/messenger_profile'.format(bot.graph_url)
response = requests.post(
request_endpoint,
params=bot.auth_args,
data=json.dumps({"get_started": {"payload": "first"}}),
headers={'Content-Type': "application/json"}
)
result = response.json()
Bot.send_raw(response)
def returnOutputMessage():
try:
output: dict = request.get_json()
message: dict = output['entry'][0]['messaging'][0]
if message.get('message'):
recipient_id: str = message['sender']['id']
if message['message'].get('text'):
text: str = message['message'].get('text')
output_msg = text
bot = Bot(ACCESS_TOKEN)
bot.send_text_message(recipient_id, output_msg)
return 'réalisation avec succès'
except:
return 'Nous rencontrons un problème à recevoir votre message'
class TestSmallTalkFunctionality(unittest.TestCase):
"""
Tests the SmallTalkFunctionality class
"""
SENDER_ID = "1"
bot = Bot(constants.PAGE_ACCESS_TOKEN)
categories = {"greetings": "Hey", "response": "bien"}
functionality = SmallTalkFunctionality(SENDER_ID, bot, categories)
def test_getResponse(self):
# check default message and type
response = self.functionality.getResponse()
self.assertEqual("text_message", response["type"])
self.assertEqual("text_message", response["type"])
self.assertTrue(response["message"])
def test_getMessageToSend(self):
messageToSend = self.functionality.getMessageToSend()
self.assertTrue(messageToSend)
print(self.categories)
self.assertNotEqual("ah, ok", messageToSend)
def test_getMessageToSendIfQuestion(self):
setInDB(self.SENDER_ID, {"question": "howAreYou"})
messageToSend = self.functionality.getMessageToSend()
self.assertFalse(getInDB(self.SENDER_ID, "question"))
self.assertIn(
messageToSend,
[
"Tant mieux!",
"Et ben. Ça va bien aller" + emojis.RAINBOW + ", comme on dit",
"Tout va bien alors " + emojis.HAPPY_FACE + "!",
],
)
class TestWeirdQuestionsFunctionality(unittest.TestCase):
"""
Tests the NewsFunctionality class
"""
SENDER_ID = "1"
bot = Bot(constants.PAGE_ACCESS_TOKEN)
categories = {"question": ["Quelle", "?"]}
functionality = ToughQuestionsFunctionality(SENDER_ID, bot, categories)
def test_getResponse(self):
response = self.functionality.getResponse()
self.assertEqual("text_message", response["type"])
self.assertIn(
response["message"],
[
"Je dirais exactement comme la jument blanche de Napoléon",
"La 4e à ta gauche",
"Hmmm. Bonne question. Si j'avais le choix, je pense que je choisirais celle qui est la même que le "
"fils unique de la fille unique de ma grand-mère",
"La même que la patate à Mononc' Serge",
],
)
def test_getResponseWithOnlyOneChoice(self):
newCategories = {"question": ["qui", "?"], "whatCanYouDo": "faire"}
functionality = ToughQuestionsFunctionality(self.SENDER_ID, self.bot,
newCategories)
response = functionality.getResponse()
self.assertTrue(response["type"])
self.assertTrue(response["message"])
class TestGameFunctionality(unittest.TestCase):
"""
Tests the GameFunctionality class
"""
SENDER_ID = "1"
bot = Bot(constants.PAGE_ACCESS_TOKEN)
categories = {"number": str(2)}
payload = None
functionality = GameFunctionality(SENDER_ID, bot, categories, payload)
def test_TicTacToeResponse(self):
categories = {"response": "oui"}
functionality = GameFunctionality(self.SENDER_ID, self.bot, categories,
self.payload)
deleteFromDB(self.SENDER_ID)
setInDB(self.SENDER_ID, {"game": "ticTacToe"})
response = functionality.getResponse()
self.assertEqual("text_message", response["type"])
self.assertIsInstance(response["message"], str)
self.assertIsNotNone(getInDB(self.SENDER_ID, "grid"))
def test_TicTacToeGameStarted(self):
deleteFromDB(self.SENDER_ID)
setInDB(
self.SENDER_ID,
{"grid": [["0", "1", "2"], ["3", "4", "5"], ["6", "7", "8"]]},
)
response = self.functionality.continuePlayingTicTacToe()
self.assertIsInstance(response, str)
setInDB(self.SENDER_ID, {"grid": None})
class TestSingFunctionality(unittest.TestCase):
"""
Tests the NewsFunctionality class
"""
SENDER_ID = "1"
bot = Bot(constants.PAGE_ACCESS_TOKEN)
categories = {"rickSong": "We're no strangers to love"}
functionality = SingFunctionality(SENDER_ID, bot, categories)
def test_getResponse(self):
deleteFromDB(self.SENDER_ID)
response = self.functionality.getResponse()
self.assertEqual("text_message", response["type"])
self.assertEqual(
putNotesEmojisAround("You know the rules and so do I"),
response["message"])
def test_getResponseWithDatabase(self):
deleteFromDB(self.SENDER_ID)
setInDB(self.SENDER_ID, {"rickPartLastLyrics": 5})
response = self.functionality.getResponse()
self.assertEqual("text_message", response["type"])
self.assertEqual(putNotesEmojisAround("Never gonna let you down"),
response["message"])
class TestWeirdQuestionsFunctionality(unittest.TestCase):
"""
Tests the NewsFunctionality class
"""
SENDER_ID = "1"
bot = Bot(constants.PAGE_ACCESS_TOKEN)
categories = {"choice": ["vrai", "faux"]}
functionality = ChoiceQuestionsFunctionality(SENDER_ID, bot, categories)
def test_getResponse(self):
response = self.functionality.getResponse()
self.assertEqual("text_message", response["type"])
self.assertIn(
response["message"], ["vrai", "faux", "Trop difficile comme choix, ça!"]
)
def test_getResponseWithOnlyOneChoice(self):
newCategories = {"choice": "pas de choix"}
functionality = ChoiceQuestionsFunctionality(
self.SENDER_ID, self.bot, newCategories
)
response = functionality.getResponse()
self.assertEqual("text_message", response["type"])
self.assertIn(
response["message"], ["pas de choix", "Trop difficile comme choix, ça!"]
)
class TestFunctionality(unittest.TestCase):
"""
Tests the Utils class
"""
SENDER_ID = "1"
bot = Bot(constants.PAGE_ACCESS_TOKEN)
categories = {"newsType": "coronavirus"}
functionality = Functionality(SENDER_ID, bot, categories)
def test_getResponse(self):
# check default message and type
response = self.functionality.getResponse()
self.assertEqual("huh!?", response["message"])
self.assertEqual("text_message", response["type"])
def test_getCategoryValue(self):
# get the value for a category
value = self.functionality.getCategoryValue("newsType")
self.assertEqual("coronavirus", value)
class TestNewsFunctionality(unittest.TestCase):
"""
Tests the NewsFunctionality class
"""
SENDER_ID = "1"
bot = Bot(constants.PAGE_ACCESS_TOKEN)
categories = {"newsType": "coronavirus", "frequence": "jour"}
functionality = NewsFunctionality(SENDER_ID, bot, categories)
def test_getResponse(self):
# check default message and type
deleteFromDB(self.SENDER_ID)
response = self.functionality.getResponse()
self.assertEqual("generic_message", response["type"])
self.assertTrue(len(response["message"]) != 0)
def test_getResponseRecurrence(self):
deleteFromDB(self.SENDER_ID)
response = self.functionality.getResponse()
self.assertEqual("generic_message", response["type"])
self.assertTrue(len(response["message"]) != 0)
setInDB(self.SENDER_ID, {"newsRecurrence": None})
from decimal import Decimal
import requests
import psycopg2
from pymessenger import Bot
from flask_sqlalchemy import SQLAlchemy
import os
app = Flask(__name__)
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'postgres://*****:*****@ec2-54-227-241-179.compute-1.amazonaws.com:5432/deaeql5ahe7n7c'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
ACCESS_TOKEN = 'EAADVw0N2kHEBAGsaysJSKBGrS0SXAK91JaU1yDrShLaOywRoJshD3ZBYkDY2Jb9lPxCG2TRX5ZBwd4m2wwPb8DOKW7uU7dz1NT410b1QP1UK5exVVKP26Ldyo4izFp7lcXT4bcsPK18yDYLf5AkxxY1J2AF8uWHbpQ7Yvb0AZDZD' #ACCESS_TOKEN = os.environ['ACCESS_TOKEN']
VERIFY_TOKEN = 'VERIFY_TOKEN' # VERIFY_TOKEN = os.environ['VERIFY_TOKEN'] not need
bot = Bot(ACCESS_TOKEN)
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(50))
text_send = db.Column(db.Text)
text_receive = db.Column(db.Text)
date = db.Column(db.String(100), default=datetime.datetime.utcnow)
session = db.Column(db.Text)
# We will receive messages that Facebook sends our bot at this endpoint
@app.route("/bot", methods=['GET', 'POST'])
import os, sys
from flask import Flask, request
from utils import wit_response, get_news_elements
from pymessenger import Bot
app = Flask(__name__)
bot = Bot('ACCESS_TOKEN')
@app.route('/', methods=['GET'])
def verify():
if request.args.get('hub.mode') == 'subscribe' and request.args.get(
'hub.challenge'):
if not request.args.get('hub.verify_token') == 'hello':
return 'Verification token mismatch', 403
return request.args['hub.challenge'], 200
return 'Hello World', 200
@app.route('/', methods=['POST'])
def webhook():
data = request.get_json()
log(data)
if data['object'] == 'page':
for entry in data['entry']:
for messaging_event in entry['messaging']:
sender_id = messaging_event['sender']['id']
recipient_id = messaging_event['recipient']['id']
from flask import Flask, request
from pymessenger import Bot
import sys, os
app = Flask("My echo bot")
FB_ACCESS_TOKEN = "EAANSLNttakoBACts0kqZBgqxv04nk3JZBZCOL88HV4F4q2PbmF3ZBTQFtxk0r9Hh2bWZCDZCfGxMvmd0lPep3qUx8NZCQFPQZCXRWMDrCatGKN5ZCPJj1XHyLxwPIKGsMpvYr188tPByYJ5tDFHM8hF2UWXz5MAyZAnkPhbLI7u3Ok9vg3vLLzFv0pTFHF49dd11UZD"
bot = Bot(FB_ACCESS_TOKEN)
VERIFICATION_TOKEN = "hello"
@app.route('/', methods=['GET']) # '/' means homepage of our website
def verify():
if request.args.get("hub.mode") == "subscribe" and request.args.get(
"hub.challenge"):
if not request.args.get("hub.verify_token") == VERIFICATION_TOKEN:
return "Verification token mismatch", 403
return request.args["hub.challenge"], 200
return "Hello world", 200
@app.route('/', methods=['POST'])
def webhook():
data = request.get_json()
log(data)
if data['object'] == 'page':
for entry in data['entry']:
for messaging_event in entry[
'messaging']: # a messaging_event is essentially a webhook event
import os, sys
from flask import Flask, request
from utils import wit_response
from pymessenger import Bot
#initialise Flask app
app = Flask(__name__)
PAGE_ACCESS_TOKEN = "EAAFGnmzStNcBAIVibLcyq18ZBXpgoNeeQSDhYq9qjcKiIGkvtEZB0ZCUVGyxuYg5bl6qeYiJB9apFXem2A1C7ZCyKrGHuxEKQsvD85bkXlkmHLCRIwRxyDhEZANMwTxoX6VU2co6Jm6LBpvA3p9a7WF614BgZBzHLOYukYZCzBKutF9TCEH94iv"
bot = Bot(PAGE_ACCESS_TOKEN)
count = 0
@app.route('/', methods=['GET'])
def verify():
# Webhook verification
# 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") == "hello":
return "Verification token mismatch", 403
return request.args["hub.challenge"], 200
return "Hello world", 200
@app.route('/', methods=['POST'])
def webhook():
global count
data = request.get_json()
log(data)
if data['object'] == 'page':
import os, sys
from flask import Flask, request
from pymessenger import Bot
from utils import wit_response, get_news_elements
app = Flask(__name__)
accesstoken = "Page access token here"
bot = Bot(accesstoken)
@app.route('/', methods=['GET'])
def verify():
# Webhook verification
if request.args.get("hub.mode") == "subscribe" and request.args.get(
"hub.challenge"):
if not request.args.get("hub.verify_token") == "hello":
return "Verification token mismatch", 403
return request.args["hub.challenge"], 200
return "Hello world", 200
@app.route('/', methods=['POST'])
def webhook():
data = request.get_json()
log(data)
if data['object'] == 'page':
for entry in data['entry']:
for messaging_event in entry['messaging']:
# IDs
import json
import requests
#from utils import wit_response
from pymessenger import Bot
from os import environ
import re
app = Flask(__name__)
#v_token = environ.get('FB_VERIFY_TOKEN')
#a_token = environ.get('FB_ACCESS_TOKEN')
v_token = "blondiebytes"
a_token = "EAADZBqZBZC8rAIBAPDztnVHeGZB7slQzZBZBiZBsZBl5XrCrlpJa6Oo5mQr0kfUBdci5LvVuOg9U1RhaHDLX9nkbQSigIDqcgnmGiY6KU2zeMZCZBPZBekdzgyaeUupy1fiUmTjwfHw0FFrzWADZBPYWmO3b3BZABmJ5J2BsJO7GQiDg23hvKfvOFdpjm"
bot = Bot(a_token)
global respuestas, names, nivel, parafraseo_indices, parafraseo, puntajes, parafraseos
respuestas = {}
names = {}
nivel = {}
parafraseo_indices = {}
parafraseo = {}
consentimiento_accepted = False
puntajes = {'1_a':1,'1_b':2,'1_c':3,'1_d':4,'1_e':5,
'2_a':5,'2_b':4,'2_c':3,'2_d':2,'2_e':1,
'3_a':1,'3_b':2,'3_c':3,'3_d':4,'3_e':5,
'4_a':5,'4_b':4,'4_c':3,'4_d':2,'4_e':1,
'5_a':1,'5_b':2,'5_c':3,'5_d':4,'5_e':5,
'6_a':1,'6_b':2,'6_c':3,'6_d':4,'6_e':5,
import secrets
import json
from flask import Flask, request, jsonify, send_from_directory
from pymessenger import Bot
from conversation import TextResponse, ImageUrlResponse, YesNoResponse, Match
from repo import ConversationRepository, PollRepository
from poll import Poll
from user import TeamSlugFilter
conversation_repository = ConversationRepository()
poll_repository = PollRepository()
app = Flask(__name__)
VERIFY_TOKEN = "globotftw"
bot = Bot(secrets.ACCESS_TOKEN)
@app.route("/", methods=['GET', 'POST'])
def hello():
if request.method == 'GET':
if request.args.get("hub.verify_token") == VERIFY_TOKEN:
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:
from flask import Flask, request
from pymessenger import Bot
import random
import ibm_watson
from utils import entity_to_nutri, get_nparr
app = Flask(__name__, static_folder='static')
app.config.from_pyfile('configs/constants.py')
bot = Bot(app.config['FACEBOOK_ACCESS_TOKEN'])
assistant = ibm_watson.AssistantV1(version='2019-02-28',
iam_apikey=app.config['ASSISTANT_API_KEY'],
url=app.config['ASSISTANT_URL'])
nparr = get_nparr()
nparr = [tmp[0] for tmp in nparr]
@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")
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()
class TestLocationFunctionality(unittest.TestCase):
"""
Tests the LocationFunctionality class
"""
SENDER_ID = "1"
bot = Bot(constants.PAGE_ACCESS_TOKEN)
categories = {"location": "Canada"}
functionality = LocationFunctionality(SENDER_ID, bot, categories)
def test_getResponse_whenNotChangingLocation(self):
# check default message and type
setInDB(self.SENDER_ID, {"question": None})
setInDB(self.SENDER_ID, {"location": "Canada"})
response = self.functionality.getResponse()
self.assertEqual(
"Ok, donc je garde Canada en note comme étant ta localisation préférée!",
response["message"],
)
self.assertEqual("text_message", response["type"])
def test_getResponse_whenNewLocation(self):
# check default message and type
setInDB(self.SENDER_ID, {"question": None})
setInDB(self.SENDER_ID, {"location": "India"})
response = self.functionality.getResponse()
self.assertEqual(
"Ton endroit préféré jusqu'à maintenant était India, est-ce que tu veux le changer?",
response["message"],
)
self.assertEqual("text_message", response["type"])
setInDB(self.SENDER_ID, {"location": "Canada"})
def test_getResponse_whenChangingLocation(self):
# check default message and type
setInDB(
self.SENDER_ID,
{"question": "location", "response": "Canada", "location": "India"},
)
response = self.functionality.getResponse()
self.assertEqual(
"Ok, donc je garde Canada en note comme étant ta localisation préférée!",
response["message"],
)
self.assertEqual("text_message", response["type"])
setInDB(self.SENDER_ID, {"location": "Canada"})
def test_getResponse_whenSayingNoChangingLocation(self):
# check default message and type
setInDB(
self.SENDER_ID,
{"question": "location", "response": "India", "location": "India"},
)
response = self.functionality.getResponse()
self.assertEqual("Ah, ok. Donc on ne change pas", response["message"])
self.assertEqual("text_message", response["type"])
setInDB(self.SENDER_ID, {"location": "Canada"})
def test_getCategoryValue(self):
# get the value for a category
value = self.functionality.getCategoryValue("location")
self.assertEqual("Canada", value)
from flask import Flask, request
import requests
import json
import traceback
import random
import os, sys
from pymessenger import Bot
from WitApi import WitApi
witApi = WitApi()
webhook_verify_token = os.environ.get('webhook_verify_token', None)
page_token = os.environ.get('page_token', None)
bot = Bot(page_token)
app = Flask(__name__)
@app.route('/', methods=['GET'])
def verify():
if not request.args.get('hub.verify_token') == page_token:
return 'verification token mismatch', 403
else:
return request.args.get('hub.challenge', 'Error shovon'), 200
return 'hello mate', 200
@app.route('/', methods=['POST'])
def post_message():
import os,sys,requests
from utils import ioeBot
# from detectChange import detectChange
import json
from flask import Flask,request
from pymessenger import Bot
import datetime
PAGE_TOKEN = open('token.txt','r').readline()
ADMIN_SENDER_ID = "1928179273867668"
SLEEP_TIME = 60
app = Flask(__name__)
bot = Bot(PAGE_TOKEN)
# START=datetime.datetime.now
# print(START)
# if(START-datetime.datetime.now==20):
# detectChange()
@app.route('/',methods=['GET'])
def verify_webhook():
#Webhook Verification
if request.args.get("hub.mode") == "subscribe" and request.args.get("hub.challenge"):
if not request.args.get("hub.verify_token") == "ioeBot":
return "Verification token Mismatch" , 403
return request.args["hub.challenge"],200
print("Verfiy")
return "Hello world",200
import os, sys
from flask import Flask, request
from witt import wit_response
from pymessenger import Bot
app = Flask(__name__)
# Page token
Page_token = "EAAQI1W6WkPABABBUcZChoQN461CZBesaadZBZBUoLNrv0KjEWNjFxh5kOWhgGKrZAVhQMczmnh1tDOtQLjDX3M8WgWuEAfAVU4ZCCffxInTYnkdQXFKuH9QJlw2BNRdhlGHQOgqS6SEZA7Qjrsr2IbhbhYfhzZCSP4fiEvAqtZCOveCu4122vq8kk"
Prometheus = Bot(Page_token)
@app.route('/', methods=['GET'])
def verify():
# Webhook verification
if request.args.get("hub.mode") == "subscribe" and request.args.get(
"hub.challenge"):
if not request.args.get("hub.verify_token") == "hello":
return "Verification token mismatch", 403
return request.args["hub.challenge"], 200
return "Hello world", 200
@app.route('/', methods=['POST'])
def webhook():
data = request.get_json()
log(data)
if data['object'] == 'page':
for entry in data['entry']:
for messegeevent in entry['messaging']:
import os, sys
from flask import Flask, request
from pymessenger import Bot
from utils import wit_response
TOKEN = 'EAAH9TA0EJ5gBAOQ6WXS8rwum8ZCBkN8EstvKYY1ncOjlVU7dQO4dQikbCSsemHZA88aluF7VCE1l4ZBg4ZAw7BJNU7nBDKpLnfocaZBM73kOMSxiII2p3ccmOG8gDF82AbYerE5pVZA8bJm9UZBBEZBZAJA2FvcGnnlobVv1QuLvkHMaaEStLmk3V'
app = Flask(__name__)
bot = Bot(TOKEN)
@app.route('/', methods=['GET'])
def verify():
if request.args.get("hub.mode") == "subscribe" and request.args.get(
"hub.challenge"):
if not request.args.get("hub.verify_token") == "hello":
return "Verification token mismatch", 403
return request.args["hub.challenge"], 200
return "Hello world", 200
@app.route('/', methods=['POST'])
def webhook():
data = request.get_json()
log(data)
if data['object'] == 'page':
for entry in data['entry']:
for msg_event in entry['messaging']:
sender_id = msg_event['sender']['id']
recipient_id = msg_event['recipient']['id']
def create_bot():
return Bot(ACCESS_TOKEN)
import gnewsclient
from gnewsclient import gnewsclient
import random
import constants
from pymessenger import Bot
from application.dbAccess.pyMongo import getInDB, setInDB
from application.functionalities.functionality import Functionality
bot = Bot(constants.PAGE_ACCESS_TOKEN)
class NewsFunctionality(Functionality):
def setResponse(self):
if not (getInDB(self.senderId, "question")):
response = self.getCoronaNewsElements()
else:
response = self.setNewsRecurrence()
self.messageToSend = response["message"]
self.messageType = response["type"]
def setNewsRecurrence(self):
if "frequence" in self.categories:
frequence = self.categories.get("frequence")
if "jour" in frequence:
setInDB(self.senderId, {"newsRecurrence": "jour"})
messageToSend = "C'est noté! Toutefois, cette fonction ne marche pas présentement, dsl"
setInDB(self.senderId, {"question": None})
elif "semaine" in frequence:
setInDB(self.senderId, {"newsRecurrence": "semaine"})
messageToSend = "C'est noté! Toutefois, cette fonction ne marche pas présentement, dsl"
setInDB(self.senderId, {"question": None})
from flask import request
from pymessenger import Bot
from sharesio import app
from sharesio.config import config
from sharesio.event_dispatcher import EventDispatcher
from sharesio.face_recognition import FaceRecognition
from sharesio.messenger_api import MessengerApi
from sharesio.messenger_bot import MessengerBot
from sharesio.repository import InMemoryImageRepository, InMemoryUserRepository
_pymessenger_bot = Bot(config['page_access_token'])
_api = MessengerApi(_pymessenger_bot)
_face_recognition = FaceRecognition()
_image_repository = InMemoryImageRepository()
_user_repository = InMemoryUserRepository()
_messenger_bot = MessengerBot(_api, _face_recognition, _image_repository,
_user_repository)
_event_dispatcher = EventDispatcher(_messenger_bot)
@app.route('/', methods=['GET'])
def index():
return app.send_static_file('index.html')
@app.route('/webhook', methods=['GET'])
def verify_token():
if request.args.get('hub.verify_token') == config['verification_token']:
import os, sys
import requests
from flask import Flask, request
from pymessenger import Bot
app = Flask(__name__)
#stores requests for btc price in different currencies using api
x = requests.get('https://api.coindesk.com/v1/bpi/currentprice/CAD.json')
y = requests.get('https://api.coindesk.com/v1/bpi/currentprice/GBP.json')
PAGE_ACCESS_TOKEN = "EAAWMoLgKtqgBAPZA0aRc3iLdux0TmlkZCLPKaQo3ZA4E6ZAkOliIjxCuk9R4bWcnqXvS24tUYveM8UySZAUlqHUvvYeiYsaYNRZCPQiZBu8WSYlCsTBDbuRyBrpVkMQEBwAtiPxwEfLZAKHJwk14SvJdGcou3S3ml05DeZAFtwhX8KyJmyGngLNhh"
bot = Bot(PAGE_ACCESS_TOKEN)
@app.route('/', methods=['GET'])
def verify():
if request.args.get("hub.mode") == "subscribe" and request.args.get(
"hub.challenge"):
if not request.args.get("hub.verify_token") == "hello":
return "Verification token mismatch", 403
return request.args["hub.challenge"], 200
return "Hello world", 200
@app.route('/', methods=['POST'])
def webhook():
data = request.get_json()
log(data)
if data['object'] == 'page':
if "Topics" not in i.keys():
out += i['Text'] + "\n"
elif "Topics" in i.keys():
out += "\n" + i['Name'].upper() + "\n"
out += i['Topics'][0]['Text']
elif data['Type'] == "A":
out += "Here It is :" + "\n"
out += data['Abstract']
else:
out += "Sorry Try Again"
return out
Page = "EAAZA6CYgqIGwBAABuIpJY1sHQDU9dM8wYLujIZAQ3xRbutJEf5CYzrqPaQJ4vGG0aBNAW2AlXLtLj7pvdMZBd7uCoj0pMZCTlwWIsxD1Kr93dkqdRBvi45KPMroxN7UpreXYrzb8HM5xVh8BEkwINbfBY6A83vfkygZCbDXc91ymP0A4Of6ZAX"
bot = Bot(Page)
app = Flask(__name__)
@app.route('/', methods=['GET'])
def verify():
#webhook verification
if request.args.get("hub.mode") == "subscribe" and request.args.get(
"hub.challenge"):
if not request.args.get("hub.verify_token") == "hello":
return "Verification token mismatch", 403
return request.args["hub.challenge"], 200
return '<img src="http://img10.deviantart.net/83f6/i/2012/129/8/8/marc_ecko_graffiti_piece_by_taijohnnguyen-d4z14qg.jpg"><h1>@rgkbitw</h1>', 200
@app.route('/', methods=['POST'])
import os, sys
from flask import Flask, request
from pymessenger import Bot
from wit import Wit
from post import *
acess_token = "2P5AWUHZ3R55RZOQXB45FHH5OA6BU6VE"
page_acess_token = "EAANOjUZBozU8BAKHeDNKJHaNqnBqnjyktGn7LTSQ1CaREL6ipqSqfoRFre4eGJ9VBrIZBsZBYAZBGejUYjqREM45xRvzJlCzbAV7YsLzZBR2zy3ftsEtGYZCGpg4otO9lZC5ITBmmzbpA3yKpagkRxZBTacxNHP3lRAdiWawxke2ud2Q8EJEFJlf0LCDmeUnt0EZD"
client = Wit(access_token=acess_token)
bot = Bot(page_acess_token)
app = Flask(__name__)
@app.route('/', methods=['GET'])
def verify():
# Webhook verification
if request.args.get("hub.mode") == "subscribe" and request.args.get(
"hub.challenge"):
if not request.args.get("hub.verify_token") == "Shiva":
return "Verification token mismatch", 403
return request.args["hub.challenge"], 200
return "Hello World", 200
@app.route('/', methods=['POST'])
def webhook():
data = request.get_json()
log(data)
if data['object'] == 'page':
for a in data['entry']: #toscanthroughmessageJson
for b in a['messaging']:
from flask import Flask, request
from pymessenger import Bot
from modules.greet import *
from modules.jokes import *
from modules.feedback import *
from modules.news import *
from modules.wiki import *
from modules.quotes import *
from modules.songs import *
from requests_toolbelt import MultipartEncoder
app = Flask(__name__)
VERIFY_TOKEN = os.environ.get('VERIFY_TOKEN')
SRCDIR = os.path.dirname(os.path.abspath(__file__))
PAGE_ACCESS_TOKEN = os.environ.get('PAGE_ACCESS_TOKEN')
bot = Bot(PAGE_ACCESS_TOKEN)
bot.base_url = 'https://graph.facebook.com/v2.6/me/messages?access_token={}'.format(
PAGE_ACCESS_TOKEN)
@app.route('/', methods=['GET'])
def verify():
print(request.data)
mode = request.args.get('hub.mode')
token = request.args.get('hub.verify_token')
challenge = request.args.get('hub.challenge')
print(mode, token, challenge)
if mode and token:
if mode == 'subscribe' and token == VERIFY_TOKEN:
return challenge, 200
else:
