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: