def add_poll(update: Update, context: CallbackContext) -> bool:
user_id = update.poll_answer.user.id
user: User = current_list_users.get(user_id, None)
if user and user.askedSkill:
msg = []
flag = 0
for i in update.poll_answer.option_ids:
Db.get_instance().add_interest(user_id, i)
msg.append(INTEREST_LIST[i])
flag += 1
if flag == 3:
break
user.askedSkill = False
context.bot.send_message(
text=f'``` Selected Interest:- {",".join(msg)} ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=user_id,
)
del current_list_users[user_id]
context.bot.send_message(
text=f'``` You are all set to go Anonymous ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=user_id,
)
helper(user_id, context)
return True
return False
def check_batch(update: Update, context: CallbackContext) -> bool:
user: User = current_list_users.get(update.message.chat.id, None)
if user and user.askedBatch:
user.set_batch(update.message.text)
user.askedBatch = False
delete_msg(update.message.chat.id, context)
context.bot.send_message(
text=f'``` Inserted Data\n'
f'Name {user.name}\n'
f'Instagram {user.instagram_id}\n'
f'Gender {user.GENDER[user.gender]}\n'
f'Year {user.batch}```',
parse_mode=ParseMode.MARKDOWN,
chat_id=update.message.chat.id,
)
Db.get_instance().write_user(user)
Db.get_instance().read_users()
active_commands[update.message.chat.id] = context.bot.send_poll(
update.message.chat.id,
ASK_FOR_INTEREST,
INTEREST_LIST,
allows_multiple_answers=True,
is_anonymous=False).message_id
return True
return False
def accept_request(update: Update, context: CallbackContext):
tel_to = update.callback_query.message.chat.id
tel_id = active_requests.get(tel_to, None)
if tel_id:
tel_id = tel_id[0]
active_chats[tel_id] = active_requests[tel_id][0]
active_chats[active_chats[tel_id]] = tel_id
del active_requests[tel_id]
del active_requests[active_chats[tel_id]]
delete_msg(tel_id, context)
delete_msg(tel_to, context)
active_commands[tel_id] = context.bot.send_message(
text=f'``` Request Accepted ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id).message_id
context.bot.send_message(
text=
f'``` The Messages Now on (except Commands will be visible to the Anonymous '
f'person) ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id)
context.bot.send_message(
text=
f'``` The Messages Now on (except Commands will be visible to the Anonymous '
f'person) ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to)
res = Db.get_instance().get_common_interests(tel_id, tel_to)
data = [INTEREST_LIST[x] for x in res[0].intersection(res[1])]
if len(data) != 0:
context.bot.send_message(
text=f'``` Common Interest {" ".join(data)}```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id)
context.bot.send_message(
text=f'``` Common Interest {" ".join(data)} ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to)
else:
context.bot.send_message(
text=
f'``` Interests the Anonymous User have:- {" ".join([INTEREST_LIST[i] for i in res[1]])}```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id)
context.bot.send_message(
text=
f'``` Interests the Anonymous User have:- {" ".join([INTEREST_LIST[i] for i in res[0]])} ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to)
req = Request()
req.make(tel_id, tel_to, 3)
Db.get_instance().update_request(req)
else:
delete_msg(tel_to, context)
active_commands[tel_to] = context.bot.send_message(
text=f'``` Expired Request ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to).message_id
def reveal(update: Update, context: CallbackContext) -> None:
data = Db.get_instance().read_user_id(
update.callback_query.message.chat_id)
if data:
if data.name == PLACEHOLDER:
delete_msg(update.callback_query.message.chat.id, context)
active_commands[
update.callback_query.message.chat.
id] = context.bot.send_message(
text="""``` You haven't provided the details```""",
parse_mode=ParseMode.MARKDOWN,
chat_id=update.callback_query.message.chat.id,
).message_id
return
else:
data = Db.get_instance().read_user_id(
active_chats[update.callback_query.message.chat_id])
if data:
if data.name == PLACEHOLDER:
delete_msg(update.callback_query.message.chat.id, context)
active_commands[
update.callback_query.message.chat.
id] = context.bot.send_message(
text=
"""``` The user who's chatting with you hasn't provided the details```""",
parse_mode=ParseMode.MARKDOWN,
chat_id=update.callback_query.message.chat.id,
).message_id
return
keyboard = [
[
InlineKeyboardButton(
"ACCEPT", callback_data=ACCEPT_REVEAL_CALLBACK_DATA),
InlineKeyboardButton(
"DECLINE", callback_data=DECLINE_REVEAL_CALLBACK_DATA),
],
]
delete_msg(
active_chats.get(update.callback_query.message.chat.id, None),
context)
delete_msg(update.callback_query.message.chat.id, context)
active_commands[active_chats[
update.callback_query.message.chat.id]] = context.bot.send_message(
text="""``` Reveal Request```""",
parse_mode=ParseMode.MARKDOWN,
chat_id=active_chats[update.callback_query.message.chat.id],
reply_markup=InlineKeyboardMarkup(keyboard)).message_id
active_commands[
update.callback_query.message.chat.id] = context.bot.send_message(
text="""``` Reveal Request Sent```""",
parse_mode=ParseMode.MARKDOWN,
chat_id=update.callback_query.message.chat.id,
).message_id
else:
helper(update.callback_query.message.chat_id, context)
def questionnaire(update: Update, context: CallbackContext):
chat_id = update.callback_query.message.chat.id
delete_msg(chat_id, context)
print(Db.get_instance().get_questions(chat_id))
if Db.get_instance().get_questions(chat_id) is None:
active_commands[chat_id] = context.bot.send_message(
text=ASK_FOR_QN, chat_id=chat_id,
parse_mode=ParseMode.MARKDOWN).message_id
asked_questionnaire[update.callback_query.message.chat.id] = True
else:
view_questionnaire(update, context)
def report_confirmation(update: Update, context: CallbackContext):
if update.callback_query.data == ACCEPT_REPORT_CALLBACK_DATA:
Db.get_instance().update_block(
active_chats[update.callback_query.message.chat.id])
cancel_chat(update, context)
elif update.callback_query.data == DECLINE_CALLBACK_DATA:
delete_msg(update.callback_query.message.chat.id, context)
active_commands[
update.callback_query.message.chat.id] = context.bot.send_message(
text="""``` Report Request Closed```""",
chat_id=update.callback_query.message.chat.id,
parse_mode=ParseMode.MARKDOWN).message_id
def cancel_chat(update: Update, context: CallbackContext):
tel_id = active_chats.get(update.callback_query.message.chat.id, None)
if tel_id:
Db.get_instance().update_user_disconnected(tel_id)
Db.get_instance().update_user_disconnected(active_chats[tel_id])
req = Request()
req.make(tel_id, active_chats[tel_id], 1)
Db.get_instance().update_request(req)
req.make(active_chats[tel_id], tel_id, 1)
Db.get_instance().update_request(req)
delete_msg(tel_id, context)
delete_msg(active_chats[tel_id], context)
active_commands[tel_id] = context.bot.send_message(
text=f'``` Chat Cancelled ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id).message_id
active_commands[active_chats[tel_id]] = context.bot.send_message(
text=f'``` Chat Cancelled ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=active_chats[tel_id]).message_id
context.bot.send_message(text="/chat for chat settings",
parse_mode=ParseMode.MARKDOWN,
chat_id=active_chats[tel_id])
context.bot.send_message(text="/chat for chat settings",
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id)
del active_chats[active_chats[tel_id]]
del active_chats[tel_id]
def send_poll(update: Update, context: CallbackContext) -> None:
delete_msg(update.callback_query.message.chat.id, context)
user = Db.get_instance().read_user_id(
update.callback_query.message.chat.id)
user.askedSkill = True
current_list_users[user.tel_id] = user
Db.get_instance().delete_interest(user.tel_id)
active_commands[
update.callback_query.message.chat.id] = context.bot.send_poll(
update.callback_query.message.chat.id,
ASK_FOR_INTEREST,
INTEREST_LIST,
allows_multiple_answers=True,
is_anonymous=False).message_id
def accept_reveal_request(update: Update, context: CallbackContext) -> None:
user_id = update.callback_query.message.chat.id
delete_msg(active_chats.get(user_id, None), context)
delete_msg(user_id, context)
data = Db.get_instance().read_user_id(user_id)
if data:
msg = f"``` Name:- {data.name}\n Instagram Id:- {data.instagram_id}\n Gender:- {data.GENDER[data.gender]}\n Year:- {data.batch}```"
context.bot.send_message(text=msg,
parse_mode=ParseMode.MARKDOWN,
chat_id=active_chats[user_id])
data = Db.get_instance().read_user_id(active_chats[user_id])
if data:
msg = f"``` Name:- {data.name}\n Instagram Id:- {data.instagram_id}\n Gender:- {data.GENDER[data.gender]}\n Year:- {data.batch}```"
context.bot.send_message(text=msg,
parse_mode=ParseMode.MARKDOWN,
chat_id=user_id)
def status_code(chat_id: int):
if active_chats.get(chat_id, None):
return 1
elif active_requests.get(chat_id, None):
return 0
elif Db.get_instance().read_user_id(chat_id):
return -1
def register_user(update: Update, context: CallbackContext):
chat_id = update.callback_query.message.chat.id
if Db.get_instance().read_user_id(chat_id) is None:
if current_list_users.get(chat_id, None) is None:
delete_msg(chat_id, context)
active_commands[chat_id] = context.bot.send_message(
text=ASK_FOR_NAME,
parse_mode=ParseMode.MARKDOWN,
chat_id=chat_id).message_id
user = User(update.callback_query.message.chat.id)
current_list_users[update.callback_query.message.chat.id] = user
def decline_request(update: Update, context: CallbackContext):
tel_to = update.callback_query.message.chat.id
tel_id = active_requests.get(tel_to, None)
if tel_id:
tel_id = tel_id[0]
del active_requests[tel_to]
del active_requests[tel_id]
delete_msg(tel_id, context)
delete_msg(tel_to, context)
active_commands[tel_id] = context.bot.send_message(
text=f'``` Request Cancelled ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_id).message_id
active_commands[tel_to] = context.bot.send_message(
text=f'``` Request Cancelled ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to).message_id
Db.get_instance().update_user_disconnected(tel_id)
Db.get_instance().update_user_disconnected(tel_to)
req = Request()
req.make(tel_id, tel_to, 2)
Db.get_instance().update_request(req)
else:
delete_msg(tel_to, context)
active_commands[tel_to] = context.bot.send_message(
text=f'``` Expired Request ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=tel_to).message_id
def skip_process(message, context: CallbackContext):
chat_id = message.chat_id
if not Db.get_instance().read_user_id(chat_id):
if current_list_users.get(chat_id, None):
user = current_list_users[chat_id]
Db.get_instance().write_user(user)
del current_list_users[chat_id]
else:
user = User(chat_id)
Db.get_instance().write_user(user)
delete_msg(message.chat.id, context)
user = User(chat_id)
user.askedId = False
user.askedGender = False
user.askedName = False
user.askedBatch = False
current_list_users[chat_id] = user
active_commands[message.chat.id] = context.bot.send_poll(
chat_id,
ASK_FOR_INTEREST,
INTEREST_LIST,
allows_multiple_answers=True,
is_anonymous=False).message_id
def parse_questions(update: Update, context: CallbackContext):
delete_msg(update.message.chat.id, context)
ques = update.message.text.split('/')
if Db.get_instance().get_questions(update.message.chat_id):
Db.get_instance().delete_questions(update.message.chat_id)
Db.get_instance().add_questions(update.message.chat_id, ques)
msg = "Entered Questions\n"
for i in ques:
msg += f"{ques.index(i) + 1} {i.strip()}\n"
keyboard = [
[
InlineKeyboardButton("Edit Questionnaire",
callback_data=QUESTIONNAIRE_SET),
InlineKeyboardButton("<- Menu", callback_data=MENU),
],
]
active_commands[update.message.chat.id] = context.bot.send_message(
text=f"```{msg}```",
parse_mode=ParseMode.MARKDOWN,
chat_id=update.message.chat_id,
reply_markup=InlineKeyboardMarkup(keyboard)).message_id
asked_questionnaire[update.message.chat.id] = False
def send_questionnaire(update: Update, context: CallbackContext):
delete_msg(update.callback_query.message.chat.id, context)
ques = Db.get_instance().get_questions(
update.callback_query.message.chat.id)
for i in ques:
msg = context.bot.send_poll(
active_chats[update.callback_query.message.chat.id],
f"{ques.index(i) + 1}) {i.strip()}",
OPTION_LIST,
is_anonymous=False)
active_polls[msg.poll.id] = (msg.message_id, i)
active_commands[
update.callback_query.message.chat.id] = context.bot.send_message(
update.callback_query.message.chat.id,
"``` Poll Sent Waiting for reply```",
parse_mode=ParseMode.MARKDOWN).message_id
def view_questionnaire(update: Update, context: CallbackContext):
chat_id = update.callback_query.message.chat_id
delete_msg(chat_id, context)
data = Db.get_instance().get_questions(chat_id)
msg = "Entered Questions\n"
for i in data:
msg += f"{data.index(i) + 1} {i.strip()}\n"
keyboard = [
[
InlineKeyboardButton("Edit Questionnaire",
callback_data=QUESTIONNAIRE_SET),
InlineKeyboardButton("<- Menu", callback_data=MENU),
],
]
active_commands[chat_id] = context.bot.send_message(
text=f"```{msg}```",
parse_mode=ParseMode.MARKDOWN,
chat_id=chat_id,
reply_markup=InlineKeyboardMarkup(keyboard)).message_id
asked_questionnaire[chat_id] = False
def error_handle(update: Update, context: CallbackContext):
logger = logging.getLogger()
logger.error(msg="Exception while handling an update:", exc_info=context.error)
tb_list = traceback.format_exception(None, context.error, context.error.__traceback__)
print(context.error)
if isinstance(context.error, error.BadRequest):
update.message.reply_markdown("``` Kindly Repeat the process ```")
active_commands[update.message.chat_id] = None
elif isinstance(context.error, error.Unauthorized):
if status_code(update.message.chat_id) == 1:
context.bot.send_message(update.message.chat_id,
"``` The Anonymous user blocked the chat bot so we are stopping the chat````",
parse_mode=ParseMode.MARKDOWN, )
Db.get_instance().delete_user(active_chats[update.message.chat_id])
Db.get_instance().update_user_disconnected(update.message.chat_id)
del active_chats[update.message.chat_id]
elif status_code(update.message.chat_id) == 0:
context.bot.send_message(update.message.chat_id,
"``` The Anonymous user blocked the chat bot so make another request````",
parse_mode=ParseMode.MARKDOWN, )
cancel_request(update.message, context)
Db.get_instance().delete_user(active_requests[update.message.chat_id])
elif isinstance(context.error, error.TimedOut):
context.bot.send_message(update.message.chat_id,
"``` Connection Timed Out Repeat the process````",
parse_mode=ParseMode.MARKDOWN, )
helper(update.message.chat_id, context)
tb_string = ''.join(tb_list)
message = (
f'An exception was raised while handling an update\n'
f'<pre>update = {html.escape(json.dumps(update.to_dict(), indent=2, ensure_ascii=False))}'
'</pre>\n\n'
f'<pre>context.chat_data = {html.escape(str(context.chat_data))}</pre>\n\n'
f'<pre>context.user_data = {html.escape(str(context.user_data))}</pre>\n\n'
f'<pre>{html.escape(tb_string)}</pre>'
)
context.bot.send_message(chat_id=ADMIN_ID, text=message, parse_mode=ParseMode.HTML)
def helper(chat_id, context):
if chat_id in black_list:
return
if active_chats.get(chat_id, None):
if Db.get_instance().get_questions(chat_id):
menu = [[
InlineKeyboardButton("Reveal Identity Request",
callback_data=REVEAL_IDENTITY_REQUEST),
],
[
InlineKeyboardButton("Send Questionnaire",
callback_data=QUESTIONNAIRE_SENT),
],
[
InlineKeyboardButton("Report Chat",
callback_data=REPORT_CHAT),
InlineKeyboardButton("View/ Edit Questionnaire",
callback_data=QUESTIONNAIRE)
],
[
InlineKeyboardButton("Close Chat Portal",
callback_data=CLOSE_CHAT),
]]
else:
menu = [[
InlineKeyboardButton("Reveal Identity Request",
callback_data=REVEAL_IDENTITY_REQUEST),
],
[
InlineKeyboardButton("Report Chat",
callback_data=REPORT_CHAT),
InlineKeyboardButton("View/ Edit Questionnaire",
callback_data=QUESTIONNAIRE)
],
[
InlineKeyboardButton("Close Chat Portal",
callback_data=CLOSE_CHAT),
]]
delete_msg(chat_id, context)
active_commands[chat_id] = context.bot.send_message(
text=WELCOME_TEXT,
parse_mode=ParseMode.MARKDOWN,
chat_id=chat_id,
reply_markup=InlineKeyboardMarkup(menu)).message_id
elif Db.get_instance().read_user_id(chat_id):
menu = [[
InlineKeyboardButton("Random Chat",
callback_data=RANDOM_CHAT_CALLBACK_DATA),
],
[
InlineKeyboardButton("Questionnaire",
callback_data=QUESTIONNAIRE),
],
[
InlineKeyboardButton("Alter Interest",
callback_data=RESET_CALLBACK_DATA),
],
[
InlineKeyboardButton(
"How This Works",
callback_data=WALKABOUT_CALLBACK_DATA),
InlineKeyboardButton("Commands",
callback_data=COMMAND_CALLBACK_DATA)
]]
delete_msg(chat_id, context)
active_commands[chat_id] = context.bot.send_message(
text=WELCOME_TEXT,
parse_mode=ParseMode.MARKDOWN,
chat_id=chat_id,
reply_markup=InlineKeyboardMarkup(menu)).message_id
else:
welcome(chat_id, context)
if __name__ == '__main__':
# TOKEN = HERE
updater = Updater(TOKEN, use_context=True,
request_kwargs={'read_timeout': 6, 'connect_timeout': 7})
dp = updater.dispatcher
if os.path.isfile('active_chats'):
data.deserialize()
dp.add_handler(CommandHandler('start', help_menu))
dp.add_handler(CommandHandler('status', status))
dp.add_handler(CommandHandler('menu', store))
dp.add_handler(CommandHandler('help', help_menu))
dp.add_handler(CommandHandler('chat', help_menu))
dp.add_handler(CommandHandler('cancel', cancel))
dp.add_handler(CommandHandler('skip', skip))
dp.add_handler(CommandHandler('chat_id', chat_id))
dp.add_handler(CallbackQueryHandler(callback_query_handler))
dp.add_handler(MessageHandler(Filters.text & ~Filters.command, message_handler))
dp.add_handler(MessageHandler(Filters.sticker, sticker_handler))
dp.add_handler(MessageHandler(Filters.all, message_all_handler))
dp.add_handler(PollHandler(poll_handler))
dp.add_handler(PollAnswerHandler(poll_answer_handler))
dp.add_error_handler(error_handle)
Db.get_instance().create_black_list()
Db.get_instance().create_active_command_list()
updater.start_polling()
updater.idle()
def set_up_random_chat(update: Update, context: CallbackContext) -> None:
data = status_code(update.callback_query.message.chat_id)
if data == 1:
context.bot.send_message(
text=f'``` Close the current chat portal to start a new one ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=update.callback_query.message.chat.id,
)
return
if data == 0:
data = active_requests.get(update.callback_query.message.chat.id, None)
delete_msg(update.callback_query.message.chat_id, context)
print(data)
if data[1] == 1:
keyboard = [[
InlineKeyboardButton(
"CANCEL REQUEST",
callback_data=CANCEL_REQUEST_CALLBACK_DATA)
]]
msg_id = context.bot.send_message(
update.callback_query.message.chat.id,
"""``` You are in request phase Waiting for Accepting```""",
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(keyboard)).message_id
active_commands[update.callback_query.message.chat.id] = msg_id
elif data[1] == -1:
keyboard = [
[
InlineKeyboardButton("ACCEPT",
callback_data=ACCEPT_CALLBACK_DATA),
InlineKeyboardButton("DECLINE",
callback_data=DECLINE_CALLBACK_DATA),
],
]
msg_id = context.bot.send_message(
update.callback_query.message.chat.id,
"""``` You are in request phase```""",
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(keyboard)).message_id
active_commands[update.callback_query.message.chat.id] = msg_id
return
data = Db.get_instance().read_available_users(
update.callback_query.message.chat.id)
if len(data) == 0:
context.bot.send_message(
text=f'``` Oops! No Users Available try after some time ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=update.callback_query.message.chat.id,
)
else:
user = sample(data, 1)[0]
request = Request()
request.make(update.callback_query.message.chat.id, user.tel_id, 0)
Db.get_instance().write_request(request)
active_requests[request.tel_id] = (request.tel_to, 1)
active_requests[request.tel_to] = (request.tel_id, -1)
delete_msg(request.tel_id, context)
keyboard = [[
InlineKeyboardButton("CANCEL REQUEST",
callback_data=CANCEL_REQUEST_CALLBACK_DATA)
]]
active_commands[request.tel_id] = context.bot.send_message(
text=f'``` Waiting for Confirmation ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=request.tel_id,
reply_markup=InlineKeyboardMarkup(keyboard)).message_id
keyboard = [
[
InlineKeyboardButton("ACCEPT",
callback_data=ACCEPT_CALLBACK_DATA),
InlineKeyboardButton("DECLINE",
callback_data=DECLINE_CALLBACK_DATA),
],
]
delete_msg(request.tel_to, context)
active_commands[request.tel_to] = context.bot.send_message(
text=f'``` Anonymous Chat Request ```',
parse_mode=ParseMode.MARKDOWN,
chat_id=request.tel_to,
reply_markup=InlineKeyboardMarkup(keyboard)).message_id
Db.get_instance().update_user_connected(request.tel_id)
Db.get_instance().update_user_connected(request.tel_to)
