def add_user(bot: Bot, update: Update, user_data: dict) -> (int, str):
uid = update.message.from_user.id
message = update.message.text
username = update.message.from_user.username
if is_cancelled(message):
user_data['reply_markup'] = ReplyKeyboardMarkup(
REGISTER_KEYBOARD, True)
send_cancel(bot, uid, user_data)
return ConversationHandler.END
elif is_stopped(message):
on_stop(message),
return ConversationHandler.END
user = Users.create(telegram_id=uid, username=username)
user.set_city(user_data['reg_city'])
user.set_email(user_data['reg_email'])
user.set_status(user_data['reg_email'])
user.save() # TODO: check email is valid
for key, val in user_data.items():
del key, val
thread = Thread(name=f"get_and_save::{uid}, {user.email}",
target=get_and_save,
args=((user.email, user.is_student, uid), ))
thread.start()
bot.send_message(uid,
MESSAGES['add_user:msg'],
ParseMode.HTML,
reply_markup=ReplyKeyboardMarkup(START_KEYBOARD, True))
return ConversationHandler.END
def get_city(bot: Bot, update: Update) -> (int, str):
uid = update.message.from_user.id
message = update.message.text
if is_cancelled(message):
send_cancel(bot, uid, user_data={
'reply_markup': ReplyKeyboardMarkup(START_KEYBOARD, True)
})
return ConversationHandler.END
elif is_stopped(message):
on_stop(bot, update)
return ConversationHandler.END
elif is_back(message):
bot.send_message(
uid,
MESSAGES['get_city:back'],
ParseMode.HTML,
reply_markup=ReplyKeyboardMarkup(SETTINGS_KEYBOARD, True)
)
elif message not in CITIES:
bot.send_message(
uid,
MESSAGES['get_city:incorrect'],
ParseMode.HTML,
reply_markup=ReplyKeyboardMarkup(SETTINGS_KEYBOARD, True)
)
else:
user = Users.get(Users.telegram_id == uid)
user.set_city(message, is_update=True)
user.save()
bot.send_message(uid, MESSAGES['get_city:correct'], ParseMode.HTML)
send_current(bot, uid, user.email, user.city)
return SETTINGS
def create_users():
""" Create sample records in Users database """
# add students to Users
for idx, email in enumerate(CORRECT_EMAILS['students']):
Users.create(telegram_id=idx,
username=re.sub(r"@.*", r'', email),
email=email,
dt=datetime.now(),
city="moscow")
# add lecturers to Users
for idx, email in enumerate(CORRECT_EMAILS['lecturers']):
Users.create(telegram_id=idx + len(CORRECT_EMAILS['students']),
username=re.sub(r"@.*", r'', email),
email=email,
dt=datetime.now(),
city="moscow",
student=False)
def get_email(bot: Bot, update: Update) -> (int, str):
uid = update.message.from_user.id
message = update.message.text
if is_cancelled(message):
send_cancel(bot, uid, user_data={
'reply_markup': ReplyKeyboardMarkup(START_KEYBOARD, True)
})
return ConversationHandler.END
elif is_stopped(message):
on_stop(bot, update)
return ConversationHandler.END
elif is_back(message):
bot.send_message(
uid,
MESSAGES['get_email:back'],
ParseMode.HTML,
reply_markup=ReplyKeyboardMarkup(SETTINGS_KEYBOARD, True)
)
elif not Users.check_email(message):
bot.send_message(
uid,
MESSAGES['get_email:incorrect'],
ParseMode.HTML,
reply_markup=ReplyKeyboardMarkup(SETTINGS_KEYBOARD, True)
)
else:
user = Users.get(Users.telegram_id == uid)
user.set_email(message)
user.set_status(message)
user.save() # TODO: check email is correct
thread = Thread(
name=f"get_and_save::{uid}, {message}",
target=get_and_save,
args=((user.email, user.is_student, uid), )
)
thread.start()
bot.send_message(uid, MESSAGES['get_email:correct'], ParseMode.HTML)
send_current(bot, uid, user.email, user.city)
return SETTINGS
def on_settings(bot: Bot, update: Update) -> str:
uid = update.message.from_user.id
try:
user = Users.get(Users.telegram_id == uid)
except BaseException as excinfo:
print(excinfo)
bot.send_message(
uid,
MESSAGES['on_settings:unregistered'],
ParseMode.HTML,
reply_markup=ReplyKeyboardMarkup(REGISTER_KEYBOARD, True)
)
return ASK_EMAIL
send_current(bot, uid, user.email, user.city)
return SETTINGS
def on_schedule(bot: Bot, update: Update) -> str:
uid = update.message.from_user.id
try:
user = Users.get(Users.telegram_id == uid)
except BaseException as excinfo:
print(excinfo)
bot.send_message(uid,
MESSAGES['on_schedule:unregistered'],
ParseMode.HTML,
reply_markup=ReplyKeyboardMarkup(
REGISTER_KEYBOARD, True))
return ASK_EMAIL
bot.send_message(update.message.chat.id,
MESSAGES['on_schedule:ask'],
ParseMode.HTML,
reply_markup=ReplyKeyboardMarkup(SCHEDULE_KEYBOARD, True))
return SCHEDULE
def get_email(bot: Bot, update: Update, user_data: dict) -> (int, str):
chat_id = update.message.chat.id
message = update.message.text
if is_cancelled(message):
user_data['reply_markup'] = ReplyKeyboardMarkup(
REGISTER_KEYBOARD, True)
send_cancel(bot, chat_id, user_data)
return ConversationHandler.END
elif is_stopped(message):
on_stop(message),
return ConversationHandler.END
if not Users.check_email(message):
bot.send_message(chat_id, MESSAGES['get_email:incorrect'],
ParseMode.HTML)
return
user_data['reg_email'] = message
bot.send_message(chat_id, MESSAGES['get_email:correct'], ParseMode.HTML)
return ask_city(bot, update)
def on_stop(bot: Bot, update: Update) -> int:
uid = update.message.from_user.id
user = None
try:
user = Users.get(Users.telegram_id == uid)
except BaseException as excinfo:
logging.debug(excinfo)
if not user:
bot.send_message(uid,
MESSAGES['on_stop:unregistered'],
ParseMode.HTML,
reply_markup=ReplyKeyboardMarkup(
REGISTER_KEYBOARD, True))
return
lessons = get_lessons(uid)
if lessons:
lessons.delete_instance()
user.delete_instance()
bot.send_message(uid,
MESSAGES['on_stop:complete'],
ParseMode.HTML,
reply_markup=ReplyKeyboardRemove())
return ConversationHandler.END
def start(bot: Bot, update: Update) -> None:
uid = update.message.from_user.id
username = update.message.from_user.username
message = update.message.text
user = None
try:
user = Users.get(Users.telegram_id == uid)
except BaseException as excinfo:
logging.debug(excinfo)
if not user:
bot.send_message(uid,
MESSAGES['start:greetings_new'],
ParseMode.HTML,
reply_markup=ReplyKeyboardMarkup(
REGISTER_KEYBOARD, True))
return ConversationHandler.END
user.username = username
user.save()
bot.send_message(uid,
MESSAGES['start:greetings'],
ParseMode.HTML,
reply_markup=ReplyKeyboardMarkup(START_KEYBOARD, True))
return ConversationHandler.END
def prepare_mailing(bot: Bot, update: Update, user_data: dict) -> (int, str):
uid = update.message.from_user.id
message = update.message.text
if is_cancelled(message):
bot.send_message(**user_data['recipients_sp'])
return WHOM_TO_SEND
recipients = Users.select()
if user_data['recipients'] == 'students':
recipients = recipients.where(Users.is_student == 1)
elif user_data['recipients'] == 'lecturers':
recipients = recipients.where(Users.is_student == 0)
for key, val in user_data.items():
del key, val
if recipients.exists():
thread = Thread(
name=f"mailing::{uid}",
target=do_mailing,
args=(bot, recipients, message, uid)
)
thread.start()
bot.send_message(
uid,
MESSAGES['prepare_mailing:start'],
ParseMode.HTML
)
start(bot, update)
else:
bot.send_message(
uid,
MESSAGES['prepare_mailing:empty'],
ParseMode.HTML
)
return ConversationHandler.END
def add_user(update):
user = Users.objects.filter(telegram_id=update.message.chat.id)
if user.count() is 0:
invated = update.message.text.split(' ')
if len(invated) > 1 and invated[1] != str(update.message.from_user.id):
invated_user = Users.objects.filter(telegram_id=invated[1])
if invated_user.count() != 0:
invated_user = invated_user.get(telegram_id=invated[1])
user = Users(telegram_id=update.message.chat.id,
username=update.message.chat.username,
first_name=update.message.chat.first_name,
last_name=update.message.chat.last_name,
invited_by=invated_user.id)
user.save()
return
user = Users(telegram_id=update.message.chat.id,
username=update.message.chat.username,
first_name=update.message.chat.first_name,
last_name=update.message.chat.last_name)
user.save()
else:
user = user.get(telegram_id=update.message.chat.id)
if not user.banned:
user.first_name = update.message.chat.first_name
user.last_name = update.message.chat.last_name
user.params = '[]'
user.rules = False
user.blocked = False
user.save()
else:
return None
return user