def interests_process(bot, update):
query = update.callback_query
interest_id = query.data.split("_")[1]
user_object = get_or_register_user(query.from_user)
user = query.from_user
target_interest = Interest.get(id=interest_id)
keyboard = []
if not User.select().join(UserInterests).join(Interest).where(User.tlg_id == user.id,
Interest.name == target_interest.name).exists():
UserInterests.create(user=user_object, interest=target_interest)
else:
ui = UserInterests.get(UserInterests.user == user_object, UserInterests.interest == target_interest)
ui.delete_instance()
for interest in Interest.select():
if User.select().join(UserInterests).join(Interest).where(User.tlg_id == user.id,
Interest.name == interest.name).exists():
prefix = "✅ "
else:
prefix = ""
keyboard.append([InlineKeyboardButton(prefix + interest.name, callback_data="interest_{}".format(interest.id))])
keyboard.append([InlineKeyboardButton("Готово", callback_data="interests_finish")])
reply_markup = InlineKeyboardMarkup(keyboard)
query.edit_message_reply_markup(reply_markup=reply_markup)
query.answer("Интерес обновлен ✅")
def clbck(c):
chat_id = cid(c)
u = User.cog(user_id=cid(c))
Message.create(sender=cid(c),
sender_type="user",
receiver=bot_id,
text=c.data,
msg_type='text')
try:
r = Routing.get(state=u.state, decision=c.data)
keyboard = types.InlineKeyboardMarkup()
bot.edit_message_reply_markup(chat_id=cid(c),
message_id=c.message.message_id,
reply_markup=keyboard)
bot.answer_callback_query(callback_query_id=c.id, show_alert=True)
try: # на случай если action не определён в таблице роутинга
if u.state != s.stop:
eval(r.action)(u=u, c=c)
except Exception as e:
Error.create(message=c.data, state=u.state, exception=e)
print(e)
print(s.action_not_defined)
except Exception as e:
Error.create(message=c.data, state=u.state, exception=e)
log_routing_error(e)
def send_photo_delay(chat_id,
p,
state=None,
delay=0,
disable_notification=None):
u = User.get(user_id=chat_id)
if state != None:
u.state = state
u.save()
bot.send_photo(chat_id, p, disable_notification=disable_notification)
def get_or_register_user(user, ref_id=None):
ref_user = None
if ref_id:
query = User.select().where(User.unique_id == ref_id)
if query.exists():
ref_user = query.get()
# logger.info("In register user, ref_id is {} and user found is {}".format(ref_id, ref_user))
# Register in DB if not exist, putting the referrer id if provided
if not User.select().where(User.tlg_id == user.id).exists():
# logger.info("Putting ref_user id {} to user {}".format(ref_user, user.first_name))
user_object = User.create(tlg_id=user.id,
tlg_username=user.username,
first_name=user.first_name,
last_name=user.last_name,
referer=ref_user)
else:
user_object = User.select().where(User.tlg_id == user.id).get()
return user_object
def create_menu_message(bot, update, is_callback=False):
if is_callback:
user = update.from_user
else:
user = update.message.from_user
user_object = get_or_register_user(user)
keyboard = []
# Check, if the user have not calculate scale - display only one option
if get_user_scale(user).amount <= 0:
keyboard.append([InlineKeyboardButton("Рассчитать масштаб личности", callback_data="scale_processing_start")])
reply_markup = InlineKeyboardMarkup(keyboard)
message = "Хочешь узнать на сколько ты масштабная личность и получить доступ к самым интересным для тебя " \
"событиям? "
update.message.reply_text(message, reply_markup=reply_markup)
return
# Adding the ability to recalculate scale at any time
query = Scale.select().join(User).where(User.tlg_id == user.id)
message = "{}, ваши данные по нетворкинг сети:\n" \
"Масштаб вашей личности: {}\n".format(user.first_name if user.first_name else user.username,
query.get().amount)
keyboard.append([InlineKeyboardButton("Пересчитать масштаб личности", callback_data="scale_processing_start")])
# Referral system data to message append
Referrer = User.alias()
query = User.select().join(Referrer, on=(Referrer.referer == User.id)).where(User.tlg_id == user.id)
ref_link = "https://t.me/{bot_name}?start={lnk}".format(bot_name=BOT_NAME, lnk=user_object.unique_id)
message = "{}\nПриглашено человек по реферальной системе: {}" \
"\nВаша реферальная ссылка: {}\n".format(message, query.count(), ref_link)
# If the user does not have selected interests, show him the invitation to fill them
if Interest.select().join(UserInterests).join(User).where(User.tlg_id == user.id).count() < 1:
message = "{}\nЧтобы получать наиболее интересные для вас новости, укажите ваши интересы".format(message)
keyboard.append([InlineKeyboardButton("Указать интересы", callback_data="interests_set")])
keyboard = appendSocialButtons(keyboard, ref_link)
reply_markup = InlineKeyboardMarkup(keyboard)
update.message.reply_text(message, reply_markup=reply_markup)
return
query = User.select().join(UserInterests).join(Interest).where(User.tlg_id == user.id)
message = "{}\nУказано {} интересов для уточнения новостей".format(message, query.count())
keyboard.append([InlineKeyboardButton("Уточнить интересы", callback_data="interests_set")])
keyboard = appendSocialButtons(keyboard, ref_link)
# Final reply
reply_markup = InlineKeyboardMarkup(keyboard)
update.message.reply_text(message, reply_markup=reply_markup)
def delayed(*args, **kwargs):
chat_id, m = args
u = User.get(user_id=chat_id)
u.state = s.stop
u.save()
timer = threading.Timer(kwargs['delay'],
func,
args=args,
kwargs=kwargs)
timer.start()
def day_2(user_id):
u = User.get(user_id=user_id)
u.day = 2
u.save()
send_message_delay(user_id,
s.day_2_start.format(u.first_name),
state=s.day_2,
delay=1)
bot.send_chat_action(user_id, 'typing')
send_message_delay(
user_id,
"Продолжайте присылать фото всего, что Вы едите и пьёте",
delay=6)
def interests_show(bot, update):
query = update.callback_query
user = query.from_user
keyboard = []
for interest in Interest.select():
if User.select().join(UserInterests).join(Interest).where(User.tlg_id == user.id,
Interest.name == interest.name).exists():
prefix = "✅ "
else:
prefix = ""
keyboard.append([InlineKeyboardButton(prefix + interest.name, callback_data="interest_{}".format(interest.id))])
keyboard.append([InlineKeyboardButton("Готово", callback_data="interests_finish")])
reply_markup = InlineKeyboardMarkup(keyboard)
query.edit_message_text("Отметьте ваши интересы.\nДля заверешения нажмите \"Готово\"", reply_markup=reply_markup)
def send_message_delay(chat_id,
m,
state=None,
delay=0,
reply_markup=None,
disable_notification=None,
parse_mode='Markdown'):
u = User.get(user_id=chat_id)
bot.send_chat_action(chat_id, 'typing')
if state != None:
u.state = state
u.save()
bot.send_message(chat_id,
m,
reply_markup=reply_markup,
parse_mode=parse_mode,
disable_notification=disable_notification)
def photo(m):
photo_name = save_photo(m)
Message.create(sender=uid(m),
sender_type="user",
receiver=bot_id,
text=photo_name,
msg_type='photo')
photo = Photo.create(user_id=uid(m), message_id=m.message_id)
u = User.cog(user_id=uid(m))
try:
r = Routing.get(state=u.state, decision='photo')
try: # на случай если action не определён в таблице роутинга
if u.state != s.stop:
eval(r.action)(u=u, m=m)
except Exception as e:
Error.create(message=m.text, state=u.state, exception=e)
except Exception as e:
print(e)
def __call__(self):
while True:
now = datetime.now()
now = now.replace(microsecond=0)
hour_ago = now - timedelta(hours=1)
# проверка на запланированное действие в расписании
actions = Schedule.select().where((Schedule.timestamp >= now) & (
Schedule.timestamp < now + timedelta(seconds=1)))
for action in actions:
eval(action.action)(**json.loads(action.arguments))
# проверка на last_activity
users = User.select().where(
(User.last_activity >= hour_ago)
& (User.last_activity < hour_ago + timedelta(seconds=1))
& (User.state != s.canceled) & (User.state != s.pause)
& (User.state != s.stop))
for user in users:
bot.send_message(user.user_id, s.one_hour_reminder)
sleep(1)
def action(m):
chat_id = sid(m)
u = User.cog(user_id=uid(m))
Message.create(sender=uid(m),
sender_type="user",
receiver=bot_id,
text=m.text)
if u.state == s.canceled:
return False
try:
r = Routing.get(state=u.state, decision='text')
try: # на случай если action не определён в таблице роутинга
if u.state != s.stop:
eval(r.action)(u=u, m=m)
except Exception as e:
Error.create(message=m.text, state=u.state, exception=e)
# print(e)
# print(m)
except Exception as e:
Error.create(message=m.text, state=u.state, exception=e)
log_routing_error(e)
def start(m):
# print(u, m)
u = User.cog(user_id=uid(m),
username=m.from_user.username,
first_name=m.from_user.first_name,
last_name=m.from_user.last_name)
u.clear()
u.state = s.default
u.save()
keyboard = types.InlineKeyboardMarkup()
agree_btn = types.InlineKeyboardButton(text=s.agree_btn,
callback_data=s.agree)
disagree_btn = types.InlineKeyboardButton(text=s.disagree_btn,
callback_data=s.disagree)
more_btn = types.InlineKeyboardButton(text=s.more_btn,
url="http://1fitchat.ru")
keyboard.add(agree_btn)
keyboard.add(disagree_btn)
keyboard.add(more_btn)
bot.send_message(uid(m),
s.greeting,
reply_markup=keyboard,
parse_mode="Markdown")
def publish_news(novelty_object, my_bot):
# Match the user by interest and scale
query = User.select().join(UserInterests).join(Interest).join(NoveltyInterests).join(Novelty).switch(User).join(Scale) \
.where(Novelty.id == novelty_object.id,
((Scale.amount >= novelty_object.scale_from) & (Scale.amount < novelty_object.scale_to)))
logger.info("Publish the news to {} users".format(query.count()))
for user in query:
try:
my_bot.send_message(chat_id=user.tlg_id, text=novelty_object.text)
except Unauthorized as u:
user_msg = "{}:{} {}".format(user.username, user.first_name,
user.last_name)
logger.info(
"Exception occurred while sending message to user {}\n Message: {}"
.format(user_msg, u.message))
continue
except TelegramError as te:
user_msg = "{}:{} {}".format(user.username, user.first_name,
user.last_name)
logger.info(
"Telegram Error occurred while sending message to user {}\n Message: {}"
.format(user_msg, te.message))
continue
def init(m):
User.create_table(fail_silently=True)
def bye_day_3(user_id):
u = User(user_id=user_id).get()
u.day = 0
u.save()
bot.send_message(user_id, s.bye_day_3)
def day_3(user_id):
u = User.get(user_id=user_id)
u.day = 3
u.save()
bot.send_message(user_id, s.greeting_3.format(u.first_name))
send_message_delay(user_id, s.waiting_from_you, state=s.day_3, delay=5)
