class ViberRequestHandler:
_instance = None
def __init__(self):
bot_config = _get_bot_configuration()
self.viber_client = Api(bot_config)
self.state_machine = StateMachine(initial_state=BootStrapState())
@classmethod
def create_instance(cls):
if cls._instance is None:
cls._instance = ViberRequestHandler()
return cls._instance
def parse(self, request):
viber_request = self.viber_client.parse_request(request.body)
if isinstance(viber_request,
(ViberSubscribedRequest, ViberMessageRequest)):
trigger = create_trigger_from_request(viber_request,
self.viber_client)
# получение пользовательского id - viber_request.sender.id
# получение время обращения timestamp - viber_request.timestamp
# сохранение статистики
self.state_machine.fire(trigger)
elif isinstance(viber_request, ViberFailedRequest):
pass
def get_viber(self):
if self._viber_cache is None:
self._viber_cache = Api(BotConfiguration(
name=str(self.slug),
avatar=self.avatar.url,
auth_token=str(self.token)
))
return self._viber_cache
def init_bot():
config = BotConfiguration(
name="Books delivery",
avatar="",
auth_token=settings.BOT_TOKEN
)
bot = Api(config)
return bot
def getCurBotAPIRuntime(bot_config):
global __BOT_API_RUNTIME__
if __BOT_API_RUNTIME__.get(bot_config['api_token']) == None:
# Создаем экземпляр API для бота
bot_configuration = BotConfiguration(
name=bot_config['name'],
avatar='',
auth_token=bot_config['api_token'])
# Создание API для запуска бота
__BOT_API_RUNTIME__[bot_config['api_token']] = Api(bot_configuration)
return __BOT_API_RUNTIME__[bot_config['api_token']]
def replace_auth_token_view():
try:
data = json.loads(flask.request.get_data().decode('utf-8'))
except Exception as error:
logging.error('input data parse error {}'.format(error))
data = {}
name = data.get('name')
avatar = data.get('avatar')
auth_token = data.get('token')
webhook = data.get('webhook')
if auth_token is not None and name is not None and avatar is not None:
try:
viberbot_api = Api(
BotConfiguration(name=name,
avatar=avatar,
auth_token=auth_token))
viberbot_api.set_webhook(url=webhook)
resp = flask.jsonify(message='Auth token успешно заменен',
account=viberbot_api.get_account_info())
resp.status_code = 200
return resp
except Exception as error:
logging.error('replace auth token error: {}'.format(error))
resp = flask.jsonify(error='Auth token не удалось замененить ')
resp.status_code = 404
return resp
resp = flask.jsonify(message='некорректные входные данные {}'.format(
flask.request.get_data()))
resp.status_code = 404
return resp
def SessionClose(message):
system_id = int(re.search("(\d+)", message.text).group(1))
user = db_users.find_one({"_id": message.from_user.id})
if not db_users.find_one({"system id": system_id}):
bot.send_message(message.chat.id, 'Такого пользователя нет')
return
tolker = db_users.find_one({"system id": system_id})
if user['operator']['active session'] == system_id:
user['operator']['active session'] = None
tolker['operator']['active session'] = None
db_users.replace_one({"_id": message.from_user.id}, user, True)
db_users.replace_one({"_id": tolker["_id"]}, tolker, True)
bot.send_message(message.chat.id,
f'Активная сессия с {tolker["name"]} закрыта')
if tolker["messenger"] == "viber":
viber = Api(
BotConfiguration(name=user['operator']['name'],
avatar=cfg.v_avatar,
auth_token=cfg.v_token))
viber.send_messages(tolker["_id"],
[TextMessage(text='Оператор отключился')])
elif tolker["messenger"] == "telegram":
bot.send_message(tolker["_id"],
f"{user['operator']['name']}\nОтключился")
return
if system_id in user['operator']["sessions"]:
user['operator']['sessions'].remove(system_id)
tolker['operator']['active session'] = None
if len(user['operator']["sessions"]) == 0:
user['operator']["sessions"] = None
db_users.replace_one({"_id": message.from_user.id}, user, True)
db_users.replace_one({"_id": tolker["_id"]}, tolker, True)
bot.send_message(message.chat.id, f'Сессия с {tolker["name"]} закрыта')
if tolker["messenger"] == "viber":
viber = Api(
BotConfiguration(name=user['operator']['name'],
avatar=cfg.v_avatar,
auth_token=cfg.v_token))
viber.send_messages(tolker["_id"],
[TextMessage(text='Оператор отключился')])
elif tolker["messenger"] == "telegram":
bot.send_message(tolker["_id"],
f"{user['operator']['name']}\nОтключился")
return
def main():
i18n.load_path.append(os.path.dirname(__file__))
i18n.set('file_format', 'json')
token = None
with open(os.path.dirname(__file__) + '/token_file', 'r') as tokenFile:
token = tokenFile.readline()
app = Flask(__name__)
viber = Api(
BotConfiguration(name=i18n.t(__get_res('botName')),
avatar=i18n.t(__get_res('image-url')),
auth_token=token))
messageSwitcher = MessageSwitcher(viber)
@app.route('/' + token, methods=['POST'])
def incoming():
logger.debug("received request. post data: {0}".format(
request.get_data()))
viber_request = viber.parse_request(request.get_data().decode('utf-8'))
messageSwitcher.disassembleReq(viber_request)
# if isinstance(viber_request, ViberMessageRequest):
# message = viber_request.message
# # lets echo back
# userId = viber_request.sender.id
# sendMessage(viber, userId)
# # viber.send_messages(viber_request.sender.id, [message])
# elif isinstance(viber_request, ViberSubscribedRequest):
# viber.send_messages(viber_request.get_user.id, [
# TextMessage(text="thanks for subscribing!")
# ])
# elif isinstance(viber_request, ViberFailedRequest):
# logger.warn("client failed receiving message. failure: {0}".format(viber_request))
return Response(status=200)
app.run()
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
token = "4723336bb367d06e-ab321ee6503a0206-58d9d2bfcc9b6386"
avatar = 'https://pbs.twimg.com/profile_images/378800000472528007/7e3d601acd34222cd0e1accff4b92d2a_400x400.jpeg'
# test_token='47180bc4e627d501-2fd700adf2113640-bb3e6b0f5459b969'
app = Flask(__name__)
viber = Api(BotConfiguration(name='ГрузоБот', avatar=avatar, auth_token=token))
conn = sqlite3.connect('database.db')
c = conn.cursor()
# ['id','stage','vehicle','time','place','loaders'] varchar
def get_reply(stage, text, user_id):
# по дефолту ответом является сообщение клиента, клавиатуры - нет
reply = "Я тебя не понял!🚚\nStage:{}".format(stage)
keyboard = None
if stage == "1":
c.execute(
"UPDATE users SET vehicle = '', extra='', loaders='', place='', time='' WHERE id = '%s';"
handler = logging.FileHandler('viber bot.log')
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
app = Flask(__name__)
api = flask_restful.Api(app)
'''@app.route("/")
def hello():
return "<h1 style='color:blue'>Hello There!</h1>"'''
TOKEN = '49cc42b11a27d0ba-ccb237ef23e7f055-26665b55f3ebb019'
webhookURL = 'https://ecoviewapp.fvds.ru/'
viber = Api(BotConfiguration(name='ПЭЛ-помощник', avatar='', auth_token=TOKEN))
text_command = ""
select_category = False
OUTPUT_ = {'mass': []}
OUTPUT = {'mass': []}
name_razdel = ""
@app.route('/', methods=["POST"])
def incoming():
#global output_
logger.debug("received request. post data: {0}".format(request.get_data()))
# every viber message is signed, you can verify the signature using this method
if not viber.verify_signature(
request.get_data(),
def test_parse_request_not_json():
viber = Api(VIBER_BOT_CONFIGURATION)
with pytest.raises(ValueError) as exc:
viber.parse_request("dsfdfdsf\#")
def test_verify_signature_failure():
invalid_signature = 'aaaaaaaaaaaaaaaaaaaaaa'
message = "{\"event\":\"webhook\"}".encode("utf-8")
viber = Api(VIBER_BOT_CONFIGURATION)
assert not viber.verify_signature(message, invalid_signature)
def create_viber_api(self, bot_configuration):
return Api(bot_configuration)
from viberbot import Api
from viberbot.api.bot_configuration import BotConfiguration
import Constants
viber = Api(BotConfiguration(
name=Constants.BOT_NAME,
avatar=Constants.AVATAR_URL,
auth_token=Constants.AUTH_TOKEN
))
viber.set_webhook("https://f2056b99634f.ngrok.io")
class Viber(ChatIface):
def __init__(self, web_url, web_config=('0.0.0.0', 8080)):
super().__init__()
self.thread = None
self.token = os.environ.get('VIBER_TOKEN')
if self.token is None:
raise Exception('VIBER_TOKEN env variable is nil.')
self.bot_configuration = BotConfiguration(
name=os.environ.get('VIBER_NAME'),
avatar='https://static.thenounproject.com/png/363639-200.png',
auth_token=self.token)
self.api = None
self.app = Flask(__name__)
self.web_config = web_config
self.web_url = web_url
self.setup_routes()
self.last_message = None
self.initial_button_text = "I want to book a hotel"
def run(self):
web_config = self.web_config
self.thread = threading.Thread(target=self.start)
self.thread.start()
self.api = Api(self.bot_configuration)
logging.info("Setting viber hook to: %s", self.web_url)
evtypes = self.api.set_webhook(
self.web_url, webhook_events=['conversation_started', 'message'])
viber_account = self.api.get_account_info()
logging.info("Registered ev types: %s", evtypes)
logging.info("Account info: %s", viber_account)
def start(self):
web_config = self.web_config
self.app.run(host=web_config[0],
port=web_config[1],
debug=True,
use_reloader=False)
# Message handlers
#
# Conversation start allows only 1 message before a subscription
def _on_start(self, user_id):
viber = self.api
d = self.get_dialog(user_id)
g = d.start()
d.on_searching(
lambda details: self._callback_on_searching(user_id, details))
keyboard_msg = self.get_initial_keyboard(user_id)._keyboard
viber.send_messages(user_id, [
TextMessage(text=g, keyboard=keyboard_msg),
])
def _on_message(self, user_id, message):
# Make sure our dialog is setup.
d = self.get_dialog(user_id)
d.on_searching(
lambda details: self._callback_on_searching(user_id, details))
try:
# Process the message
is_done, rz = self.process_message(user_id, message)
r = [rx for rx in listify(rz) if rx is not None]
# Send replies
if is_done and r is not None and len(r) > 0:
last_response = r[len(r) - 1]
last_response.buttons = [self.initial_button_text]
self.send_replies(user_id, r)
except Exception as ex:
tb = traceback.format_exc()
logging.info(tb)
logging.info(ex)
self.send_replies(user_id, "Sorry can you try a different phrase?")
def _callback_on_searching(self, user_id, details):
viber = self.api
logging.info("Starting search at %s", details)
place = details['location'].capitalize()
t = details['type']
if len(t) == 0:
txtmsg = TextMessage(
text="Great. Here are a few places for you to stay in {0}..".
format(place))
viber.send_messages(user_id, [txtmsg])
else:
txtmsg = TextMessage(
text="Great. I'll start searching for {0} in {1}..".format(
'placest to stay', place))
viber.send_messages(user_id, [txtmsg])
def send_img(self,
user_id,
rep: dialog.dialog.Reply,
keyboard: KeyboardMessage = None):
viber = self.api
imglist = rep.img
if not isinstance(imglist, list):
imglist = [imglist]
img = imglist[0]
if img is None:
return
img_url = img['url']
k = None
if keyboard is not None:
k = keyboard._keyboard
pmsg = PictureMessage(text=rep.text, media=img_url, keyboard=k)
viber.send_messages(user_id, [pmsg])
def send_keyboard(self, user_id, keyboard):
viber = self.api
try:
viber.send_messages(user_id, [keyboard])
except:
tb = traceback.format_exc()
logging.info(tb)
logging.info(ex)
def send_replies(self, user_id, replies):
viber = self.api
if not isinstance(replies, list): replies = [replies]
for rep in replies:
if isinstance(rep, str):
rep = dialog.dialog.msg_reply(rep)
reply_text = rep.str()
if reply_text == "":
reply_text = "Can you try again with a different phrase?"
logging.info("REPL[%s]: %s", rep.type, rep)
self.send_reply(rep, reply_text, user_id)
def send_on_done(self, user_id):
init_kbd = self.get_initial_keyboard(user_id)
viber = self.api
viber.send_messages(user_id, [init_kbd])
def send_reply(self, rep, reply_text, user_id):
viber = self.api
if rep.type == 'place':
# Send the image and a button for the user to confirm or reject
kbd = self.get_place_keyboard(user_id, rep.buttons)
if rep.img:
self.send_img(user_id, rep, keyboard=kbd)
else:
txtmsg = TextMessage(text=str(reply_text), keyboard=kbd)
viber.send_messages(user_id, [txtmsg])
elif rep.type == 'place_list':
logging.info("Reply itinerary: %s", reply_text)
txtmsg = TextMessage(text=str(reply_text),
keyboard=buttons_to_keyboard(rep.buttons))
viber.send_messages(user_id, [txtmsg])
elif rep.type == 'interest_question':
txtmsg = TextMessage(text=str(reply_text),
keyboard=buttons_to_keyboard(rep.buttons))
viber.send_messages(user_id, [txtmsg])
else:
rkbd = buttons_to_keyboard(rep.buttons)
logging.info("KBD: %s", rkbd)
txtmsg = TextMessage(text=str(reply_text), keyboard=rkbd)
viber.send_messages(user_id, [txtmsg])
def setup_routes(self):
app = self.app
@app.route('/', methods=['POST'])
def incoming():
import json
viber = self.api
data = request.get_data()
logging.info("received request. post data: {0}".format(data))
# every viber message is signed, you can verify the signature using this method
if not viber.verify_signature(
request.get_data(),
request.headers.get('X-Viber-Content-Signature')):
return Response(status=403)
request_dict = json.loads(data)
# this library supplies a simple way to receive a request object
viber_request = viber.parse_request(data)
if isinstance(viber_request, ViberConversationStartedRequest):
user_id = viber_request.user.id
self._on_start(user_id)
elif isinstance(viber_request, ViberSeenRequest):
pass
elif isinstance(viber_request, ViberDeliveredRequest):
pass
elif isinstance(viber_request, ViberMessageRequest):
sender_id = viber_request.sender.id
message = viber_request.message
# We need unique messages
if isinstance(message, TextMessage):
ts = int(request_dict['timestamp'])
is_old = (self.last_message is not None
and (self.last_message[2] == ts)
and self.last_message[1] == sender_id)
cr_pair = (message.text, sender_id, ts)
# logging.info("MSG DUMP: %s", cr_pair)
# logging.info("LAST DUMP: %s", self.last_message)
# logging.info("DUP: %s", is_old)
if not is_old:
self.last_message = cr_pair
self._on_message(sender_id, message.text)
# self.last_message = cr_pair
elif isinstance(viber_request, ViberFailedRequest):
logging.warn(
"client failed receiving message. failure: {0}".format(
viber_request))
return Response(status=200)
@app.route('/incoming', methods=['POST'])
def incomingUrl():
logging.debug("received request. post data: {0}".format(
request.get_data()))
# handle the request here
return Response(status=200)
@app.route('/health-check', methods=['GET'])
def health():
logging.debug("Health-check")
# handle the request here
return Response(status=200)
def get_place_keyboard(self, user_id, additional_buttons=None):
import json
buttons = [{
"Columns": 2,
"Rows": 2,
"Text": "<font color=\"#494E67\">Confirm</font>",
"TextSize": "medium",
"TextHAlign": "center",
"TextVAlign": "middle",
"ActionType": "reply",
"ActionBody": "Yes",
"BgColor": "#f7bb3f",
}, {
"Columns": 2,
"Rows": 2,
"Text": "<font color=\"#494E67\">Next</font>",
"TextSize": "medium",
"TextHAlign": "center",
"TextVAlign": "middle",
"ActionType": "reply",
"ActionBody": "No",
"BgColor": "#f6f7f9",
}, {
"Columns": 2,
"Rows": 2,
"Text": "<font color=\"#494E67\">Stop</font>",
"TextSize": "medium",
"TextHAlign": "center",
"TextVAlign": "middle",
"ActionType": "reply",
"ActionBody": "Stop",
"BgColor": "#f6f7f9",
}]
if additional_buttons:
buttons.extend([{
"Columns": 2,
"Rows": 2,
"Text": "<font color=\"#494E67\">" + b + "</font>",
"ActionBody": b,
} for b in additional_buttons])
keyboard = {
"DefaultHeight": True,
"BgColor": "#FFFFFF",
"Type": "keyboard",
"Buttons": buttons
}
msg = KeyboardMessage(keyboard=keyboard)
return msg
def get_initial_keyboard(self, user_id):
keyboard = {
"Type":
"keyboard",
"Buttons": [{
"Columns":
6,
"ActionType":
"reply",
"Rows":
1,
"Text":
"<font color=\"#494E67\">" + self.initial_button_text +
"</font>",
"TextSize":
"medium",
"TextHAlign":
"center",
"TextVAlign":
"middle",
"ActionBody":
self.initial_button_text,
}]
}
msg = KeyboardMessage(keyboard=keyboard)
return msg
from Settings import TOKEN, WEBHOOK
from viberbot import Api
from viberbot.api.bot_configuration import BotConfiguration
bot_configuration = BotConfiguration(name='MyLearnEnglishBot4',
avatar='http://viber.com/avatar.jpg',
auth_token=TOKEN)
viber = Api(bot_configuration)
print('setting webhook: ' + WEBHOOK)
viber.set_webhook(WEBHOOK)
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
user_amator = {}
app = Flask(__name__)
viber = Api(
BotConfiguration(
name='ST Amator',
avatar='http://viber.com/avatar.jpg',
auth_token='4daa90c76a27d2bd-da20e99cc428dc26-491a88d6cd292369'))
@app.route('/', methods=['POST'])
def incoming():
logger.debug("Получил запрос. Отправка данных: {0}".format(
request.get_data()))
viber_request = viber.parse_request(request.get_data())
viber_request = viber.parse_request(request.get_data().decode('utf8'))
global user_amator
if len(user_amator) == 0:
user_amator = file_io("read", user_amator, "StartBot")
import os
import utils.settings
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
last_token = 0
last_token_track = 0
app = Flask(__name__)
viber = Api(BotConfiguration(
name=utils.settings.name,
avatar=utils.settings.avatar,
auth_token=utils.settings.auth_token
))
@app.route('/', methods=['POST'])
def incoming():
global last_token
global last_token_track
logger.debug("received request. post data: {0}".format(request.get_data()))
viber_request = viber.parse_request(request.get_data().decode('utf8'))
if isinstance(viber_request, ViberMessageRequest):
message = viber_request.message
token = viber_request.message_token
contents = ["text", "sticker", "document", "photo", "audio", "voice"]
client = MongoClient()
db = client.FeedBot
db_users = db.users
db_settings = db.settings
logging.remove()
logging.add(sys.stdout, colorize=True, format="<green>{time:DD.MM.YY H:mm:ss}</green> " \
"| <yellow><b>{level}</b></yellow> | <magenta>{file}:{line}</magenta> | <cyan>{message}</cyan>")
logging.add(
"./log/bot.log",
rotation="50 MB",
format="{time:DD.MM.YY H:mm:ss} | {level} | {file}:{line} | {message}")
bot = telebot.TeleBot(cfg.token)
app = Flask(__name__)
viber = Api(
BotConfiguration(name='BotName',
avatar=cfg.v_avatar,
auth_token=cfg.v_token))
@app.route('/telega', methods=['POST'])
def TelegramIncoming():
try:
if not request.headers.get('content-type') == 'application/json':
abort(403)
logging.debug(f"Telegram data: {request.get_data().decode('utf-8')}")
json_string = request.get_data().decode('utf-8')
update = telebot.types.Update.de_json(json_string)
if update.message is not None:
user_update(update.message, 'telegram')
#user = db_users.find_one({"_id": update.message.from_user.id})
#result = MessageBox.Message(bot, viber, update.message, user)
from dotenv import load_dotenv
load_dotenv()
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
app = Flask(__name__)
viber = Api(
BotConfiguration(name=os.getenv('BOT_NAME'),
avatar='http://viber.com/avatar.jpg',
auth_token=os.getenv('AUTH_TOKEN')))
keyboard = {
"DefaultHeight":
False,
"BgColor":
"#222222",
"Type":
"keyboard",
"Buttons": [{
"Columns": 2,
"Rows": 2,
"Text": "<br><font color=\"#494E67\"><b>ASIAN</b></font>",
"TextSize": "large",
"TextHAlign": "center",
class ViberChatBot(ChatBot):
def __init__(self):
name = 'Guide'
avatar = 'https://st2.depositphotos.com/'\
'3146979/9765/v/950/depositphotos_97658722'\
'-stock-illustration-vector-round-icon-pile-of.jpg'
auth_token = os.environ['VIBER_AUTH_TOKEN']
viber_bot_config = BotConfiguration(name=name,
avatar=avatar,
auth_token=auth_token)
self.viber_bot = Api(viber_bot_config)
def get_message(self, request):
signature = request.headers.get('X-Viber-Content-Signature')
if not self.viber_bot.verify_signature(request.get_data(), signature):
raise 'Invalid Signature!', signature
viber_request = self.viber_bot.parse_request(request.get_data())
if isinstance(viber_request, ViberMessageRequest):
user_id = viber_request.sender.id
text = viber_request.message.text
return {'user_id': user_id, 'text': text}
elif isinstance(viber_request, ViberSubscribedRequest):
pass
elif isinstance(viber_request, ViberSeenRequest):
pass
elif isinstance(viber_request, ViberDeliveredRequest):
pass
elif isinstance(viber_request, ViberFailedRequest):
raise 'client failed receiving message. failure: {0}'.format(
viber_request)
else:
pass
def send_message(self, user_id, answer):
viber_answer = []
if 'text' in answer:
text_message = TextMessage(text=answer['text'])
viber_answer.append(text_message)
if 'image' in answer:
url_prefix = 'https://drive.google.com/uc?export=download&id='
image_url = url_prefix + answer['image']
picture_message = PictureMessage(media=image_url)
viber_answer.append(picture_message)
if 'options' in answer:
keyboard = self.create_keyboard(answer['options'])
keyboard_message = KeyboardMessage(tracking_data=None,
keyboard=keyboard)
viber_answer.append(keyboard_message)
self.viber_bot.send_messages(user_id, viber_answer)
def create_keyboard(self, connections):
keyboard = {}
keyboard['Type'] = 'keyboard'
keyboard['Buttons'] = map(self.create_button, connections)
return keyboard
def create_button(self, connection):
button = {}
button['Columns'] = 6
button['Rows'] = 1
button['Text'] = '<font color="#000000"><b>' + \
connection + '</b></font>'
button['TextSize'] = 'large'
button['TextHAlign'] = 'center'
button['TextVAlign'] = 'middle'
button['ActionType'] = 'reply'
button['ActionBody'] = connection
button['BgColor'] = '#b9e6f5'
return button
"""
Viber bot API configuration
It is possible to change bot configuration file by setting VIBER_CONF
environment variable.
"""
import os
import sys
from viberbot import Api
from viberbot.api.bot_configuration import BotConfiguration
from viber_command_bot.config import config
viber = Api(
BotConfiguration(auth_token=config['Viber']['authentication_token'],
name=config['Viber']['name'],
avatar=config['Viber']['avatar']))
ViberConversationStartedRequest,
ViberMessageRequest,
ViberSubscribedRequest)
from .handlers import user_message_handler
from .resources import texts
from .resources import keyboards_content as kb
from loguru import logger
logger.add('logs/info.log',
format='{time} {level} {message}',
level='INFO',
rotation="1 MB",
compression='zip')
viber = Api(
BotConfiguration(name='TopCrew',
avatar='https://i.imgur.com/xVxrShr.jpg',
auth_token=settings.VIBER_TOKEN))
@csrf_exempt
def viber_app(request):
"""Catching all requests to bot and defining the request type."""
if not viber.verify_signature(
request.body, request.headers.get('X-Viber-Content-Signature')):
return HttpResponse(status=403)
viber_request = viber.parse_request(request.body)
# Defining type of the request and replying to it
if isinstance(viber_request, ViberMessageRequest):
# Passing any message from user to message handler in handlers.py
user_message_handler(viber, viber_request)
elif isinstance(viber_request, ViberSubscribedRequest):
import answer_types
from cart import Cart
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
app = Flask(__name__)
viber = Api(
BotConfiguration(
name='PythonSampleBot',
avatar='',
auth_token='45decab4eff228d7-e86f8a81930047f7-8e75c34b9894d46e'))
@app.route('/', methods=['POST'])
def incoming():
request_data = request.get_data().decode()
logger.debug("received request. post data: {0}".format(request_data))
viber_request = viber.parse_request(request_data)
request_json = json.loads(request_data)
msg = TextMessage(text='Выберите пункт меню', keyboard=MAIN_MENU)
if isinstance(viber_request, ViberMessageRequest):
def create_viber_api(self, configuration):
return Api(configuration)
import time
import logging
import sched
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
app = Flask(__name__)
viber = Api(
BotConfiguration(
name='PythonBot',
avatar=
'http://cs9.pikabu.ru/images/big_size_comm/2017-01_7/1485863230198053474.jpg',
auth_token='46035a5801f49064-54a5b815877ccb4d-176654aa2704e14a'))
# dictionary where key is an class of Viber and value is a key from event_queues_dict
subscribers_dict = {}
# incoming queues of all processes
event_queues_dict = {}
@app.route('/', methods=['POST'])
def incoming():
logger.debug("received request. post data: {0}".format(request.get_data()))
viber_request = viber.parse_request(request.get_data())
from viberbot.api.bot_configuration import BotConfiguration
from viberbot.api.messages import VideoMessage
from viberbot.api.messages.text_message import TextMessage
import logging
import json
from viberbot.api.viber_requests import ViberConversationStartedRequest
from viberbot.api.viber_requests import ViberFailedRequest
from viberbot.api.viber_requests import ViberMessageRequest
from viberbot.api.viber_requests import ViberSubscribedRequest
from viberbot.api.viber_requests import ViberUnsubscribedRequest
application = Flask(__name__)
viber = Api(
BotConfiguration(
name='PythonSampleBot',
avatar=
'http://media.wplm.pl/pictures/wp/photo/2012-10/414/414/hammer_and_sicklesvg.jpg',
auth_token='47903e4860a7d433-88367fbaec064c17-feb50e42a2f20d9c'))
@application.route("/", methods=['POST'])
def hello():
viber_request = viber.parse_request(request.get_data())
if isinstance(viber_request, ViberMessageRequest):
message = viber_request.message
# lets echo back
viber.send_messages(viber_request.sender.id, [message])
viber.send_messages(viber_request.get_user.id,
[TextMessage(text="thanks for subscribing!")])
from viberbot import Api
from viberbot.api.bot_configuration import BotConfiguration
from django.conf import settings
bot_configuration = BotConfiguration(
name='PipBot',
avatar='https://www.prostir.ua/wp-content/uploads/2019/07/chatbot.png',
auth_token=settings.VIBER_TOKEN
)
viber = Api(bot_configuration)
def set_webhook():
webhook_events = [
"failed",
"subscribed",
"unsubscribed",
"conversation_started"
]
viber.set_webhook('https://83e62f218da8.ngrok.io/bot/callback/', webhook_events=webhook_events)
url='https://%s%s' %
(config.SERVER_NAME, config.TELEGRAM_BOT_WEBHOOK),
max_connections=100)
except Exception as e:
logging.warning(e)
else:
telegram_service = None
if config.TELEGRAM_STRANGERGEO_ENABLED:
strangergeo_service = TeleBot(config.TELEGRAM_STRANGERGEO_KEY,
threaded=False)
try:
strangergeo_service.set_webhook(
url='https://%s%s' %
(config.SERVER_NAME, config.TELEGRAM_STRANGERGEO_WEBHOOK),
max_connections=100)
except Exception as e:
logging.warning(e)
else:
strangergeo_service = None
if config.VIBER_BOT_ENABLED:
viber_service = ViberApi(
ViberBotConfiguration(name=config.VIBER_BOT_NAME,
avatar='http://viber.com/avatar.jpg',
auth_token=config.VIBER_BOT_TOKEN))
viber_service.set_webhook('https://%s%s' %
(config.SERVER_NAME, config.VIBER_BOT_WEBHOOK))
else:
viber_service = None
class Viber(BaseMessenger):
"""
IM connector for Viber Bot API
"""
# region Interface
def __init__(self, token: str, **kwargs):
super().__init__(token, **kwargs)
self.bot = Api(
BotConfiguration(
auth_token=token,
name=kwargs.get('name'),
avatar=kwargs.get('avatar'),
))
def enable_webhook(self, url: str, **kwargs):
return self.bot.set_webhook(url=url)
def disable_webhook(self):
return self.bot.unset_webhook()
def get_account_info(self) -> Dict[str, Any]:
# data = {
# "status":0,
# "status_message":"ok",
# "id":"pa:75346594275468546724",
# "name":"account name",
# "uri":"accountUri",
# "icon":"http://example.com",
# "background":"http://example.com",
# "category":"category",
# "subcategory":"sub category",
# "location":{
# "lon":0.1,
# "lat":0.2
# },
# "country":"UK",
# "webhook":"https://my.site.com",
# "event_types":[
# "delivered",
# "seen"
# ],
# "subscribers_count":35,
# "members":[
# {
# "id":"01234567890A=",
# "name":"my name",
# "avatar":"http://example.com",
# "role":"admin"
# }
# ]
# }
try:
data = self.bot.get_account_info()
except Exception as err:
raise MessengerException(err)
return {
'id': data.get('id'),
'username': data.get('name'),
'uri': data.get('uri'), # check this
'info': data
}
def get_user_info(self, user_id: str, **kwargs) -> Dict[str, Any]:
# data = {
# "id":"01234567890A=",
# "name":"John McClane",
# "avatar":"http://avatar.example.com",
# "country":"UK",
# "language":"en",
# "primary_device_os":"android 7.1",
# "api_version":1,
# "viber_version":"6.5.0",
# "mcc":1,
# "mnc":1,
# "device_type":"iPhone9,4"
# }
try:
data = self.bot.get_user_details(user_id)
except Exception as err:
if 'failed with status: 12' in str(err):
raise RequestsLimitExceeded(err)
raise MessengerException(err)
return {
'id': data.get('id'),
'username': data.get('name'),
'avatar': data.get('avatar'),
'info': data,
}
def parse_message(self, request: HttpRequest) -> Message:
# Verify signature
sign = request.META.get('HTTP_X_VIBER_CONTENT_SIGNATURE')
data = json.loads(request.body)
if not self.bot.verify_signature(request.body, sign):
raise MessengerException(f'Viber message not verified; '
f'Data={data}; Sign={sign};')
return self._from_viber_message(self.bot.create_request(data))
def send_message(self, receiver: str,
messages: Union[Message, List[Message]]) -> List[str]:
if isinstance(messages, MessageList):
messages = messages.as_list()
elif isinstance(messages, Message):
messages = [messages]
vb_messages = []
for message in messages:
vb_messages.append(self._to_viber_message(message))
try:
return self.bot.send_messages(receiver, vb_messages)
except Exception as err:
if 'failed with status: 6, message: notSubscribed' in str(err):
raise NotSubscribed(err)
raise MessengerException(err)
def welcome_message(self, text: str) -> Union[str, Dict[str, Any], None]:
return {
"sender": {
"name": self.name,
"avatar": self.avatar_url
},
"type": "text",
"text": text
}
# endregion
# region Help methods
@staticmethod
def _from_viber_message(vb_request: ViberRequest) -> Message:
if isinstance(vb_request, vbr.ViberMessageRequest):
assert isinstance(vb_request.message, TypedMessage)
vb_message = vb_request.message
if isinstance(vb_message, vbm.TextMessage):
if 'btn-' in vb_message.text:
return Button(id=vb_request.message_token,
user_id=vb_request.sender.id,
timestamp=vb_request.timestamp,
command=vb_message.text)
return Text(id=vb_request.message_token,
user_id=vb_request.sender.id,
timestamp=vb_request.timestamp,
text=vb_message.text)
elif isinstance(vb_message, vbm.PictureMessage):
return Picture(id=vb_request.message_token,
user_id=vb_request.sender.id,
timestamp=vb_request.timestamp,
file_url=vb_message.media)
elif isinstance(vb_message, vbm.VideoMessage):
return Video(id=vb_request.message_token,
user_id=vb_request.sender.id,
timestamp=vb_request.timestamp,
file_url=vb_message.media,
file_size=vb_message.size)
elif isinstance(vb_message, vbm.FileMessage):
return File(id=vb_request.message_token,
user_id=vb_request.sender.id,
timestamp=vb_request.timestamp,
file_url=vb_message.media,
file_size=vb_message.size)
elif isinstance(vb_message, vbm.RichMediaMessage):
return RichMedia(id=vb_request.message_token,
user_id=vb_request.sender.id,
timestamp=vb_request.timestamp,
text=vb_message.alt_text,
rich_media=vb_message.rich_media)
elif isinstance(vb_message, vbm.ContactMessage):
return Contact(id=vb_request.message_token,
user_id=vb_request.sender.id,
timestamp=vb_request.timestamp,
contact=vb_message.contact)
elif isinstance(vb_message, vbm.LocationMessage):
return Location(id=vb_request.message_token,
user_id=vb_request.sender.id,
timestamp=vb_request.timestamp,
location=vb_message.location)
elif isinstance(vb_message, vbm.URLMessage):
return Url(id=vb_request.message_token,
user_id=vb_request.sender.id,
timestamp=vb_request.timestamp,
url=vb_message.media)
elif isinstance(vb_message, vbm.StickerMessage):
return Sticker(id=vb_request.message_token,
user_id=vb_request.sender.id,
timestamp=vb_request.timestamp,
file_id=vb_message.sticker_id)
return Text(id=vb_request.message_token,
user_id=vb_request.sender.id,
timestamp=vb_request.timestamp,
text=str(vb_message))
elif isinstance(vb_request, vbr.ViberConversationStartedRequest):
return Event(id=vb_request.message_token,
user_id=vb_request.user_id,
timestamp=vb_request.timestamp,
event_type=EType.START,
user_name=vb_request.user.name,
context=vb_request.context)
elif isinstance(vb_request, vbr.ViberSubscribedRequest):
return Event(id=vb_request.message_token,
user_id=vb_request.user_id,
timestamp=vb_request.timestamp,
event_type=EType.SUBSCRIBED,
user_name=vb_request.user.name)
elif isinstance(vb_request, vbr.ViberUnsubscribedRequest):
return Event(id=vb_request.message_token,
user_id=vb_request.user_id,
timestamp=vb_request.timestamp,
event_type=EType.UNSUBSCRIBED)
elif isinstance(vb_request, vbr.ViberDeliveredRequest):
return Event(id=vb_request.message_token,
user_id=vb_request.user_id,
timestamp=vb_request.timestamp,
event_type=EType.DELIVERED)
elif isinstance(vb_request, vbr.ViberSeenRequest):
return Event(id=vb_request.message_token,
user_id=vb_request.user_id,
timestamp=vb_request.timestamp,
event_type=EType.SEEN)
elif isinstance(vb_request, vbr.ViberFailedRequest):
log.warning(f'Client failed receiving message; Error={vb_request}')
return Event(id=vb_request.message_token,
user_id=vb_request.user_id,
timestamp=vb_request.timestamp,
event_type=EType.START,
context=vb_request.desc)
elif vb_request.event_type == 'webhook':
return Event(timestamp=vb_request.timestamp)
log.warning(f'ViberRequest type={type(vb_request)}; '
f'Object={vb_request};')
return Text(timestamp=vb_request.timestamp, text=str(vb_request))
def _to_viber_message(self, message: Message) -> VbMessage:
kb = self._get_keyboard(message.buttons)
if isinstance(message, Text):
return vbm.TextMessage(text=message.text, keyboard=kb)
if isinstance(message, Sticker):
return vbm.StickerMessage(sticker_id=message.file_id, keyboard=kb)
elif isinstance(message, Picture):
return vbm.PictureMessage(media=message.file_url,
text=message.text,
keyboard=kb)
elif isinstance(message, Video):
return vbm.VideoMessage(media=message.file_url,
size=message.file_size,
text=message.text,
keyboard=kb)
elif isinstance(message, (File, Audio)):
return vbm.FileMessage(media=message.file_url,
size=message.file_size or 0,
file_name=message.file_name or '',
keyboard=kb)
elif isinstance(message, Contact):
contact = message.contact
return vbm.ContactMessage(contact=contact, keyboard=kb)
elif isinstance(message, Url):
return vbm.URLMessage(media=message.url, keyboard=kb)
elif isinstance(message, Location):
location = message.location
return vbm.LocationMessage(location=location, keyboard=kb)
elif isinstance(message, RichMedia):
rich_media = message.rich_media
return vbm.RichMediaMessage(rich_media=rich_media,
alt_text=message.text,
keyboard=kb)
@staticmethod
def _get_keyboard(buttons: List[Button]) -> Optional[Dict[str, Any]]:
# TODO do refactoring
if not buttons:
return None
vb_buttons = []
for button in buttons:
# assert isinstance(button, Button), f'{button=} {type(button)}'
vb_btn = {
'Columns':
2, # TODO: how is it storage in Model?
'Rows':
1,
'BgColor':
'#aaaaaa',
'ActionType':
'reply',
'ActionBody':
button.command,
'Text':
'<font color="{clr}"><b>{text}'
'</b></font>'.format(text=button.text, clr='#131313'),
'TextVAlign':
'middle',
'TextHAlign':
'center',
'TextOpacity':
60,
'TextSize':
'large',
'TextPaddings': [12, 8, 8, 20], # [up, left, right, bottom]
}
if hasattr(button, 'image'):
domain = Site.objects.get_current().domain
vb_btn.update({
'BgMedia': f'https://{domain}{button.image}',
'BgMediaScaleType': 'fill'
})
vb_buttons.append(vb_btn)
return {
'Type': 'keyboard',
'BgColor': '#ffffff',
'min_api_version': 6,
'Buttons': vb_buttons,
}
from viberbot.api.viber_requests import ViberSubscribedRequest
from viberbot.api.viber_requests import ViberUnsubscribedRequest
import time
import logging
import sched
import threading
"""
Переменная webApp определяется как экземпляр класса Flask в сценарии __init__.py,
что делает его частью пакета приложения.
"""
app = Flask(__name__)
app.config.from_object(Config)
viber = Api(
BotConfiguration(name=ViberBotConfig().name,
avatar=ViberBotConfig().avatar,
auth_token=ViberBotConfig().auth_token))
def set_webhook(viber):
viber.set_webhook('https://egissoshechka.herokuapp.com:443')
logging.info("Web hook has been set")
#webApp.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
#webApp.config['SECRET_KEY'] = "random string"
"""
Импорт модуля представлений
view — это разные URL-адреса, которые приложение реализует.
"""
from egissoshechka.app import view
