def request_phone_number(chat_id):
# указываем параметр resize_keyboard для того, чтобы кнопки были маленького размера
markup = types.ReplyKeyboardMarkup(row_width=2, one_time_keyboard=True, resize_keyboard=True)
markup.add(types.KeyboardButton(text=phone_button_text, request_contact=True))
markup.add(types.KeyboardButton(text=phone_button_text_denied))
telegram_bot.send_message(text=request_phone_message, chat_id=chat_id,
reply_markup=markup, disable_notification=True)
def daily_update(self):
subscription = Subscribe.query.filter(Subscribe.telegram_id==self.id).all()
for sub in subscription:
comp = Company.query.filter(Company.id==sub.company_id).first()
response = render_template('telebot/price_alert.html', header='Daily Update', company=comp, user=self, company_url=COMPANY_INFO_URL)
telegram_bot.send_message(chat_id=self.chat_id, text=response, parse_mode='HTML')
sub.user_notified()
def handle_room_owner_start(query):
room_owner = User.query.get(query.message.chat.id) # создатель комнаты
if room_owner.state != BotSate.IN_ROOM_CREATOR:
return
room_users = room_owner.participant.users # AppenderBaseQuery все участники комнаты
room_users_count = get_room_users_count(room_owner) # всего участников комнаты
room_users_ready_count = check_ready(room_owner) # кол-во готовых пользователей
# если в комнате только создатель или не все пользователи готовы
# отменить распределение тайных сант до тех пор пока все не будут готовы
if room_users_count == 1 or room_users_count != room_users_ready_count:
return
santa_ids = [user.id for user in room_users]
for user in room_users:
telegram_bot.send_message(chat_id=user.id, text=room_everyone_ready_message.format(room_owner.first_name),
disable_notification=True)
santa_for = random.choice(santa_ids)
while santa_for == user.id: # никто не может быть тайным сантой для себя самого
santa_for = random.choice(santa_ids)
santa_ids.remove(santa_for)
santa = User.query.filter_by(id=santa_for).first()
assign_santa(user, santa) # назначить санту santa для пользователя user
drop_room(query.message, end=True)
def drop_room(message, end=False):
user = User.query.filter_by(id=message.chat.id).first()
if user.participant is not None:
room = Room.query.filter_by(identifier=user.participant.identifier).first()
else:
room = None
if room and user.state == BotSate.IN_ROOM_CREATOR and user.id == room.owner_id:
for u in room.users:
u.participant = None
u.state = BotSate.ROOM_CHOICE
db.session.query(User).filter_by(id=u.id).update({"ready": False}) # сбрасываем готовность
if u.id == user.id:
telegram_bot.send_message(chat_id=u.id,
text=room_dropped_owner_message, disable_notification=True)
else:
telegram_bot.send_message(chat_id=u.id,
text=room_dropped_participant_message.format(user.first_name),
disable_notification=True)
if not end:
request_room_invitation(u.id)
db.session.delete(room)
db.session.commit()
else:
check_state(message)
def join_room(message):
identifier = re.search(r'/room\w{10}\b', message.text).group(0)[5:]
user = User.query.filter_by(id=message.chat.id).first()
room = Room.query.filter_by(identifier=identifier).first()
if room and user.state == BotSate.ROOM_CHOICE:
user.participant = room
user.state = BotSate.IN_ROOM_USER
db.session.commit()
for u in room.users:
if u.id != user.id:
telegram_bot.send_message(chat_id=u.id,
text=room_join_alert_message.format(user.first_name,
user.participant.identifier),
disable_notification=True)
else:
owner_name = User.query.filter_by(id=user.participant.owner_id).first().first_name
telegram_bot.send_message(chat_id=user.id,
text=room_join_message.format(user.first_name,
user.participant.identifier,
owner_name),
disable_notification=True)
request_ready(user.id)
else:
check_state(message)
def send_message_to_all_telegram_users(users, message):
# start = time.time()
# при рассылке использовать try-except, так как пользватель может заблокировать бота
for user in users:
try:
telegram_bot.send_message(user.id, message)
except Exception as e:
pass
def request_room_invitation(chat_id):
markup = types.InlineKeyboardMarkup(row_width=2)
markup.add(types.InlineKeyboardButton(text='Создать новую комнату',
callback_data=json.dumps({'inv': True})))
markup.add(types.InlineKeyboardButton(text='Подключится к существующей',
callback_data=json.dumps({'inv': False})))
telegram_bot.send_message(text=room_invitation_text, chat_id=chat_id,
reply_markup=markup, parse_mode='Markdown', disable_notification=True)
def get_room_users_count(room_owner):
count = User.query.filter_by(room=room_owner.participant.id).count()
if count == 1:
telegram_bot.send_message(chat_id=room_owner.id,
text=room_owner_alone_message.format(room_owner.participant.identifier),
parse_mode='Markdown',
disable_notification=True)
return count
def assign_santa(user, santa):
contact_data = concatenate_name(santa)
try:
message_text = secret_santa_message.format(contact_data, santa.phone_number, santa.address, santa.present)
telegram_bot.send_message(chat_id=user.id, text=message_text, parse_mode='HTML', disable_notification=True)
except Exception as e: # ошибка форматирования HTML
clean_message_test = secret_santa_message_clean.format(contact_data, santa.phone_number, santa.address,
santa.present)
telegram_bot.send_message(chat_id=user.id, text=clean_message_test, disable_notification=True)
def request_start(chat_id):
photo = open('app/static/start-pic.jpg', 'rb')
markup = types.InlineKeyboardMarkup()
markup.add(types.InlineKeyboardButton(text='Старт', callback_data=json.dumps({'strt': True})))
telegram_bot.send_photo(chat_id, photo)
telegram_bot.send_message(chat_id=chat_id,
text=start_message,
reply_markup=markup,
parse_mode='Markdown')
def price_alert(self, max_send_frequency=3):
# Storing current utc datetime
datetime_now = datetime.datetime.utcnow()
target_time = datetime_now - datetime.timedelta(hours=max_send_frequency)
subscription = Subscribe.query.filter(Subscribe.company_id == self.id, Subscribe.last_sent<=target_time, Subscribe.price_alert_status == 0, Subscribe.price_alert != None).all()
for sub in subscription:
if abs(self.last_done - sub.price_alert) < 0.005:
user = TelegramSubscriber.query.filter(TelegramSubscriber.id==sub.telegram_id).first()
response = render_template('telebot/price_alert.html', header='Price Alert', company=self, user=user, company_url=COMPANY_INFO_URL)
telegram_bot.send_message(chat_id=user.chat_id, text=response, parse_mode='HTML')
sub.price_alert_notified()
def price_change(self, max_send_frequency=3):
# Storing current utc datetime
datetime_now = datetime.datetime.utcnow()
target_time = datetime_now - datetime.timedelta(hours=max_send_frequency)
if abs(self.change_percent) >= 3:
# Query list of subscribers that received price alerts more than max_send_frequency hours ago for self(company)
users = TelegramSubscriber.query.filter(TelegramSubscriber.subscribe.any(and_(Subscribe.last_sent<=target_time, Subscribe.company_id==self.id))).all()
for user in users:
response = render_template('telebot/price_alert.html', header='Volatile Alert', company=self, user=user, company_url=COMPANY_INFO_URL)
telegram_bot.send_message(chat_id=user.chat_id, text=response, parse_mode='HTML')
sub = Subscribe.query.filter(Subscribe.telegram_id == user.id, Subscribe.company_id == self.id).first()
sub.user_notified()
def notify_room_participants(message):
user = User.query.filter_by(id=message.from_user.id).first()
# отправлять уведомления тем кто в комнате
if user.state in [BotSate.IN_ROOM_CREATOR, BotSate.IN_ROOM_USER, BotSate.IN_ROOM_USER_READY]:
if message.text == '/notify':
telegram_bot.send_message(user.id, proper_usage_of_notify_text, parse_mode='Markdown')
return
telegram_bot.delete_message(message.chat.id, message.message_id) # удалить сообщение со слэшем
for room_user in user.participant.users:
telegram_bot.send_message(chat_id=room_user.id,
text='💬 {}: {}'.format(concatenate_name(user), message.text[8:]),
disable_notification=True)
else:
check_state(message)
def confirm_present(chat_id):
user = User.query.get(chat_id)
try:
markup = types.InlineKeyboardMarkup(row_width=2)
markup.add(types.InlineKeyboardButton(text='Да',
callback_data=json.dumps({'prz': True})))
markup.add(types.InlineKeyboardButton(text='Нет',
callback_data=json.dumps({'prz': False})))
telegram_bot.send_message(text=correct_present_text.format(user.present), chat_id=chat_id,
reply_markup=markup, parse_mode='Markdown', disable_notification=True)
except Exception as e:
user.present = None
db.session.commit()
request_present(user.id)
def send_or_update_course_option(chat_id, message_id=None, update=False):
markup = types.InlineKeyboardMarkup()
markup.add(types.InlineKeyboardButton(text='Умный дом на Arduino С++',
callback_data=json.dumps({'crs': Course.SMART_HOUSE})))
markup.add(types.InlineKeyboardButton(text='Python Джедай', callback_data=json.dumps({'crs': Course.PYTHON})))
markup.add(types.InlineKeyboardButton(text='Получи Бонус', callback_data=json.dumps({'crs': Course.BONUS})))
if update:
telegram_bot.delete_message(chat_id=chat_id, message_id=message_id)
telegram_bot.send_message(chat_id=chat_id, text=course_choice_message,
reply_markup=markup, parse_mode='Markdown')
else:
telegram_bot.send_message(chat_id=chat_id, text=course_choice_message,
reply_markup=markup, parse_mode='Markdown')
def handle_room_ready(query):
ready = json.loads(query.data).get('rdy')
user = User.query.get(query.message.chat.id)
if ready and user.state == BotSate.IN_ROOM_USER:
db.session.query(User).filter_by(id=user.id).update({"ready": True})
user.state = BotSate.IN_ROOM_USER_READY
db.session.commit()
for u in user.participant.users:
if u.id != user.id:
telegram_bot.send_message(chat_id=u.id,
text=user_ready_alert_message.format(user.first_name),
disable_notification=True)
else:
telegram_bot.delete_message(chat_id=u.id, message_id=query.message.message_id)
telegram_bot.send_message(chat_id=u.id, text=user_ready_message, parse_mode='Markdown',
disable_notification=True)
def auth_user(message):
if User.query.filter_by(id=message.from_user.id).first():
check_state(message)
else:
user = User(id=message.from_user.id,
first_name=message.from_user.first_name,
last_name=message.from_user.last_name,
username=message.from_user.username,
state=BotSate.PHONE)
db.session.add(user)
db.session.commit()
telegram_bot.send_message(chat_id=user.id,
text=start_message.format(user.first_name),
disable_notification=True)
request_phone_number(message.from_user.id)
def check_ready(room_owner):
ready_users_count = 0
try:
for u in room_owner.participant.users:
if u.ready:
ready_users_count += 1
else:
telegram_bot.send_message(chat_id=room_owner.id,
text=user_doesnt_ready_owner_message.format(u.first_name),
disable_notification=True)
telegram_bot.send_message(chat_id=u.id,
text=user_doesnt_ready_participant_message.format(room_owner.first_name),
disable_notification=True)
request_ready(chat_id=u.id)
return ready_users_count
except Exception:
return ready_users_count
def handle_room_joining(query):
choice = json.loads(query.data).get('inv') # True - кнопка создания, False - кнопка присоединения
user = User.query.get(query.message.chat.id)
if user.state < BotSate.ROOM_CHOICE: # ничего не делать если не в меню выбора кнопок или не в комнате
return
if choice:
if not user.room:
room = Room(owner_id=user.id)
user.participant = room
user.state = BotSate.IN_ROOM_CREATOR
# создатель комнаты готов по-умолчанию
db.session.query(User).filter_by(id=query.message.chat.id).update({"ready": True})
db.session.add(room)
db.session.commit()
request_room_owner_panel(query.message.chat.id, user.first_name, room.identifier)
telegram_bot.delete_message(chat_id=query.message.chat.id,
message_id=query.message.message_id)
else:
if user.id == user.participant.owner_id:
telegram_bot.send_message(text=already_in_room_message.format(user.participant.identifier),
chat_id=query.message.chat.id, disable_notification=True)
else:
telegram_bot.send_message(text=already_in_room_message2.format(user.participant.identifier),
chat_id=query.message.chat.id, disable_notification=True)
else:
if not user.room:
telegram_bot.send_message(text=room_exists_message,
chat_id=query.message.chat.id,
parse_mode='Markdown', disable_notification=True)
telegram_bot.delete_message(chat_id=query.message.chat.id,
message_id=query.message.message_id)
else:
if user.id == user.participant.owner_id:
telegram_bot.send_message(text=already_in_room_message.format(user.participant.identifier),
chat_id=query.message.chat.id, disable_notification=True)
else:
telegram_bot.send_message(text=already_in_room_message2.format(user.participant.identifier),
chat_id=query.message.chat.id, disable_notification=True)
def data_loading():
app.app_context().push()
# Load company (quote) details and announcement details
print("Starting data loading job...")
Company.company_scrape()
announcements = Announcement.announcement_scrape()
db.session.commit()
if not Announcement.query.filter_by(
announced_date=datetime.date.today()).first():
print("No operation today, no announcement/stock update required")
return
# Send out announcements based on announcements loading
for announcement in announcements:
recipients = announcement.subscriber()
chats = []
for recipient in recipients:
chats.append(recipient.chat_id)
chats.append(os.environ.get('TARGET_CHANNEL'))
response = announcement.announcement_message()
if response:
for chat in chats:
time.sleep(0.1)
telegram_bot.send_message(chat_id=chat,
text=response,
parse_mode='HTML')
# Query all companies and run price check and price alert for each
subs = Subscribe.query.all()
for sub in subs:
time.sleep(0.1)
sub.company.price_change()
sub.company.price_alert()
db.session.commit()
print("Data loading job completed...")
def exit_room(message):
identifier = re.search(r'/exit\w{10}\b', message.text).group(0)[5:]
user = User.query.filter_by(id=message.chat.id).first()
room = Room.query.filter_by(identifier=identifier).first()
if room and user.state in [BotSate.IN_ROOM_USER, BotSate.IN_ROOM_USER_READY]:
user.participant = None
user.state = BotSate.ROOM_CHOICE
db.session.query(User).filter_by(id=user.id).update({"ready": False})
db.session.commit()
telegram_bot.send_message(chat_id=user.id,
text=room_exit_message.format(user.first_name, room.identifier),
disable_notification=True)
for u in room.users:
if u.id != user.id:
telegram_bot.send_message(chat_id=u.id, text=room_exit_alert_message.format(user.first_name,
room.identifier),
disable_notification=True)
request_room_invitation(user.id)
else:
check_state(message)
def course_link(query):
user = TelegramUser.query.get(query.message.chat.id)
course = json.loads(query.data).get('prb')
# вернуться к выбору языков
if course == 'back':
user.state = BotSate.COURSE_CHOICE
db.session.commit()
send_or_update_course_option(user.id, query.message.message_id, update=True)
return
# ccылки на курсы
if course == Course.SMART_HOUSE:
telegram_bot.send_message(user.id, text=smart_house_link, disable_web_page_preview=True,
parse_mode='Markdown')
elif course == Course.PYTHON:
telegram_bot.send_message(user.id, text=python_link, disable_web_page_preview=True,
parse_mode='Markdown')
elif course == Course.JAVASCRIPT:
telegram_bot.send_message(user.id, text=javascript_link, disable_web_page_preview=True,
parse_mode='Markdown')
def send_autonomous_link(query):
chat_id = query.message.chat.id
photo = open('app/static/aut-pic.jpg', 'rb')
telegram_bot.send_photo(chat_id, photo)
telegram_bot.send_message(chat_id, text=autonomous_link, parse_mode='Markdown',
disable_web_page_preview=True)
def request_present(chat_id):
telegram_bot.send_message(text=request_present_message, chat_id=chat_id, disable_notification=True)
def request_address(chat_id, first_name):
telegram_bot.send_message(text=request_address_message.format(first_name),
chat_id=chat_id, disable_notification=True)
def confirm_phone_number_lack(chat_id):
markup = types.ReplyKeyboardMarkup(row_width=1, one_time_keyboard=True, resize_keyboard=True)
markup.add(types.KeyboardButton(text=skip_phone_button_text))
telegram_bot.send_message(text=not_phone_number_info, chat_id=chat_id, reply_markup=markup,
disable_notification=True)
def request_room_owner_panel(chat_id, first_name, room_identifier):
markup = types.InlineKeyboardMarkup(row_width=2)
markup.add(types.InlineKeyboardButton(text='Старт',
callback_data=json.dumps({'strt': True})))
telegram_bot.send_message(text=room_created_message.format(room_identifier),
chat_id=chat_id, reply_markup=markup, parse_mode='Markdown', disable_notification=True)
def request_ready(chat_id):
markup = types.InlineKeyboardMarkup(row_width=2)
markup.add(types.InlineKeyboardButton(text='Готов!',
callback_data=json.dumps({'rdy': True})))
telegram_bot.send_message(text=ready_message, chat_id=chat_id,
reply_markup=markup, parse_mode='Markdown', disable_notification=True)
def send_help(message):
telegram_bot.send_message(chat_id=message.from_user.id, text=help_message,
parse_mode='Markdown', disable_notification=True)
def request_registration_start(chat_id):
telegram_bot.send_message(text=registration_start_message, chat_id=chat_id,
parse_mode='Markdown')
