def __init__(self):
self.replics = Replics()
self.rooms_count = 20
self.game_objects = {}
self.game_spacegame_rooms = {}
self.game_user = {}
self.n_rooms_bats = 2
self.n_rooms_holes = 2
self.n_rooms_troll = 1
def __init__(self):
"""Constructor"""
self.textProcessor = TextProcessor()
self.search = searchProcessor()
self.tonque = Tonque()
self.users = UserProcessor()
self.replics = Replics()
self.funnel = funnelProcessor()
self.timertask = TimerProcessor()
self.playlist = PlaylistProcessor()
self.tracker = gaTracker()
def __init__(self):
self.playlist = PlaylistProcessor()
self.replics = Replics()
class TimerProcessor:
"""Управление заданиями таймера"""
def __init__(self):
self.playlist = PlaylistProcessor()
self.replics = Replics()
def timer_start(self, chat_id, command_id, message_id=0):
url = self.playlist.get_random_link(chat_id)
task_data = {
'start': datetime.now(),
'chat_id': chat_id,
'message_id': message_id,
'status': 1,
'url': url,
'lenght': 25
}
task = TimerTask(**task_data)
task.save()
response = self.replics.tomato_start(chat_id, url)
response['message_id'] = message_id
return response
def timer_checktime(self, chat_id, command_id, message_id=0):
task = self.update_status(chat_id, message_id)
response = self.replics.tomato_checktime(chat_id, task)
response['message_id'] = message_id
return response
def timer_update(self, chat_id, command_id, message_id=0):
task = self.update_status(chat_id)
response = self.replics.tomato_update(chat_id, task)
response['message_id'] = message_id
return response
def timer_delete(self, chat_id, command_id, message_id=0):
response = self.replics.tomato_delete(chat_id)
query = TimerTask.delete().where(TimerTask.chat_id == chat_id).where(
TimerTask.message_id == message_id)
query.execute()
response['message_id'] = message_id
return response
def open_last_task(self, chat_id, message_id):
if message_id > 0:
t = TimerTask.select().where(TimerTask.chat_id == chat_id)\
.where(TimerTask.message_id == message_id).order_by(TimerTask.id.desc()).dicts()
else:
t = TimerTask.select().where(TimerTask.chat_id == chat_id)\
.order_by(TimerTask.id.desc()).dicts()
if len(t):
t = t.get()
return t
def get_time_remain(self, task):
timer_end = task['start'] + timedelta(seconds=task['lenght'] * 60)
timer_remain = timer_end - datetime.now()
return timer_remain.total_seconds()
def update_status(self, chat_id, message_id=0):
last_task = self.open_last_task(chat_id, message_id)
time_remain = self.get_time_remain(last_task)
last_task['time_remain'] = time_remain
last_task['time_remain_min'] = round(time_remain / 60)
return last_task
class processChat:
def __init__(self):
"""Constructor"""
self.textProcessor = TextProcessor()
self.search = searchProcessor()
self.tonque = Tonque()
self.users = UserProcessor()
self.replics = Replics()
self.funnel = funnelProcessor()
self.timertask = TimerProcessor()
self.playlist = PlaylistProcessor()
self.tracker = gaTracker()
def response(self, json_string):
update = types.Update.de_json(json_string)
try:
if update.callback_query is not None:
self.send_debug('process_callback')
response = self.process_callback(update.callback_query)
chat_id = update.callback_query.message.chat.id
else:
self.send_debug('process')
response = self.process(update.message)
chat_id = update.message.from_user.id
if 'message_id' in response:
message_id = response['message_id']
del response['message_id']
self.tonque.edit_message_text(chat_id, message_id, response)
else:
self.tonque.send_message(chat_id, response)
self.tracker.storeInputMessage(update.message)
except Exception as e:
self.tracker.storeInputMessage(str(e))
return str(e) + str(update.message)
return response
def process(self, message):
"""Принимает запрос пользователя и отдает ответ в виде словаря с ключем text и markup"""
response = None
# if message.text[0] != '/':
self.users.user_update(message, message.from_user.id)
if message.reply_to_message is not None:
return self.message_from_admin(message)
chat_id = message.chat.id
self.send_debug('textProcessor')
text, text_raw, emoji = self.textProcessor.get_content(message)
self.send_debug('add_context')
text = self.funnel.add_context(chat_id, text)
self.send_debug('handle_request')
meaning_nodes = self.search.handle_request(text, d_type='words')
self.send_debug(str(meaning_nodes))
if len(meaning_nodes) > 0:
if self.check_reset(meaning_nodes[0]):
self.send_debug('process_reset')
##Собщение об отмене действия
response = self.process_reset(chat_id, meaning_nodes[0], text)
else:
##Проверка воронки
self.send_debug('process_funnel')
meaning_defined, response = self.process_funnel(
chat_id, 0, text, 'text_raw')
if meaning_defined:
return response
else:
self.send_debug('process_function')
##Проверка воронки
response = self.process_function(chat_id, meaning_nodes[0],
text)
else:
self.send_debug('process_not_defined')
response = self.not_defined(chat_id, message.message_id, text)
return response
def process_callback(self, callback_query):
"""Обработка Коллбэка для inline кнопок"""
response = None
message_id = callback_query.message.message_id
chat_id = callback_query.message.chat.id
command_split = callback_query.data.split('_')
try:
if len(command_split) > 1:
callback_types = {
'start': self.timertask.timer_start,
'checktime': self.timertask.timer_checktime,
'delete': self.timertask.timer_delete,
'addlink': self.playlist.playlist_confirm,
'droplink': self.playlist.playlist_drop
}
if command_split[0] in callback_types:
functionName = callback_types[command_split[0]]
response = functionName(chat_id, command_split[1],
message_id)
except Exception as e:
response = {'text': '_process_callback ' + str(e)}
return response
def process_function(self, user_id, meaning, text):
"""Обработка функци назначенных интентам в common.js"""
self.send_debug('process_function')
functions = {
'drop': self.process_reset,
'hello': self.process_hello,
'playlist': self.process_playlist,
'tomato': self.process_tomato,
'feedback': self.process_feedback
}
if meaning['function'] in functions:
function_name = functions[meaning['function']]
response = function_name(user_id, meaning, text)
else:
response = self.process_text(user_id, meaning, text)
return response
def process_text(self, user_id, meaning, text):
"""Ответ тектом в common.js без дополгнительной обработки фугкциями"""
self.send_debug('process_text')
response = {'text': meaning['text']}
if 'menu' in meaning:
response['reply_markup'] = [i['title'] for i in meaning['menu']]
if 'funnel' in meaning:
self.funnel.set_funnel(user_id, meaning['funnel'], '')
return response
def check_reset(self, meaning):
"""Проверка на отмену действия"""
self.send_debug('check_reset')
if meaning['function'] == 'drop':
return True
else:
return False
def not_defined(self, chat_id, message_id, text):
"""Генерим ответ со ссылкой на оператора, если тема не найдена"""
response = self.replics.not_defined(chat_id) #not_defined.format(text)
self.tonque.send_alert_admin(chat_id, message_id, text)
return response
def process_hello(self, chat_id, meaning, text):
response = self.replics.tomato_hello(chat_id)
return response
def process_tomato(self, chat_id, meaning, text):
response = self.replics.tomato(chat_id)
return response
def process_reset(self, chat_id, meaning, text):
response = self.replics.reset(chat_id)
self.funnel.set_funnel(chat_id, 'drop', '')
return response
def process_feedback(self, chat_id, meaning, text):
pass
def process_playlist(self, chat_id, meaning, text):
response = self.replics.playlist_process(chat_id)
self.funnel.set_funnel(chat_id, 'playlist_confirm', text)
return response
def process_funnel(self, chat_id, message_id, text, text_raw):
""""""
meaning_defined = False
response = False
funnels = {'playlist_confirm': self.playlist.playlist_confirm}
funnel_current = self.funnel.last_funnel(chat_id)
funnel_current = funnel_current['chatfunnel']
if funnel_current in funnels:
meaning_defined = 1
functionName = funnels[funnel_current]
response = functionName(chat_id, message_id, text)
return meaning_defined, response
def message_from_admin(self, message):
response = {}
# Ответ пользователю от Админа
if message.reply_to_message.forward_from is not None:
client_id = message.reply_to_message.forward_from.id
# response = self.replySupport(text, message.chat.id)
response = {'text': 'Вы ответили клиенту', 'reply_markup': ''}
message_to_client = {'text': message.text}
self.tonque.send_message(client_id, message_to_client)
return response
def send_debug(self, txt):
if config.debug == 1:
for a in config.admin_ids:
self.tonque.send_message(a, {'text': txt})
return True
import sys
sys.path.insert(0, '..')
sys.path.insert(0, '/home/v/vstoch2s/tgtmt4/tgtmt4')
from timertask import Timertask
from replics import Replics
from tonque import Tonque
from models import *
import pandas as pd
replics = Replics()
timertask = Timertask()
tonque = Tonque()
def get_chat_id():
c = TimerTask.select(
TimerTask.chat_id).where(TimerTask.status == 1).distinct().dicts()
c = [i['chat_id'] for i in c]
return c
def update_timer():
chat_ids = get_chat_id()
for chat_id in chat_ids:
task = timertask.update_status(chat_id)
# print(task)
if task['time_remain'] > 0:
response = replics.tomato_update(task['chat_id'], task)
class Actions():
def __init__(self):
self.replics = Replics()
self.rooms_count = 20
self.game_objects = {}
self.game_spacegame_rooms = {}
self.game_user = {}
self.n_rooms_bats = 2
self.n_rooms_holes = 2
self.n_rooms_troll = 1
def init_user_state(self):
'''Характеристики игрока'''
a = {
'arrows': 5,
'lives': 1,
'context': '',
'troll_game': [],
'blind': False
}
return a
def init_game_space(self):
'''Генерация лабиринта'''
space = []
def min_treshold(x, x_thresh, x_replace):
return x_replace if x < x_thresh else x
def max_treshold(x, x_thresh, x_replace):
return x_replace if x > x_thresh else x
for i in range(5):
space.append(
[max_treshold(i + 1, 4, 0),
min_treshold(i - 1, 0, 4), i + 5])
for i in range(5, 10):
space.append([min_treshold(i + 4, 10, 14), i + 5, i - 5])
for i in range(10, 15):
space.append([max_treshold(i - 4, 9, 5), i - 5, i + 5])
for i in range(15, 20):
space.append([max_treshold(i + 1, 19, 15), i - 1, i - 5])
return space
def room_object(self, exclude_rooms, n_rooms=1):
r = []
while len(r) < n_rooms:
n = np.random.randint(self.rooms_count)
if n not in exclude_rooms:
r.append(n)
return r
def init_game_objects(self, rooms):
'''Расстановка объектов в игре'''
def rooms_exclude(g_objects):
return [item for sublist in g_objects.values() for item in sublist]
g_objects = {
'wampus': self.room_object([]),
'holes': [],
'bats': [],
'troll': []
}
for i in zip(
['holes', 'bats', 'troll'],
[self.n_rooms_bats, self.n_rooms_holes, self.n_rooms_troll]):
for j in range(i[1]):
g_objects[i[0]] = g_objects[i[0]] + self.room_object(
rooms_exclude(g_objects))
for i in ['holes', 'bats', 'wampus']:
g_objects[i + '_near'] = [
item for sublist in [rooms[i] for i in g_objects[i]]
for item in sublist
]
g_objects['player_history'] = self.room_object(
rooms_exclude(g_objects))
return g_objects
def init_troll(self):
def rooms_exclude(g_objects):
return [item for sublist in g_objects.values() for item in sublist]
p = np.random.randint(10)
if p > 5:
if not self.game_objects['troll']:
self.game_objects['troll'] = self.room_object(
rooms_exclude(self.game_objects))
if p > 5:
if self.game_objects['troll']:
self.game_objects['troll'] = []
return True
def check_active_user(f):
def wrapper(self, n):
if self.game_user['lives'] > 0:
return f(self, n)
else:
return self.replics.game_over()
return wrapper
def set_game_space(self):
self.game_space = self.init_game_space()
self.game_objects = self.init_game_objects(self.game_space)
def set_game_user(self):
self.game_user = self.init_user_state()
def create_game_world(self):
'''Создание мира игры - генерация лабиринта
и размещение всех объектов - мыши, ямы, Вампус, игрок'''
self.set_game_space()
self.set_game_user()
def append_history(self, room_to):
'''Добавление посещенной комнаты в историю'''
self.game_objects['player_history'].append(room_to)
def start(self, input_seq):
'''Запуск игры'''
self.create_game_world()
player_start_room = self.game_objects['player_history'][0]
response_status = self.replics.start_game()
response_room = self.move_check_room(player_start_room)
return '''{} # {}'''.format(
response_status, response_room
) #Сейчас вы находитесь в комнате {}. Вы можете перейти в смежные комнаты: {}.
def not_found(self, input_seq):
'''Не распознан запрос'''
return self.replics.not_found()
def cheat_code(self, input_seq):
'''чит код'''
return str(self.game_objects)
@check_active_user
def move_room(self, input_seq):
'''Переход в комнтау - обработка текстового запроса'''
n = v.find_numbers(input_seq)
if len(n) == 1:
room_to = int(n[0])
room_from = int(self.game_objects['player_history'][-1])
response = self.move_room_process(room_to, room_from)
else:
response = self.replics.move_wrong_input()
return response
def move_room_whereami(self, input_seq):
'''Напоминание где игрок'''
room_from = int(self.game_objects['player_history'][-1])
return self.move_check_room(room_from)
def move_room_process(self, room_to, room_from, check_connection=True):
'''Фиксация перехода в комнату и проработка игровых последствий
- встреча с объектами, запись в историю'''
if check_connection:
if room_to in self.game_space[room_from]:
self.append_history(room_to)
return self.move_check_room(room_to)
if room_to == room_from:
return self.replics.move_room_same(room_to,
self.game_space[room_to])
else:
return self.replics.move_room_close(room_from, room_to,
self.game_space[room_from])
else:
self.append_history(room_to)
return self.move_check_room(room_to)
def move_room_bats(self, room_to, rooms_connect):
'''Последствия перехода в комнату с мышами - перенос в случайную комнату'''
room_forward = room_to
while room_forward == room_to:
room_forward = np.random.randint(self.rooms_count)
response_ = self.replics.move_room_bats()
response = self.move_room_process(room_forward,
room_to,
check_connection=False)
return '{} # {}'.format(response_, response)
def move_room_holes(self, room_to, rooms_connect):
self.game_user['lives'] -= 1
return self.replics.move_room_holes(room_to, rooms_connect)
def move_room_wampus(self, room_to, rooms_connect):
self.game_user['lives'] -= 1
return self.replics.move_room_wampus(room_to, rooms_connect)
def move_room_troll(self, room_to, rooms_connect):
# self.game_user['lives'] -= 1
return self.troll_talk('')
def move_room_complex(self, keys_list, room_to, rooms_connect):
'''переход в комнату где сразу несколько опасностей рядом'''
return self.replics.move_room_danger_near(keys_list, room_to,
rooms_connect)
def move_check_room(self, room_to):
'''Проверка открытой игроком комнаты на все игровые предметы.
Выбор функции для ответа.'''
check_state_func = {
'wampus': self.move_room_wampus,
'holes': self.move_room_holes,
'bats': self.move_room_bats,
'troll': self.move_room_troll
}
for c in check_state_func.keys():
if room_to in self.game_objects[c]:
f = check_state_func[c]
return f(room_to, self.game_space[room_to])
check_state_near = {
'holes_near': self.replics.move_room_holes_near,
'bats_near': self.replics.move_room_bats_near,
'wampus_near': self.replics.move_room_wampus_near
}
response_keys = []
for c in check_state_near.keys():
if room_to in self.game_objects[c]:
response_keys.append(c)
if len(response_keys) > 1:
return self.move_room_complex(response_keys, room_to,
self.game_space[room_to])
elif len(response_keys) == 1:
f = check_state_near[response_keys[0]]
return f(room_to, self.game_space[room_to])
else:
return self.replics.move_room_empty(room_to,
self.game_space[room_to])
def shoot_random_rooms(self, rooms_arrow_pass, room_prev):
'''Генерация случайного полета стрелы с момента ошибки в комнате'''
while len(rooms_arrow_pass) < 5:
room_connect = self.game_space[room_prev]
room_target = np.random.choice(room_connect, 1)[0]
if room_target not in rooms_arrow_pass:
rooms_arrow_pass.append(room_target)
room_prev = room_target
return rooms_arrow_pass
def shoot_check_rooms(self, rooms_arrow, player_room):
'''Определение комнат через которые на самом деле пролетела стрела'''
wrong_room = False
room_prev = player_room
rooms_arrow_pass = []
for room_target in rooms_arrow:
room_connect = self.game_space[room_prev]
if room_target not in room_connect:
rooms_arrow_pass = self.shoot_random_rooms(
rooms_arrow_pass, room_prev)
wrong_room = True
break
rooms_arrow_pass.append(room_target)
room_prev = room_target
return rooms_arrow_pass, wrong_room
def wampus_change_room(self):
'''вампус просыпается и переходит в соседнюю комнату'''
wampus_room = self.game_objects['wampus'][0]
i = np.random.randint(3)
wampus_new_room = self.game_objects['wampus_near'][i]
self.game_objects['wampus'] = [wampus_new_room]
self.game_objects['wampus_near'] = self.game_space[wampus_new_room]
# print(['''вампус переходит в соседнюю комнату''', wampus_new_room])
@check_active_user
def shoot(self, input_seq):
'''Управление полетом стрелы'''
player_room = self.game_objects['player_history'][-1]
wampus_room = self.game_objects['wampus'][0]
rooms_arrow = v.find_numbers(input_seq)
if len(rooms_arrow) == 5:
if self.game_user['arrows'] > 0:
self.game_user['arrows'] -= 1
rooms_arrow_pass, wrong_room = self.shoot_check_rooms(
rooms_arrow, player_room)
if wampus_room in rooms_arrow_pass:
self.game_user['lives'] -= 1
return self.replics.shoot_wampus_killed(
rooms_arrow_pass, wampus_room)
if player_room in rooms_arrow_pass:
self.game_user['lives'] -= 1
return self.replics.shoot_player_killed(
rooms_arrow_pass, player_room)
response = self.replics.shoot_process(rooms_arrow_pass,
wrong_room,
self.game_user['arrows'])
else:
self.game_user['lives'] -= 1
response = self.replics.arrows_over()
else:
response = self.replics.shoot_wrong_input()
self.wampus_change_room()
return response
def help(self, input_seq):
'''Помощь'''
return self.replics.help()
@check_active_user
def troll_talk(self, input_seq):
self.game_user['context'] = 'askgame'
return self.replics.troll_talk()
@check_active_user
def troll_start_game(self, input_seq):
if input_seq == 'да askgame':
self.game_user['context'] = 'startgame'
return self.replics.troll_start_game()
elif input_seq == 'нет askgame':
self.game_user['context'] = ''
self.game_user['arrows'] -= 1
response_room = self.move_check_room(
int(self.game_objects['player_history'][-1]))
response_status = self.replics.troll_deny_game(
self.game_user['arrows'])
return '{} ## {}'.format(response_status, response_room)
else:
return 'Я не понимаю твоего ответа. Да или нет?'
@check_active_user
def troll_game_restrict(self, input_seq):
return '''- Ты не можешь вот так прервать игру. Говори: камень, ножницы или бумага?'''
@check_active_user
def troll_game_play(self, input_seq):
'''процесс игры в камень ножницы бумага с троллем'''
res = {1: -1, 2: 1, -1: 1, -2: -1}
input_seq = input_seq.replace('startgame', '').replace('_', '').strip()
variants = ['камень', 'ножницы', 'бумага']
if input_seq in variants:
i = variants.index(input_seq)
j = i
while j == i:
j = np.random.randint(3)
r = i - j
self.game_user['troll_game'].append(res[r])
if len(self.game_user['troll_game']) > 2:
self.game_user['context'] = ''
s = sum(self.game_user['troll_game'])
self.game_user['troll_game'] = []
if s > 0:
return self.troll_win_game()
else:
return self.troll_loose_game()
else:
return self.replics.troll_comment_game(res[r], variants[j])
# return self.str([res[r], variants[i], variants[j]])
else:
return input_seq
def troll_loose_game(self):
self.game_user['arrows'] -= 1
response_status = self.replics.troll_loose_game(
self.game_user['arrows'])
if self.game_user['arrows'] > 0:
room_from = int(self.game_objects['player_history'][-1])
response_room = self.move_check_room(room_from)
else:
response_room = self.replics.game_over()
return '{} ## {}'.format(response_status, response_room)
def troll_win_game(self):
o = ['holes', 'bats']
i = np.random.randint(len(o))
object = o[i]
rooms = self.game_objects[object]
i = np.random.randint(len(rooms))
room = rooms[i]
response_status = self.replics.troll_win_game(object, room)
room_from = int(self.game_objects['player_history'][-1])
response_room = self.move_check_room(room_from)
return '{} ## {}'.format(response_status, response_room)
@check_active_user
def health(self, input_seq):
''''''
r = '''У вас осталось {} стрел'''.format(self.game_user['arrows'])
return r
def exit_ask(self, input_seq):
'''Выход из игры - сброс мира'''
# self.game_objects = {}
# self.game_spacegame_rooms = {}
self.game_user['context'] = 'exit'
return 'Хотите выйти из игры? (да или нет)'
def exit_confirm(self, input_seq):
'''Выход из игры - сброс мира'''
self.game_user['context'] = ''
return 'exit'
@check_active_user
def exit_cancel(self, input_seq):
'''Выход из игры - сброс мира'''
self.game_user['context'] = ''
return 'Продолжаем игру!'
class PlaylistProcessor:
"""Управление музыкой таймера"""
def __init__(self):
self.replics = Replics()
self.funnel = funnelProcessor()
self.textProcessor = TextProcessor()
def get_random_link(self, chat_id):
q = """SELECT p.url url, c
FROM (
SELECT url, count(message_id) c
FROM timer_task tt
where tt.chat_id = 79711951
group by url
) tf
right join playlist p on p.url = tf.url
where p.status = 1
order by c DESC
""".format(chat_id)
q = Playlist.raw(q).dicts()
url_list = [i['url'] for i in q]
url_list = url_list[5:]
# q = Playlist.select(Playlist.url).where(Playlist.status==1).dicts()
r = randint(0, len(url_list) - 1)
return url_list[r]
def playlist_drop(self, chat_id, command_id, message_id=0):
response = self.replics.playlist_cancel(chat_id)
self.funnel.set_funnel(chat_id, 'drop', '')
# self.tonque.edit_message_text(chat_id, message_id, response)
response['message_id'] = message_id
return response
def playlist_confirm(self, chat_id, command_id, message_id=0):
funnel_current = self.funnel.last_funnel(
chat_id, funnel_name='playlist_confirm')
url = self.textProcessor.detect_url(funnel_current['message'])
if url:
playlist_data = {'chat_id': chat_id, 'status': 0, 'url': url}
playlist = Playlist(**playlist_data)
playlist.save()
response = self.replics.playlist_confirm(chat_id)
else:
response = self.replics.playlist_cancel(chat_id)
self.funnel.set_funnel(chat_id, 'drop', '')
# self.tonque.edit_message_text(chat_id, message_id, response)
response['message_id'] = message_id
return response
def __init__(self):
self.replics = Replics()
self.funnel = funnelProcessor()
self.textProcessor = TextProcessor()
def __init__(self):
"""Constructor"""
self.replics = Replics()
self.funnel = funnelProcessor()
self.textProcessor = TextProcessor()
self.email = EmailSender()
class feedbackChat:
def __init__(self):
"""Constructor"""
self.replics = Replics()
self.funnel = funnelProcessor()
self.textProcessor = TextProcessor()
self.email = EmailSender()
def new_chat(self, chat_id, message_id, text, text_raw):
fb = ChatFeedback(chatuser_id=chat_id)
fb.save()
return fb.id
def open_last_chat(self, chat_id):
fb = ChatFeedback.select().where(
(ChatFeedback.chatuser_id == chat_id)).order_by(
ChatFeedback.id.desc()).dicts()
if len(fb):
fb = fb.get()
return fb
def update_chat(self, id, fields):
# query = ChatFeedback.update(**fields).where(ChatFeedback.id == id)
query = ChatFeedback.update(**fields).where(ChatFeedback.id == id)
query.execute()
return query
def name_add(self, chat_id, message_id, text, text_raw):
last_chat = self.open_last_chat(chat_id)
self.update_chat(last_chat['id'], {'name': text_raw})
response = self.replics.feedback_name_confirm(chat_id, text_raw)
self.funnel.set_funnel(chat_id, 'feedback_phone', '')
return response
def name_confirm(self, chat_id, message_id, text, text_raw):
pass
def phone_add(self, chat_id, message_id, text, text_raw):
response = self.replics.feedback_phone(chat_id, text_raw)
last_chat = self.open_last_chat(chat_id)
self.update_chat(last_chat['id'], {'phone': text_raw})
self.funnel.set_funnel(chat_id, 'feedback_city', '')
return response
def phone_confirm(self, chat_id, message_id, text, text_raw):
pass
def city_add(self, chat_id, message_id, text, text_raw):
last_chat = self.open_last_chat(chat_id)
self.update_chat(last_chat['id'], {'location': text_raw})
response = self.replics.feedback_city(chat_id, text_raw)
self.funnel.set_funnel(chat_id, 'feedback_form_confirm', '')
return response
def text_add(self, chat_id, message_id, text, text_raw):
last_chat = self.open_last_chat(chat_id)
self.update_chat(last_chat['id'], {'message': text_raw})
response = self.replics.feedback_name(chat_id, text_raw)
self.funnel.set_funnel(chat_id, 'feedback_name', '')
return response
def city_confirm(self, chat_id, message_id, text, text_raw):
pass
def time_add(self, chat_id, message_id, text, text_raw):
pass
def time_confirm(self, chat_id, message_id, text, text_raw):
pass
def form_confirm(self, chat_id, message_id, text, text_raw):
# last_chat = self.open_last_chat(chat_id)
# self.update_chat(last_chat['id'], {'location':text_raw})
sentiment = self.textProcessor.define_positive(text_raw)
if sentiment == 1:
response = self.replics.feedback_confirm(chat_id)
self.funnel.set_funnel(chat_id, 'drop', '')
else:
response = self.replics.feedback_cancel(chat_id)
self.funnel.set_funnel(chat_id, 'drop', '')
self.send_email(chat_id)
return response
def get_username(self, chat_id):
fb = ChatUser.select().where((ChatUser.id == chat_id)).get()
if fb.username:
un = '(ник: @{})'.format(fb.username)
else:
un = ''
return un
def send_email(self, chat_id):
last_chat = self.open_last_chat(chat_id)
username = self.get_username(chat_id)
message = 'Клиент: {} {}\n\nГород: {}\n\nТелефон: {}\n\nСообщение: {}'.format(
last_chat['name'], username, last_chat['location'],
last_chat['phone'], last_chat['message'])
self.email.send_email(message)
return 1