示例#1
0
def reset(message):
    try:
        if message.from_user.id == admin_tel_id:
            bot.send_message(message.from_user.id, emoji.emojize(':right_arrow: Enter your message: '), reply_markup=Finish_Discard_keyboard)
            cur.execute('''UPDATE Users SET state = (%s) WHERE tel_id = (%s)''', ('SEND MSG TO ALL USERS', message.from_user.id, ))
    except Exception as e:
        print('Something went wrong in /sendmsg: ', e)
示例#2
0
def send_accepted_answer(question_id):
    answer = cur.execute(
        '''SELECT answer FROM Answers WHERE question_id = (%s) AND accepted_answer = 1 ORDER BY rate_answer LIMIT 1''',
        (question_id, )).fetchone()

    keyboard = telebot.types.InlineKeyboardMarkup()
    if answer is not None:
        answer, tel_id, photo, document, document_type, document_size = cur.execute(
            '''SELECT answer, tel_id, photo, document, document_type, document_size FROM Answers WHERE question_id = (%s) AND accepted_answer = 1 ORDER BY rate_answer LIMIT 1''',
            (question_id, )).fetchone()

        if (limit_text(answer)):
            answer = limit_text(answer)
            keyboard.add(showmore)

        if photo is not None:
            keyboard.add(photo_button)
        if document is not None:
            document_button = telebot.types.InlineKeyboardButton(
                emoji.emojize(':paperclip: {0} ({1})'.format(
                    document_type, document_size)),
                callback_data='document')
            keyboard.add(document_button)

        answer = emoji.emojize(':white_heavy_check_mark: #A_') + str(
            question_id) + ' #' + str(tel_id) + '\n\n' + answer

    return (answer, keyboard)
示例#3
0
def reset(message):
    try:
        st_num = cur.execute('''SELECT st_num FROM Users WHERE tel_id = (%s)''',
                             (message.from_user.id,)).fetchone()

        if st_num is not None:
            bot.send_message(message.from_user.id, emoji.emojize(":white_heavy_check_mark: Everything is updated now."), reply_markup=main_reply_keyboard)
            cur.execute('''UPDATE Users SET state = 'IDLE', cont_typing = NULL WHERE tel_id = (%s)''', (message.from_user.id,))
    except Exception as e:
        print('Something went wrong in /update: ', e)
示例#4
0
def contact(message):
    try:
        st_num = cur.execute('''SELECT st_num FROM Users WHERE tel_id = (%s)''',
                             (message.from_user.id,)).fetchone()
        if st_num is not None:
            bot.send_message(message.from_user.id, emoji.emojize(":envelope: Contact Info:\n\n"
                            ":bust_in_silhouette: Ali Hejazi:\n        :white_small_square: @Ali_H93\n        :black_small_square: [email protected]\n"
                            ":bust_in_silhouette: Nima Sedghiye\n        :white_small_square:  @Nima_sedghiye\n        :black_small_square: [email protected]\n"
                            ":bust_in_silhouette: Hamed Hosseini\n        :white_small_square: @HMDHosseini\n        :black_small_square: [email protected]"), reply_markup=next_page_contact)
    except Exception as e:
        print('Something went wrong in /contact: ', e)
示例#5
0
def attachment(message):
    state = cur.execute('''SELECT state FROM Users WHERE tel_id = (%s)''',
                        (message.from_user.id, )).fetchone()

    if state is not None:
        # STATE[0] is the state retrieved (state is a tuple
        if state[0] in ['Send Question', 'Send Answer']:
            # PHOTO
            if message.content_type == 'photo':
                check_photo = \
                cur.execute('''SELECT photo FROM Users WHERE tel_id = (%s)''', (message.from_user.id,)).fetchone()[0]
                # ONLY 1 image is allowed
                if check_photo is None:
                    # FIRST image
                    bot.reply_to(
                        message,
                        emoji.emojize(':framed_picture: Image Attached.'))
                else:
                    # UPDATING image
                    bot.reply_to(
                        message,
                        emoji.emojize(
                            ':framed_picture: Image Attachment updated.'))

                cur.execute(
                    '''UPDATE Users SET photo = (%s) WHERE tel_id = (%s)''',
                    (message.photo[-1].file_id, message.from_user.id))
            # DOCUMENT
            elif message.content_type == 'document':
                check_document = cur.execute(
                    '''SELECT document FROM Users WHERE tel_id = (%s)''',
                    (message.from_user.id, )).fetchone()[0]
                # ONLY 1 document is allowed
                if check_document is None:
                    # FIRST document
                    bot.reply_to(
                        message,
                        emoji.emojize(':paperclip: Document Attached.'))
                else:
                    # UPDATING document
                    bot.reply_to(
                        message,
                        emoji.emojize(
                            ':paperclip: Document Attachment updated.'))

                # FORMATING FILE SIZE
                FILE_SIZE = message.document.file_size / 1000.0
                if FILE_SIZE < 1000:
                    FILE_SIZE = '{0} KB'.format(round(FILE_SIZE))
                else:
                    FILE_SIZE = '{0:.1f} MB'.format(FILE_SIZE / 1000.0)

                cur.execute(
                    '''UPDATE Users SET document = (%s), document_type = (%s), document_size = (%s) WHERE tel_id = (%s)''',
                    (message.document.file_id, message.document.mime_type,
                     FILE_SIZE, message.from_user.id))
示例#6
0
    9523017,
    9523018,
    9523021,
    9523053
]

admins_list = [9023026, 8123020]

tas_list = []

#######################################
## TEST
# stnums_list = [90230262]
# admins_list = [9023026]

cur.execute('''DELETE FROM Users_temp''')

#######################################

for stnum in stnums_list:
    if cur.execute('''SELECT st_num FROM Users WHERE st_num = (%s)''',
                   (stnum, )).fetchone() is None:
        cur.execute('''INSERT INTO Users (st_num, role) VALUES (%s, %s)''',
                    (stnum, 'STUDENT'))
        print('New User: {}'.format(stnum))
    else:
        print('User already in DB {}'.format(stnum))

for admin_stnum in admins_list:
    if cur.execute('''SELECT st_num FROM Users WHERE st_num = (%s)''',
                   (admin_stnum, )).fetchone() is None:
示例#7
0
def send_question(question_id, receiver_tel_id, short):

    id, question_owner, question, question_state, photo, document, document_type, document_size = \
            cur.execute('''SELECT id, tel_id, question, status, photo, document, document_type, document_size FROM Questions WHERE id = (%s)''', (question_id, )).fetchone()

    # limiting long questions and specifying keyboard
    keyboard = telebot.types.InlineKeyboardMarkup(row_width=6)
    load_answers = telebot.types.InlineKeyboardButton(
        emoji.emojize(':bright_button: Load Answers'),
        callback_data='load_answers')
    comment = telebot.types.InlineKeyboardButton(
        emoji.emojize(':memo: Comment'), callback_data='comment_question')

    # like question button is disabled now
    # liked_number = cur.execute('''SELECT count(*) from Like_Question WHERE question_id = (%s)''', (question_id, )).fetchone()[0]
    # if liked_number == 0:
    #     like_button = telebot.types.InlineKeyboardButton(emoji.emojize(':red_heart:'), callback_data='like_question')
    # else:
    #     like_button = telebot.types.InlineKeyboardButton(emoji.emojize('{0} :red_heart:'.format(liked_number)), callback_data='like_question')

    # GETTING ADMINS AND TAs
    # Receiver_tel_id which is different from send_answer.py -> answer_owner is used there
    role = cur.execute('''SELECT role FROM Users WHERE tel_id = (%s)''',
                       (receiver_tel_id, )).fetchone()[0]

    # LONG QUESTIONS
    if (limit_text(question)):
        ## Sending with SHOWMORE or SHOWLESS
        if short:
            question = limit_text(question)
            showkey = showmore
        else:
            showkey = showless

        ## Setting keyboard for REGULAR Users (NOT owner or admin)
        if receiver_tel_id != question_owner:
            ### Setting keyboard for OPEN and CLOSED questions
            ## QUESTIONS are always open for ADMINs and TAs
            if (question_state == 'OPEN') or (role in ['ADMIN', 'TA']):
                if role == 'ADMIN':
                    ### ADMINs can load answers for every question any time

                    # like is now disabled
                    # keyboard.add(showkey, answer_question, like_button, load_answers, next_page_question)
                    keyboard.add(showkey, answer_question, load_answers,
                                 next_page_question)
                else:
                    # like is now disabled
                    # keyboard.add(showkey, answer_question, like_button, next_page_question)
                    keyboard.add(showkey, answer_question, next_page_question)
            else:
                keyboard.add(showkey)

        ## Setting keyboard for OWNER, only SHOWMORE and LOAD ANSWERS
        elif receiver_tel_id == question_owner:
            check_answers = cur.execute(
                '''SELECT answer FROM Answers, Users WHERE question_id = (%s)
AND Users.tel_id = Answers.tel_id AND Users.role != (%s)''',
                (question_id, 'ADMIN')).fetchone()

            if check_answers is not None:
                if role in ['ADMIN']:
                    keyboard.add(showkey, answer_question, load_answers)
                else:
                    keyboard.add(showkey, load_answers)
            else:
                if role in ['ADMIN']:
                    keyboard.add(showkey, answer_question)
                else:
                    keyboard.add(showkey)

    # SHORT QUESTIONS
    else:
        ## Setting Keyboard for NOT OWNER and OPEN Questions
        if receiver_tel_id != question_owner:
            ## Even if the QUESTION is CLOSED, it is always open for ADMINs and TAs
            if (question_state == 'OPEN') or (role in ['ADMIN', 'TA']):
                if role == 'ADMIN':
                    ### ADMINs can load answers for every question any time

                    # like is disabled now
                    # keyboard.add(answer_question, like_button, load_answers, next_page_question)
                    keyboard.add(answer_question, load_answers,
                                 next_page_question)

                else:
                    # like is disabled now
                    # keyboard.add(answer_question, like_button, next_page_question)
                    keyboard.add(answer_question, next_page_question)

        ## Setting keyboard for OWNER, only SHOWMORE and LOAD ANSWERS
        elif receiver_tel_id == question_owner:
            # LOAD ANSWERS for owner
            check_answers = cur.execute(
                '''SELECT answer FROM Answers, Users WHERE question_id = (%s)
            AND Users.tel_id = Answers.tel_id AND Users.role != (%s)''',
                (question_id, 'ADMIN')).fetchone()

            if check_answers is not None:
                if role in ['ADMIN']:
                    keyboard.add(answer_question, load_answers)
                else:
                    keyboard.add(load_answers)

    # Setting keyboard for ATTACHMENTs
    if photo is not None:
        keyboard.add(photo_button)
    if document is not None:
        document_button = telebot.types.InlineKeyboardButton(
            emoji.emojize(':paperclip: {0} ({1})'.format(
                document_type, document_size)),
            callback_data='document')
        keyboard.add(document_button)

    # FORMATTING QUESTION
    question = emoji.emojize(':question_mark: #Q_') + str(
        question_id) + '\n\n' + question

    accepted_answers_count = cur.execute(
        '''SELECT SUM(accepted_answer) FROM Answers WHERE question_id = (%s)''',
        (question_id, )).fetchone()[0]
    print(accepted_answers_count)
    if (question_state == 'CLOSED') and (accepted_answers_count == 0):
        question += emoji.emojize('\n\n:cross_mark: Question is Closed')

    question_owner_role = cur.execute(
        '''SELECT role FROM Users WHERE tel_id = (%s)''',
        (question_owner, )).fetchone()[0]
    if question_owner_role in ['ADMIN', 'TA']:
        question += emoji.emojize(
            '\n\n:bust_in_silhouette: Sent by {0}'.format(question_owner_role))

    return (question, keyboard)
示例#8
0
def send_answer(question_id, answer_owner, receiver_tel_id, short):

    answer = cur.execute(
        '''SELECT answer FROM Answers WHERE question_id = (%s) AND tel_id = (%s)''',
        (question_id, answer_owner)).fetchone()
    keyboard = telebot.types.InlineKeyboardMarkup()

    if answer is not None:
        id, question_id, tel_id, answer, accepted_answer, rate_answer, photo, document, document_type, document_size, send_date = cur.execute(
            '''SELECT * FROM Answers WHERE question_id = (%s) AND tel_id = (%s)''',
            (question_id, answer_owner)).fetchone()

        question_owner = \
        cur.execute('''SELECT tel_id FROM Questions WHERE id = (%s)''', (question_id, )).fetchone()[0]
        # Limiting Long Questions and specifying keyboard accordingly

        # GETTING ADMINS AND TAs
        role = cur.execute('''SELECT role FROM Users WHERE tel_id = (%s)''',
                           (answer_owner, )).fetchone()[0]

        # This flag is used at the bottom for Admin and TAs keyboard setting
        short_message_flag = False
        # Setting keyboard
        if limit_text(answer):
            short_message_flag = True
            # SHOWMORE key
            if short:
                answer = limit_text(answer)
                showkey = showmore
            else:
                showkey = showless

            if receiver_tel_id == question_owner:
                if accepted_answer:
                    keyboard.add(showkey)
                else:
                    keyboard.add(showkey, accept_answer, next_page_answer)
            else:
                # FOLLOWERs and Answer Owner only get a show more key
                keyboard.add(showkey)
        else:
            if receiver_tel_id == question_owner:
                if not accepted_answer:
                    if question_owner == receiver_tel_id:
                        keyboard.add(accept_answer, next_page_answer)

        # ATTACHMENTs
        if photo is not None:
            keyboard.add(photo_button)
        if document is not None:
            document_button = telebot.types.InlineKeyboardButton(
                emoji.emojize(':paperclip: {0} ({1})'.format(
                    document_type, document_size)),
                callback_data='document')
            keyboard.add(document_button)

        # SETTING EMOJI BASED ON ACCEPTED OR NOT ACCEPTED ANSWER
        if role in ['STUDENT', 'TA']:
            if accepted_answer:
                answer = emoji.emojize(':white_heavy_check_mark: #A_') + str(question_id) + ' #' + \
                         str(answer_owner) + '\n\n' + answer + emoji.emojize('\n\n:high_voltage: Rated: {0}/5'.format(rate_answer))

            else:
                answer = emoji.emojize(':bright_button: #A_') + str(
                    question_id) + ' #' + str(answer_owner) + '\n\n' + answer

            if role == 'TA':
                answer += emoji.emojize(
                    '\n\n:bust_in_silhouette: Sent by ') + role

        ## ADMINs AND TAs answers are indicated with a flag
        elif role in ['ADMIN']:
            question_state = cur.execute(
                '''SELECT status FROM Questions WHERE id = (%s)''',
                (question_id, )).fetchone()[0]

            # ADMIN Answers are different
            keyboard = telebot.types.InlineKeyboardMarkup()
            if short_message_flag:
                # SHOWMORE key
                if short:
                    showkey = showmore
                else:
                    showkey = showless

                keyboard.add(showkey)
            else:
                keyboard = None

            # ATTACHMENTs
            if photo is not None:
                keyboard.add(photo_button)
            if document is not None:
                document_button = telebot.types.InlineKeyboardButton(
                    emoji.emojize(':paperclip: {0} ({1})'.format(
                        document_type, document_size)),
                    callback_data='document')
                keyboard.add(document_button)

            answer = emoji.emojize(':collision: #A_') + str(question_id) + ' #' + str(answer_owner) + '\n\n' \
                     + answer + emoji.emojize('\n\n:bust_in_silhouette: Sent by ') + role

    # Returning Answer and Two Keyboards
    return (answer, keyboard)
示例#9
0
def callback_inline(call):

    message = call.message
    # RE patters for QUESTIONS, ANSWERS, and ACCEPTED ANSWERS
    question_pattern = ":question_mark: #Q_(\d+).*"
    answer_pattern = "(?::bright_button:|:white_heavy_check_mark:|:collision:) #A_(\d+) #(\d+).*"
    accepted_answer_pattern = ":white_heavy_check_mark: #(\d+).*"
    # GETTING RESULTS of patterns
    question_res = re.match(question_pattern,
                            emoji.demojize(message.text),
                            flags=re.DOTALL)
    answer_res = re.match(answer_pattern,
                          emoji.demojize(message.text),
                          flags=re.DOTALL)
    accepted_answer_res = re.match(accepted_answer_pattern,
                                   emoji.demojize(message.text),
                                   flags=re.DOTALL)

    question_id = None
    if question_res is not None:
        ##############################
        ###        Questions       ###
        ##############################
        question_id = question_res.groups()[0]
        forwarded_user = cur.execute(
            '''SELECT tel_id FROM Questions WHERE id = (%s)''',
            (question_id, )).fetchone()[0]

        cur.execute(
            '''UPDATE Users SET forwarded_user = (%s), forwarded_question = (%s)  WHERE tel_id = (%s)''',
            (forwarded_user, question_id, message.from_user.id))

    elif answer_res is not None:
        ##############################
        ###         Answers        ###
        ##############################
        question_id = answer_res.groups()[0]
        forwarded_user = answer_res.groups()[1]

        cur.execute(
            '''UPDATE Users SET forwarded_user = (%s), forwarded_question = (%s) WHERE tel_id = (%s)''',
            (forwarded_user, question_id, message.from_user.id))

    #################################################
    ## IF A VALID RESULT FOUND BY REGULAR EXPRESSION
    if question_id is not None:
        forwarded_question = question_id
        cur.execute(
            '''UPDATE Users SET forwarded_user = (%s), forwarded_question = (%s) WHERE tel_id = (%s)''',
            (forwarded_user, forwarded_question, call.from_user.id))
    #################################################

    #################################################
    ###                 CALLBACKS                 ###
    #################################################

    # Handling callback queries
    if call.message:
        forwarded_question, forwarded_user = cur.execute(
            '''SELECT forwarded_question, forwarded_user
                                  FROM Users WHERE tel_id = (%s)''',
            (call.from_user.id, )).fetchone()

        ##############################
        #########   USER   ###########
        ##############################

        if call.data == 'load_answers':
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Loading Received Answers...")
            answers_list = cur.execute(
                '''SELECT Answers.tel_id FROM Answers, Users WHERE question_id = (%s)
AND Answers.tel_id = Users.tel_id AND Users.role != (%s)''',
                (question_id, 'ADMIN')).fetchall()

            if len(answers_list) > 0:
                bot.send_message(
                    call.from_user.id,
                    emoji.emojize(
                        ':red_triangle_pointed_down: Loading *Question {0}* Answers...'
                        .format(question_id)),
                    parse_mode='Markdown')
                for answer in answers_list:
                    answer, keyboard = send_answer(question_id,
                                                   answer[0],
                                                   call.from_user.id,
                                                   short=True)
                    # bot.send_message(call.from_user.id, answer, reply_markup=showkeyboard_keyboard)
                    bot.send_message(call.from_user.id,
                                     answer,
                                     reply_markup=keyboard)

        elif call.data == 'show_keyboard':
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Loading Full Keyboard...")
            keyboard = send_answer(question_id,
                                   forwarded_user,
                                   call.from_user.id,
                                   short=True)[1]
            bot.edit_message_reply_markup(call.from_user.id,
                                          call.message.message_id,
                                          reply_markup=keyboard)

        elif call.data == "getfile":
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Sending File...")

            user = call.from_user.first_name
            if call.from_user.last_name is not None:
                user = call.from_user.first_name + ' ' + call.from_user.last_name
            if call.from_user.username is not None:
                user = user + ' @' + call.from_user.username

            ### GET FILE is used for both My Questions and All Questions
            # My Questions
            if emoji.demojize(message.text).startswith(':bust_in_silhouette:'):
                questions = cur.execute(
                    '''SELECT id, tel_id, question, status FROM questions WHERE tel_id = (%s) ORDER BY id DESC''',
                    (call.from_user.id, )).fetchall()
                FILE_NAME = str(
                    call.from_user.id) + '/Questions of ' + user + '.txt'
            # All Questions
            elif emoji.demojize(message.text).startswith(':page_facing_up:'):
                questions = cur.execute(
                    '''SELECT id, tel_id, question, status FROM questions ORDER BY id DESC'''
                ).fetchall()
                FILE_NAME = str(
                    call.from_user.id) + '/All Questions - ' + user + '.txt'

            # Making a directory for each user
            if not os.path.exists(str(call.from_user.id)):
                os.mkdir(str(call.from_user.id))

            # Some settings for styling the output
            q_sep = '=' * 50
            a_sep = '-' * 46

            # Output .txt file
            with open(FILE_NAME, 'w') as f:
                f.write('Requested by: ' + user + '\n\n\n')

                if len(questions) > 0:
                    for question in questions:
                        question_owner = question[1]
                        question_id = question[0]
                        question_text = question[2]
                        question_status = question[3]

                        # like_button is disabled now
                        # like_number = cur.execute('''SELECT count(*) FROM Like_Question WHERE question_id = (%s)''', (question[0],)).fetchone()[0]
                        # if question_owner == call.from_user.id:
                        #     if like_number > 0:
                        #         formatted_question = '#'+ str(question_id) + '   ' + str(question_status) + ' - Sent by: You - ' + 'Likes: {0}\n'.format(like_number) + q_sep + '\n' + question_text + '\n\n'
                        #     else:
                        #         formatted_question = '#'+ str(question_id) + '   ' + str(question_status) + ' - Sent by: You\n' + q_sep + '\n' + question_text + '\n\n'
                        #
                        # else:
                        #     formatted_question = '#'+ str(question_id) + '   ' + str(question_status) + '\n' + q_sep + '\n' + question_text + '\n\n'

                        if question_owner == call.from_user.id:
                            formatted_question = '#' + str(
                                question_id
                            ) + '   ' + str(
                                question_status
                            ) + ' - Sent by: You\n' + q_sep + '\n' + question_text + '\n\n'
                        else:
                            formatted_question = '#' + str(
                                question_id
                            ) + '   ' + str(
                                question_status
                            ) + '\n' + q_sep + '\n' + question_text + '\n\n'
                        f.write(q_sep + '\n' + formatted_question)

                        ### ANSWERs OF each QUESTION

                        # This sorts the answer by role (Admins first, then students, then TAs [alphabetical] and then
                        # based on accepted or not accepted)
                        user_answers = cur.execute(
                            '''SELECT Answers.tel_id, answer, accepted_answer, rate_answer, role FROM Answers, Users WHERE
question_id = (%s) AND Answers.tel_id = Users.tel_id ORDER BY role DESC, accepted_answer DESC''',
                            (question[0], )).fetchall()

                        if len(user_answers) > 0:
                            answer_section = a_sep + '\n' + '-' * 13 + '     Answers     ' + '-' * 13
                            answer_section = '\t'.join(
                                ('\n' +
                                 answer_section.lstrip()).splitlines(True))
                            f.write(answer_section)

                        for answer in user_answers:

                            answer_owner = answer[0]
                            answer_text = answer[1]
                            accepted_answer = answer[2]
                            rate = answer[3]
                            role = answer[4]

                            if accepted_answer:
                                status = 'Accepted - Rated ' + str(
                                    answer[3]) + '/5'.format(answer[3])
                            else:
                                status = 'Not Accepted'

                            question_owner_role = \
                            cur.execute('''SELECT role FROM Users WHERE tel_id = (%s)''', (question_owner,)).fetchone()[0]

                            ## If a Question is sent by ADMIN only accepted answers will be shown
                            if (question_owner_role
                                    in vip) and not accepted_answer:
                                continue

                            if role == 'ADMIN':
                                if answer_owner == call.from_user.id:
                                    answer = a_sep + '\nSent by: You (ADMIN)' + '\n' + a_sep + '\n' + answer_text
                                else:
                                    answer = a_sep + '\nSent by: ADMIN (#' + str(
                                        answer_owner
                                    ) + ')' + '\n' + a_sep + '\n' + answer_text
                                answer = '\t'.join(
                                    ('\n' + answer.lstrip()).splitlines(True))

                            else:
                                if answer_owner == call.from_user.id:
                                    answer = a_sep + '\nSent by: You - ' + status + '\n' + a_sep + '\n' + answer_text
                                else:
                                    answer = a_sep + '\nSent by: #' + str(
                                        answer_owner
                                    ) + ' - ' + status + '\n' + a_sep + '\n' + answer_text
                                answer = '\t'.join(
                                    ('\n' + answer.lstrip()).splitlines(True))

                            f.write(answer + '\n\n')

                        f.write('\n')
                f.write(q_sep + '\n' + q_sep + '\n' + 'END OF FILE')

            bot.edit_message_reply_markup(call.from_user.id,
                                          call.message.message_id,
                                          reply_markup=None)
            bot.send_document(call.from_user.id, open(FILE_NAME, "r"))

        # SHOW MORE KEY
        elif call.data == 'show_more':
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Show More...")
            # SHOW MORE for a QUESTION
            if question_res is not None:
                question, keyboard = send_question(forwarded_question,
                                                   call.from_user.id,
                                                   short=False)
                bot.edit_message_text(question,
                                      call.from_user.id,
                                      call.message.message_id,
                                      reply_markup=keyboard)

            # SHOW MORE for an ANSWER
            elif answer_res is not None:
                answer, keyboard = send_answer(forwarded_question,
                                               forwarded_user,
                                               call.from_user.id,
                                               short=False)
                bot.edit_message_text(answer,
                                      call.from_user.id,
                                      call.message.message_id,
                                      reply_markup=keyboard)

        # SHOW LESS KEY
        elif call.data == 'show_less':
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Show Less...")
            if question_res is not None:
                question, keyboard = send_question(forwarded_question,
                                                   call.from_user.id,
                                                   short=True)
                bot.edit_message_text(question,
                                      call.from_user.id,
                                      call.message.message_id,
                                      reply_markup=keyboard)

            elif answer_res is not None:
                answer, keyboard = send_answer(forwarded_question,
                                               forwarded_user,
                                               call.from_user.id,
                                               short=True)
                bot.edit_message_text(answer,
                                      call.from_user.id,
                                      call.message.message_id,
                                      reply_markup=keyboard)

        # COMMENT

        elif call.data == 'comment_question':
            role = cur.execute(
                '''SELECT role FROM Users WHERE tel_id = (%s)''',
                (call.from_user.id, )).fetchone()[0]
            question_state = cur.execute(
                '''SELECT status FROM Questions WHERE id = (%s)''',
                (forwarded_question, )).fetchone()[0]

            if (question_state == 'OPEN'):  # or (role in ['ADMIN', 'TA']):
                bot.answer_callback_query(callback_query_id=call.id,
                                          text="Send Comment!")
                cur.execute(
                    '''UPDATE Users SET state = (%s) WHERE tel_id = (%s)''',
                    ('Send Comment', call.from_user.id))
                bot.reply_to(
                    call.message,
                    emoji.emojize(
                        ':right_arrow: Send your Comment for: *Question ' +
                        str(forwarded_question) + '*'),
                    reply_markup=Finish_Discard_keyboard,
                    parse_mode='Markdown')
            else:
                # QUESTION IS CLOSED OR REPORTED
                bot.answer_callback_query(
                    callback_query_id=call.id,
                    text="Question is {0}!".format(question_state),
                    show_alert=True)

        elif call.data == 'like_question':

            check_like = cur.execute(
                '''SELECT question_id FROM Like_Question WHERE question_id = (%s) AND liked_by = (%s)''',
                (
                    question_id,
                    call.from_user.id,
                )).fetchone()

            if check_like is None:
                cur.execute(
                    '''INSERT INTO Like_Question (question_id, liked_by) VALUES (%s, %s)''',
                    (question_id, call.from_user.id))
                like_number = cur.execute(
                    '''SELECT count(*) FROM Like_Question WHERE question_id = (%s)''',
                    (question_id, )).fetchone()[0]

                if like_number % 5 == 0:
                    question_owner = cur.execute(
                        '''SELECT tel_id FROM Questions WHERE id = (%s)''',
                        (question_id, )).fetchone()[0]
                    bot.send_message(
                        question_owner,
                        emoji.emojize(
                            ':red_heart: Good Job! Your Question (#Q_{0}) liked by {1} people!\n'
                            ':right_arrow: Keep sending smart questions.'.
                            format(question_id, like_number)))

            bot.answer_callback_query(
                callback_query_id=call.id,
                text=emoji.emojize(
                    ":red_heart: You liked Question {0}".format(question_id)))
            try:
                keyboard = send_question(question_id,
                                         call.from_user.id,
                                         short=True)[1]
                bot.edit_message_reply_markup(call.from_user.id,
                                              call.message.message_id,
                                              reply_markup=keyboard)
            except:
                pass

        # LOADING ATTACHMENTS
        ## LOADING PHOTO
        elif call.data == 'photo':
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Loading Photo...")
            if question_res is not None:
                photo_id = cur.execute(
                    '''SELECT photo FROM Questions WHERE id = (%s)''',
                    (forwarded_question, )).fetchone()[0]
                bot.send_photo(
                    call.from_user.id, photo_id,
                    emoji.emojize(
                        ':framed_picture: #Q_{0}'.format(forwarded_question)),
                    call.message.message_id)
            elif answer_res is not None:
                photo_id = cur.execute(
                    '''SELECT photo FROM Answers WHERE question_id = (%s) AND tel_id = (%s)''',
                    (forwarded_question, forwarded_user)).fetchone()[0]
                bot.send_photo(
                    call.from_user.id, photo_id,
                    emoji.emojize(':framed_picture: #A_{0} #{1}'.format(
                        forwarded_question, forwarded_user)),
                    call.message.message_id)

        ## LOADING DOCUMENT
        elif call.data == 'document':
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Loading Document...")
            if question_res is not None:
                document_id = cur.execute(
                    '''SELECT document FROM Questions WHERE id = (%s)''',
                    (forwarded_question, )).fetchone()[0]
                bot.send_document(
                    call.from_user.id,
                    document_id,
                    call.message.message_id,
                    caption=emoji.emojize(
                        ':paperclip: #Q_{0}'.format(forwarded_question)))
            elif answer_res is not None:
                document_id = cur.execute(
                    '''SELECT document FROM Answers WHERE question_id = (%s) AND tel_id = (%s)''',
                    (forwarded_question, forwarded_user)).fetchone()[0]
                bot.send_document(call.from_user.id,
                                  document_id,
                                  call.message.message_id,
                                  caption=emoji.emojize(
                                      ':paperclip: #A_{0} #{1}'.format(
                                          forwarded_question, forwarded_user)))

        # REPORTING A USER
        ###### COMPLETE HERE
        elif call.data == "report_user":
            role = cur.execute(
                '''SELECT role FROM Users WHERE tel_id = (%s)''',
                (forwarded_user, )).fetchone()[0]

            # ONLY STUDENTS CAN BE REPORTED NOT ADMINs AND TAs
            if role == 'STUDENT':
                check_reported = cur.execute(
                    '''SELECT tel_id FROM Report_User WHERE tel_id = (%s) AND reported_by = (%s)''',
                    (forwarded_user, call.from_user.id)).fetchone()

                if check_reported is None:

                    bot.answer_callback_query(callback_query_id=call.id,
                                              text="User Reported. Thanks!",
                                              show_alert=True)
                    cur.execute(
                        '''INSERT INTO Report_User (tel_id, reported_by) VALUES (%s, %s)''',
                        (forwarded_user, call.from_user.id))

                    ban_user_id = cur.execute(
                        '''SELECT tel_id, count(tel_id) FROM Report_User WHERE tel_id = (%s) GROUP BY tel_id HAVING count(tel_id) > (%s)''',
                        (forwarded_user, report_user_limit)).fetchone()[0]

                    if call.message.date is not None:
                        date = call.message.date
                    else:
                        date = call.message.edit_date

                    cur.execute(
                        '''UPDATE Report_User SET report_date = (%s) WHERE tel_id = (%s)''',
                        (date, ban_user_id))
                    cur.execute(
                        '''UPDATE Users SET state = 'BANNED' WHERE tel_id = (%s)''',
                        (ban_user_id, ))

                else:
                    bot.answer_callback_query(
                        callback_query_id=call.id,
                        text="This user has already been reported by you!",
                        show_alert=True)

            elif role in ['ADMIN', 'TA']:
                bot.answer_callback_query(
                    callback_query_id=call.id,
                    text="You CANNOT report Admins and TAs!",
                    show_alert=True)

        ##################################
        #########   QUESTION   ###########
        ##################################
        elif call.data == "follow_question":

            try:
                question_owner = cur.execute(
                    '''SELECT tel_id FROM Questions WHERE id = (%s)''',
                    (forwarded_question, )).fetchone()[0]
                role = cur.execute(
                    '''SELECT role FROM Users WHERE tel_id = (%s)''',
                    (question_owner, )).fetchone()[0]
                print(role)
                if role in vip:
                    bot.answer_callback_query(
                        callback_query_id=call.id,
                        text=emoji.emojize(
                            ":cross_mark: Cannot follow Questions sent by ADMINs or TAs."
                        ),
                        show_alert=True)

                else:
                    if question_owner == call.from_user.id:
                        bot.answer_callback_query(
                            callback_query_id=call.id,
                            text=emoji.emojize(
                                ":cross_mark: Question {0} is your own question."
                                .format(question_id)))
                    else:
                        cur.execute(
                            '''INSERT INTO Follow_Question (question_id, follower) VALUES (%s, %s)''',
                            (forwarded_question, call.from_user.id))

                        previous_answers_num = cur.execute(
                            '''SELECT count(question_id) FROM Answers WHERE question_id = (%s)''',
                            (forwarded_question, )).fetchone()[0]
                        bot.answer_callback_query(
                            callback_query_id=call.id,
                            text=emoji.emojize(
                                ":TOP_arrow: Fowlloing Question {0}"
                                "\n:right_arrow: Already " +
                                str(previous_answers_num) +
                                " Answer(s) available in archive.".format(
                                    question_id)),
                            show_alert=True)
            except Exception as e:
                bot.answer_callback_query(
                    callback_query_id=call.id,
                    text=emoji.emojize(
                        ":right_arrow: You have already followed Question " +
                        str(forwarded_question)),
                    show_alert=True)

        # ANSWERING A QUESTION
        elif call.data == "answer_question":
            role = cur.execute(
                '''SELECT role FROM Users WHERE tel_id = (%s)''',
                (call.from_user.id, )).fetchone()[0]
            question_state = cur.execute(
                '''SELECT status FROM Questions WHERE id = (%s)''',
                (forwarded_question, )).fetchone()[0]
            if (question_state == 'OPEN') or (role in ['ADMIN', 'TA']):
                bot.answer_callback_query(callback_query_id=call.id,
                                          text="Send answer!")
                cur.execute(
                    '''UPDATE Users SET state = (%s) WHERE tel_id = (%s)''',
                    ('Send Answer', call.from_user.id))
                bot.reply_to(
                    call.message,
                    emoji.emojize(
                        ':right_arrow: Send your answer for: *Question ' +
                        str(forwarded_question) + '*'),
                    reply_markup=Finish_Discard_keyboard,
                    parse_mode='Markdown')
            else:
                # QUESTION IS CLOSED OR REPORTED
                bot.answer_callback_query(
                    callback_query_id=call.id,
                    text="Question is {0}!".format(question_state),
                    show_alert=True)

        # REPORTING A QUESTION
        elif call.data == "report_question":
            # to avoid reporting a question two times from the same user
            check_reported = cur.execute(
                '''SELECT question_id FROM Report_Question WHERE question_id = (%s) AND reported_by = (%s)''',
                (forwarded_question, call.from_user.id)).fetchone()

            if check_reported is None:
                bot.answer_callback_query(
                    callback_query_id=call.id,
                    text="Questions {0} reported. Thanks.".format(question_id),
                    show_alert=True)
                cur.execute(
                    '''INSERT INTO Report_Question (question_id, reported_by) VALUES (%s, %s)''',
                    (forwarded_question, call.from_user.id))

                # Questions beyond report limit will be changed to ___Reported Question___
                question_reported = cur.execute(
                    '''SELECT count(question_id) FROM Report_Question WHERE question_id = (%s)''',
                    (forwarded_question, )).fetchone()[0]

                role = cur.execute(
                    '''SELECT role FROM Users WHERE tel_id = (%s)''',
                    (call.from_user.id, )).fetchone()[0]

                if (question_reported >= report_question_limit) or (
                        role in instant_report_roles):


                    reported_text, reported_photo, reported_document, reported_document_type, reported_document_size = \
                        cur.execute('''SELECT question, photo, document, document_type, document_size FROM Questions WHERE id = (%s)''',
                                                (forwarded_question,)).fetchone()
                    cur.execute(
                        '''UPDATE Report_Question SET reported_text = (%s), photo = (%s), document = (%s), document_type = (%s), document_size = (%s) WHERE question_id = (%s)''',
                        (
                            reported_text,
                            reported_photo,
                            reported_document,
                            reported_document_type,
                            reported_document_size,
                            forwarded_question,
                        ))

                    cur.execute(
                        '''UPDATE Questions SET question = (%s), status = (%s), photo = NULL, document = NULL, document_type = NULL, document_size = NULL WHERE id = (%s)''',
                        ("___Reported Question___", 'REPORTED', question_id))

                    if role in instant_report_roles:
                        question_owner_id = cur.execute(
                            '''SELECT tel_id FROM Questions WHERE id = (%s)''',
                            (question_id, )).fetchone()[0]
                        first_name, last_name, username = cur.execute(
                            '''SELECT first_name, last_name, username FROM Users WHERE tel_id = (%s)''',
                            (question_owner_id, )).fetchone()

                        bot.send_message(
                            call.from_user.id,
                            emoji.emojize(
                                ':white_heavy_check_mark: Question #Q_{} of user: {} {} (@{}) reported.'
                                .format(question_id, first_name, last_name,
                                        username)))
                        try:
                            bot.send_message(
                                question_owner_id,
                                emoji.emojize(
                                    ':warning: Your question #Q_{} has been reported. Please be careful when asking questions.'
                                    .format(question_id)))
                        except:
                            pass
            else:
                bot.answer_callback_query(
                    callback_query_id=call.id,
                    text="Question {0} has already been reported by you!".
                    format(question_id),
                    show_alert=True)

        ##################################
        #########    ANSWER    ###########
        ##################################
        # ACCEPTING AN ANSWER
        elif call.data == "accept_answer":

            accepted_answer = cur.execute(
                '''SELECT accepted_answer FROM Answers WHERE question_id = (%s) AND tel_id = (%s)''',
                (forwarded_question, forwarded_user)).fetchone()[0]
            if accepted_answer == 0:

                ## Questions sent by VIP can have more than one accepted answer
                question_owner_role = cur.execute(
                    '''SELECT role FROM Users, Questions WHERE
                                      Users.tel_id = Questions.tel_id AND Questions.id = (%s)''',
                    (question_id, )).fetchone()[0]
                # if question is NOT sent by VIP, then previous accepted answer is removed and newer answer is replaced

                accepted_already_flag = cur.execute(
                    '''SELECT accepted_answer FROM Answers WHERE question_id = (%s)''',
                    (forwarded_question, )).fetchone()[0]

                if question_owner_role not in vip:
                    # to check if already another answer was accepted
                    cur.execute(
                        '''UPDATE Answers SET accepted_answer = 0 WHERE question_id = (%s)''',
                        (forwarded_question, ))

                cur.execute(
                    '''UPDATE Answers SET accepted_answer = 1 WHERE question_id = (%s) AND tel_id = (%s)''',
                    (forwarded_question, forwarded_user))
                bot.answer_callback_query(callback_query_id=call.id,
                                          text="Answer marked as accepted!")

                bot.send_message(
                    call.from_user.id,
                    emoji.emojize(":right_arrow: Please rate the answer:"),
                    reply_markup=rate_accept_answer_keyboard)
                cur.execute(
                    '''UPDATE Users SET state = (%s) WHERE tel_id = (%s)''',
                    ('Rate Answer', call.from_user.id))
                cur.execute(
                    '''UPDATE Questions SET status = (%s) WHERE id = (%s)''',
                    ('CLOSED', question_id))

                # Sending Question and Accepted Answer to all users except question owner
                send_list = cur.execute(
                    '''SELECT tel_id FROM Users WHERE tel_id != (%s)''',
                    (call.from_user.id, )).fetchall()

                if accepted_already_flag != 1:
                    for user in send_list:
                        try:
                            if question_owner_role not in vip:
                                bot.send_message(
                                    user[0],
                                    emoji.emojize(
                                        ':white_heavy_check_mark: #Q_{0} is answered now.'
                                        .format(forwarded_question)),
                                    reply_markup=showhere_keyboard,
                                    disable_notification=True)
                            else:
                                accepted_answers_count = cur.execute(
                                    '''SELECT count(answers) FROM Answers WHERE question_id = (%s) and accepted_answer = 1''',
                                    (question_id, )).fetchone()[0]
                                bot.send_message(
                                    user[0],
                                    emoji.emojize(
                                        ':white_heavy_check_mark: #Q_{0} sent by ADMIN has accepted answer ({1} Accepted Answers).'
                                        '\n:right_arrow: Enter Question Number ({0}) to see all answers.'
                                        .format(question_id,
                                                accepted_answers_count)),
                                    disable_notification=True)
                        except Exception as e:
                            print(
                                'Sending Accepted Answer to some users failed!',
                                e)

            else:
                bot.answer_callback_query(callback_query_id=call.id,
                                          text="Answer already accepted!",
                                          show_alert=True)

        # SHOWING ACCEPTED ANSWER and its QUESTION to receiving users
        elif call.data == 'show_here':
            # forwarded question and forwarded user is NOT VALID here.
            pattern = ':white_heavy_check_mark: #Q_(\d+) \w+'  #question_id is in (\d+)
            res = re.match(pattern, emoji.demojize(message.text))
            if res is not None:
                # Sending Question
                accepted_question_id = res.group(1)
                # Sending Answer
                answer_owner = cur.execute(
                    '''SELECT tel_id FROM Answers WHERE question_id = (%s) and accepted_answer = 1''',
                    (accepted_question_id, )).fetchone()[0]
                answer, keyboard = send_answer(accepted_question_id,
                                               answer_owner,
                                               call.from_user.id,
                                               short=True)

                bot.delete_message(call.from_user.id, call.message.message_id)
                bot.send_message(
                    call.from_user.id,
                    emoji.emojize(
                        ':down_arrow: Accepted answer for #Q_{0}.'.format(
                            accepted_question_id)))
                bot.send_message(call.from_user.id,
                                 answer,
                                 reply_markup=keyboard)

        elif call.data == 'close_question':
            question_state = cur.execute(
                '''SELECT status FROM Questions WHERE id = (%s)''',
                (question_id, )).fetchone()[0]
            if question_state == 'CLOSED':
                bot.answer_callback_query(
                    callback_query_id=call.id,
                    text=emoji.emojize(
                        ":cross_mark: Question {0} is already closed.".format(
                            question_id)),
                    show_alert=True)
            elif question_state == 'OPEN':
                cur.execute(
                    '''UPDATE Questions SET status = (%s) WHERE id = (%s)''',
                    ('CLOSED', question_id))
                question_owner = cur.execute(
                    '''SELECT tel_id FROM Questions WHERE id = (%s)''',
                    (question_id, )).fetchone()[0]
                try:
                    bot.send_message(
                        question_owner,
                        emoji.emojize(
                            ':cross_mark: Your Question (#Q_{0}) is closed by ADMIN.'
                        ).format(question_id))
                except:
                    print('User {0} has blocked Robot.'.format(question_owner))

                bot.answer_callback_query(
                    callback_query_id=call.id,
                    text=emoji.emojize(
                        ":white_heavy_check_mark: Question {0} closed successfully."
                        .format(question_id)),
                    show_alert=True)

        ##################################
        ###    Next and Previous Page  ###
        ##################################
        elif call.data == "next_page_question":
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Next Page")
            photo, document, document_type, document_size = \
                cur.execute('''SELECT photo, document, document_type, document_size FROM Questions WHERE id = (%s)''', (forwarded_question, )).fetchone()

            # Specifying keyboard accordingly
            keyboard = telebot.types.InlineKeyboardMarkup(row_width=4)

            role = cur.execute(
                '''SELECT role FROM Users WHERE tel_id = (%s)''',
                (call.from_user.id, )).fetchone()[0]

            if role == 'ADMIN':
                close_question = telebot.types.InlineKeyboardButton(
                    emoji.emojize(':cross_mark: Close'),
                    callback_data='close_question')
                keyboard.add(close_question, report_question, follow_question,
                             previous_page_question)
            else:
                keyboard.add(report_question, follow_question,
                             previous_page_question)

            if photo is not None:
                keyboard.add(photo_button)
            if document is not None:
                document_button = telebot.types.InlineKeyboardButton(
                    emoji.emojize(':paperclip: {0} ({1})'.format(
                        document_type, document_size)),
                    callback_data='document')
                keyboard.add(document_button)

            # Editing Message
            bot.edit_message_reply_markup(call.from_user.id,
                                          call.message.message_id,
                                          reply_markup=keyboard)

        elif call.data == "previous_page_question":
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Previous Page")
            keyboard = send_question(forwarded_question,
                                     call.from_user.id,
                                     short=True)[1]

            bot.edit_message_reply_markup(call.from_user.id,
                                          call.message.message_id,
                                          reply_markup=keyboard)

        elif call.data == "next_page_answer":
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Next Page")
            photo, document, document_type, document_size = \
                cur.execute('''SELECT photo, document, document_type, document_size FROM Answers WHERE question_id = (%s) AND tel_id = (%s)'''
                    , (forwarded_question, forwarded_user)).fetchone()
            general_keyboard = telebot.types.InlineKeyboardMarkup()
            general_keyboard.add(report_user, previous_page_answer)

            if photo is not None:
                general_keyboard.add(photo_button)
            if document is not None:
                document_button = telebot.types.InlineKeyboardButton(
                    emoji.emojize(':paperclip: {0} ({1})'.format(
                        document_type, document_size)),
                    callback_data='document')
                general_keyboard.add(document_button)

            bot.edit_message_reply_markup(call.from_user.id,
                                          call.message.message_id,
                                          reply_markup=general_keyboard)

        elif call.data == "previous_page_answer":
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Previous Page")
            keyboard = send_answer(forwarded_question,
                                   forwarded_user,
                                   call.from_user.id,
                                   short=True)[1]

            bot.edit_message_reply_markup(call.from_user.id,
                                          call.message.message_id,
                                          reply_markup=keyboard)

        ##################################
        ###    Next and Previous Page  ###
        ##################################
        # JUST A BUTTON WHEN THE BOT STARTS
        elif call.data == "send_question":
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Send your question...")
            bot.send_message(
                call.from_user.id,
                emoji.emojize(
                    ':right_arrow: Send your question, then select Finish.\n\n'
                    ':paperclip: 1 File and 1 Photo are allowed as attachment.'
                ),
                reply_markup=Finish_Discard_keyboard)
            cur.execute(
                '''UPDATE Users SET state = (%s) WHERE tel_id = (%s)''',
                ('Send Question', call.from_user.id))

        elif call.data == 'next_page_contact':
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Next Page")
            bot.edit_message_text(emoji.emojize(
                ":envelope: Contact Info:\n\n"
                ":bust_in_silhouette: Ali Arjmand:\n        :white_small_square: @AliArjomandBigdeli\n        :black_small_square: [email protected]\n"
                ":bust_in_silhouette: Mohammad Hossein Amini\n        :white_small_square: @MHosseinAmini\n        :black_small_square: [email protected] \n"
                ":bust_in_silhouette: Parsa Asadi\n        :white_small_square: @parsa_assadi\n        :black_small_square: [email protected]\n"
                ":bust_in_silhouette: S. Reza Hashemi:\n        :white_small_square: @SeyedReza_110\n        :black_small_square: [email protected]\n"
                ":bust_in_silhouette: Amin Ansarian\n        :white_small_square: @MarshalAmin\n        :black_small_square: [email protected]\n"
                ":bust_in_silhouette: Roozbeh Bazargani\n        :white_small_square: @roozbeh711\n        :black_small_square: [email protected]\n"
                ":bust_in_silhouette: Amir Hossein Zamani\n        :white_small_square: @AHZ975\n        :black_small_square: [email protected]"
            ),
                                  call.from_user.id,
                                  call.message.message_id,
                                  reply_markup=previous_page_contact)

        elif call.data == 'previous_page_contact':
            bot.answer_callback_query(callback_query_id=call.id,
                                      text="Previous Page")
            bot.edit_message_text(emoji.emojize(
                ":envelope: Contact Info:\n\n"
                ":bust_in_silhouette: Ali Hejazi:\n        :white_small_square: @Ali_H93\n        :black_small_square: [email protected]\n"
                ":bust_in_silhouette: Nima Sedghiye\n        :white_small_square:  @Nima_sedghiye\n        :black_small_square: [email protected]\n"
                ":bust_in_silhouette: Hamed Hosseini\n        :white_small_square: @HMDHosseini\n        :black_small_square: [email protected]"
            ),
                                  call.from_user.id,
                                  call.message.message_id,
                                  reply_markup=next_page_contact)
示例#10
0
def send_welcome(message):
    """This function registers user and sends welcome message."""
    # 2 Stages: Temporary User (not Enrolled Yet) - Permanent User
    check_temp_user = cur.execute(
        '''SELECT tel_id FROM Users_Temp WHERE tel_id = (%s)''',
        (message.from_user.id, )).fetchone()
    check_user = cur.execute(
        '''SELECT tel_id FROM Users WHERE tel_id = (%s)''',
        (message.from_user.id, )).fetchone()

    print(check_temp_user, check_user)
    if check_temp_user is None:
        ### Permanent Users First Touch
        if check_user is None:
            cur.execute(
                '''INSERT INTO Users_Temp (tel_id, first_name, last_name, username, login_date, state)
                            VALUES (%s, %s, %s, %s, %s, %s)''',
                (message.from_user.id, message.from_user.first_name,
                 message.from_user.last_name, message.from_user.username,
                 message.date, 'START'))

            bot.send_message(
                message.from_user.id,
                emoji.emojize(
                    ":desktop_computer: Hi, I'm *Stackoverflow* Bot. "
                    "\n:bust_in_silhouette: Enter your *Student Number* to register."
                ),
                parse_mode="Markdown")
        ### Permanent Users After Login Message
        else:
            bot.send_message(
                message.from_user.id,
                emoji.emojize(":desktop_computer: *Stackoverflow* Bot"),
                parse_mode="Markdown",
                reply_markup=main_reply_keyboard)

            cur.execute(
                '''UPDATE Users SET state = 'IDLE' WHERE tel_id = (%s)''',
                (message.from_user.id, ))

    else:
        ### Temporary Users Not Registered Warning
        if check_user is None:
            bot.send_message(
                message.from_user.id,
                emoji.emojize(
                    ":warning: Not registered yet.\n"
                    ":bust_in_silhouette: Enter your *Student Number* to register."
                ),
                parse_mode="Markdown",
                reply_markup=None)

        ### Permanent Users Message when they send /start command
        else:

            bot.send_message(
                message.from_user.id,
                emoji.emojize(
                    ":desktop_computer: *AUT Stackoverflow* Bot\n\n"
                    ":red_triangle_pointed_down: *Latest News*\n"
                    "      :paperclip: HW1: https://goo.gl/LecD5n\n"
                    "      :clapper_board: Recorded Sessions: goo.gl/uVcDD4"),
                parse_mode="Markdown",
                reply_markup=main_reply_keyboard)

            cur.execute(
                '''UPDATE Users SET state = 'IDLE' WHERE tel_id = (%s)''',
                (message.from_user.id, ))
示例#11
0
def chat(message):
    # print(emoji.demojize(message.text))

    try:
        state = cur.execute('''SELECT state FROM Users WHERE tel_id = (%s)''',
                                         (message.from_user.id,)).fetchone()
        if state is not None:
            state = state[0]

            cur.execute('''UPDATE Users SET first_name = (%s), last_name = (%s), username = (%s) WHERE tel_id = (%s)''',
                        (message.from_user.first_name,
                         message.from_user.last_name,
                         message.from_user.username,
                         message.from_user.id))
            ####################################
            ####            IDLE            ####
            ####################################
            if state == 'IDLE':

                # SEND QUESTION
                if emoji.demojize(message.text) == ':question_mark: Send Question':
                    bot.send_message(message.from_user.id, emoji.emojize(
                        ':right_arrow: Send your question, then select Finish.\n\n'
                        ':paperclip: 1 File and 1 Photo are allowed as attachment.'),
                                     reply_markup=Finish_Discard_keyboard)
                    cur.execute('''UPDATE Users SET state = (%s) WHERE tel_id = (%s)''',
                                ('Send Question', message.from_user.id))

                # MY PROFILE
                elif emoji.demojize(message.text) == ':bust_in_silhouette: My Profile':
                    try:
                        ## FIRSTNAME, LASTNAME, USERNAME
                        user = emoji.emojize(":bust_in_silhouette: " + message.from_user.first_name)
                        if message.from_user.last_name is not None:
                            user = user + message.from_user.last_name
                        if message.from_user.username is not None:
                            user = user + " (@{0})".format(message.from_user.username)

                        role, st_num = cur.execute('''SELECT role, st_num from Users WHERE tel_id = (%s)''', (message.from_user.id, )).fetchone()
                        user = user + '\n' + emoji.emojize(':white_small_square:' ) + '{0} ({1})'.format(role.capitalize(), st_num)

                        ## GETTING QUESTIONS
                        my_questions = cur.execute('''SELECT id FROM Questions WHERE tel_id = (%s) ORDER BY id''',
                                                (message.from_user.id,)).fetchall()
                        if len(my_questions) > 0:
                            ### template
                            questions = ':question_mark: Questions:'
                            ### counter is for printing three questions in each row
                            counter = 0
                            for question in my_questions:
                                if counter % 3 == 0:
                                    questions = questions + '\n'


                                # LIKE is disabled now
                                # like_number = cur.execute('''SELECT count(*) FROM Like_Question WHERE question_id = (%s)''', (question[0], )).fetchone()[0]
                                # if like_number > 0:
                                #     questions += '#Q_{0} ({1}:red_heart:)  '.format(question[0], like_number)
                                # else:
                                #     questions += '#Q_{0}  '.format(question[0])

                                counter = counter + 1
                        else:
                            questions = ':question_mark: Questions:\nNone'

                        ## GETTING ANSWERS
                        my_answers = cur.execute('''SELECT question_id, accepted_answer, rate_answer FROM Answers WHERE tel_id = (%s) ORDER BY question_id''',
                                                    (message.from_user.id,)).fetchall()
                        if len(my_answers) > 0:
                            ### counter is just to format the output by 3 in each row
                            counter = 0
                            answers = ':bright_button: Answers:'
                            for answer in my_answers:
                                if counter % 3 == 0:
                                    answers = answers + '\n'
                                if answer[1] == 0:
                                    answers += ':bright_button:#A_{0}  '.format(answer[0])
                                else:
                                    answers += ':white_heavy_check_mark:#A_{0} ({1}/5)  '.format(answer[0], answer[2])
                                counter = counter + 1

                        else:
                            answers = ':bright_button: Answers:\nNone'

                        ## TOTAL POINT calculation
                        point = 0

                        ## POINTS OF QUESTIONS AND ANSWERS
                        user_questions_count = cur.execute('''SELECT COUNT(id) FROM Questions WHERE tel_id = (%s)''', (message.from_user.id, )).fetchone()[0]
                        user_answers_count = cur.execute('''SELECT COUNT(question_id) FROM Answers WHERE tel_id = (%s)''', (message.from_user.id, )).fetchone()[0]
                        point = point + user_questions_count * question_point + user_answers_count * answer_point

                        ## POINTS OF ACCEPTED ANSWERS
                        user_accepted_answers = cur.execute('''SELECT rate_answer FROM Answers WHERE tel_id = (%s) AND accepted_answer = 1''', (message.from_user.id, )).fetchall()
                        for rate_answer in user_accepted_answers:
                            try:
                                point = point + rate_answer[0]/5.0*accepted_answer_point
                            except Exception as e:
                                print('There are some Accepted bot not Rated ANSWERs in Database!')

                        ## GETTING HIGHEST POINT
                        highest_point = cur.execute('''SELECT MAX(point) FROM Users''').fetchone()[0]
                        point = ':high_voltage: Points: {0}\n:high_voltage: Highest Point: {1}'.format(point, highest_point)

                        bot.send_message(message.from_user.id, emoji.emojize('\n\n'.join([user, questions, answers, point])), reply_markup=getfile_keyboard)

                    except Exception as e:
                        print('Something went wrong in My Profile of user: {0}'.format(message.from_user.id), e)
                        tb = traceback.format_exc()
                        print(tb)

                        bot.send_message(message.from_user.id, tb)
                        bot.send_message(admin_tel_id, 'Something went wrong in My Profile of user: {0}'.format(message.from_user.id))
                        bot.send_message(admin_tel_id, tb)

                # ALL QUESTIONS AND THEIR ANSWERS
                elif emoji.demojize(message.text) == ':page_facing_up: All Questions':
                    all_questions = cur.execute('''SELECT id, status FROM Questions ORDER BY id DESC LIMIT 10''').fetchall()
                    all_questions_count = cur.execute('''SELECT count(*) FROM Questions''').fetchone()[0]
                    questions = emoji.emojize(':page_facing_up: Total Questions: {0}\n\n'
                                              ':down_arrow: Recently Sent:\n'.format(all_questions_count))

                    if len(all_questions) > 0:

                        for question in all_questions:
                            question_id, question_state = question[0], question[1]
                            answers_count = cur.execute('''SELECT count(question_id) FROM Answers WHERE question_id = (%s)''',
                                            (question_id,)).fetchone()[0]
                            questions += emoji.emojize(':question_mark:#Q_') + "{0} - {1} Answer(s) - {2}\n".format(question_id, answers_count, question_state)
                    else:
                        questions += 'None'

                    # TOP Questions is disabled now
                    # questions += emoji.emojize('\n:down_arrow: Top Questions:\n')
                    # best_questions = cur.execute('''SELECT question_id, count(liked_by) FROM Like_Question GROUP BY question_id ORDER BY count(liked_by) DESC, question_id DESC LIMIT 3''').fetchall()
                    # for question in best_questions:
                    #     question_id = question[0]
                    #     like_number = question[1]
                    #     questions += emoji.emojize(':question_mark: #Q_{0} ({1}:red_heart:)\n'.format(question_id, like_number))

                    bot.send_message(message.from_user.id, questions, reply_markup=getfile_keyboard)

                # OPEN QUESTIONS
                elif emoji.demojize(message.text) == ':question_mark: Open Questions':
                    open_questions_list = cur.execute('''SELECT id FROM Questions WHERE status = (%s) ORDER BY id''',
                                                      ('OPEN',)).fetchall()
                    questions = emoji.emojize(':question_mark: Open Questions: ')
                    if len(open_questions_list) > 0:
                        for question in open_questions_list:
                            answers_count = \
                            cur.execute('''SELECT count(question_id) FROM Answers WHERE question_id = (%s)''',
                                        (question[0],)).fetchone()[0]
                            questions += "\n#Q_{0} - {1} Answer(s)".format(question[0], answers_count)
                    else:
                        questions +='None'

                    bot.send_message(message.from_user.id, questions)


                ### TOP STUDENTS
                elif emoji.demojize(message.text) == ':high_voltage: Top Students':
                    msg_text = emoji.emojize('\n:down_arrow: Top 5 Students:\n\n')
                    best_students = cur.execute(
                        '''SELECT st_num, first_name, last_name, point, tel_id FROM Users WHERE tel_id IS NOT NULL ORDER BY point DESC LIMIT 5''').fetchall()

                    for student in best_students:
                        try:
                            print(student)
                            student_id = student[0]
                            first_name = student[1]
                            last_name = student[2]
                            if last_name is None:
                                last_name = ''
                            point = student[3]
                            tel_id = student[4]

                            questions_num = cur.execute('''SELECT COUNT(id) FROM Questions WHERE tel_id = (%s)''', (tel_id, )).fetchone()[0]
                            answers_num = cur.execute('''SELECT COUNT(question_id) FROM Answers WHERE tel_id = (%s)''', (tel_id, )).fetchone()[0]
                            accepted_answers_num = cur.execute('''SELECT COUNT(question_id) FROM Answers WHERE tel_id = (%s) AND accepted_answer = 1''', (tel_id, )).fetchone()[0]

                            msg_text += emoji.emojize(
                                ':bust_in_silhouette: {0} - {1} {2} \n'
                                ':question_mark: {3}, :bright_button: {4}, :white_heavy_check_mark: {5} \n:high_voltage: {6} points\n\n'.format(student_id, first_name, last_name, questions_num, answers_num, accepted_answers_num, point))
                        except Exception as e:
                            print(e)

                    bot.send_message(message.from_user.id, msg_text)

                ### BY PRESSING A NUMBER, IT'S QUESTION WILL POP UP (IF ACCEPTED ANSWER IS READY, THAT WILL COME TOO)
                else:
                    # Check if entered only a number
                    q_pattern = r'^(?P<question_id>\d+)$'
                    q_res = re.match(q_pattern, message.text)

                    if q_res is not None:
                        question_id = q_res.group('question_id')
                        id = cur.execute('''SELECT id FROM Questions WHERE id = (%s)''', (question_id,)).fetchone()

                        # Check if number matches a question
                        if id is not None:
                            question, keyboard = send_question(question_id, message.from_user.id, short=True)
                            bot.send_message(message.from_user.id, question, reply_markup=keyboard)

                            # If Questions has accepted answer, BOT will send it too
                            question_state = cur.execute('''SELECT status FROM Questions WHERE id = (%s)''', (id, )).fetchone()[0]
                            if question_state != 'REPORTED':
                                answer_owners = cur.execute('''SELECT tel_id FROM Answers WHERE question_id = (%s) AND accepted_answer = 1''', (question_id, )).fetchall()
                                if len(answer_owners) > 0:
                                    for answer_owner in answer_owners:
                                        answer_owner = answer_owner[0]
                                        answer, keyboard = send_answer(question_id, answer_owner, message.from_user.id, short=True)

                                        if answer is not None:
                                            bot.send_message(message.from_user.id, answer, reply_markup=keyboard)


                            admins_answers = cur.execute('''SELECT answer, Answers.tel_id FROM Answers, Users WHERE Answers.tel_id = Users.tel_id AND
question_id = (%s) AND Users.role = (%s)''', (question_id, 'ADMIN')).fetchall()

                            for answer in admins_answers:
                                answer, keyboard = send_answer(question_id, answer[1], message.from_user.id, short=True)
                                bot.send_message(message.from_user.id, answer, reply_markup=keyboard)

                        else:
                            # Message when number is beyond total questions
                            total_questions_number = cur.execute('''SELECT count(id) FROM Questions''').fetchone()[0]
                            bot.send_message(message.from_user.id, emoji.emojize(
                                ':right_arrow: Number exceeded total questions.\n\n:question_mark: *Total Questions: {0}*'
                                    .format(total_questions_number)), parse_mode='Markdown')

                    # ADD OR REMOVE A USER
                    else:
                        ## ADDING A USER
                        if message.from_user.username in admins:
                            add_pattern = r'^add (?P<stnum>\d{1,30}) (?P<role>\w+)$'
                            add_res = re.match(add_pattern, message.text, re.IGNORECASE)

                            if add_res is not None:
                                st_num = add_res.group('stnum')
                                role = add_res.group('role').upper()
                                check_stnum = cur.execute('''SELECT st_num FROM Users WHERE st_num = (%s)''', (st_num, )).fetchone()

                                ### CHECKING FOR VALID ROLES SUCH AS STUDENT, TA, ETC
                                if role in valid_roles:
                                    if check_stnum is None:
                                        cur.execute('''INSERT INTO Users (st_num, role) VALUES (%s, %s)''', (st_num, role))
                                        bot.send_message(message.from_user.id, emoji.emojize(":white_heavy_check_mark: Student Number *{0}* "
                                                         "added with role *{1}*.".format(st_num, role)), parse_mode='Markdown')
                                    else:
                                        bot.send_message(message.from_user.id, emoji.emojize(':cross_mark: Student Number {0} is already added.'.format(st_num)))
                                else:
                                    bot.send_message(message.from_user.id, emoji.emojize(':cross_mark: Invalid role *{0}*.'.format(role)), parse_mode='Markdown')
                            ## REMOVING A USER
                            else:
                                remove_pattern = r'^remove (?P<st_num>\d{1,30})$'
                                remove_res = re.match(remove_pattern, message.text, re.IGNORECASE)

                                if remove_res is not None:
                                    st_num = remove_res.group('st_num')
                                    check_stnum = cur.execute('''SELECT st_num FROM Users WHERE st_num = (%s)''',
                                                              (st_num,)).fetchone()

                                    if check_stnum is not None:
                                        check_role = cur.execute('''SELECT role FROM Users WHERE st_num = (%s)''', (st_num, )).fetchone()[0]
                                        if check_role in ['ADMIN']:
                                            bot.send_message(message.from_user.id, emoji.emojize(
                                                ':cross_mark: Cannot remove *{0}s*.'.format(check_role)), parse_mode='Markdown')
                                        else:
                                            cur.execute('''DELETE FROM Users WHERE st_num = (%s) AND role NOT IN (%s)''',
                                                        (st_num, 'ADMIN'))
                                            cur.execute('''DELETE FROM Users_Temp WHERE st_num = (%s)''',
                                                (st_num, ))
                                            bot.send_message(message.from_user.id, emoji.emojize(
                                                ':white_heavy_check_mark: Student Number *{0}* removed.'.format(st_num)), parse_mode='Markdown')
                                    else:
                                        bot.send_message(message.from_user.id, emoji.emojize(
                                            ':cross_mark: Student Number {0} is already removed.'.format(st_num)))



            ####################################
            ####         Rate Answer        ####
            ####################################
            elif state == 'Rate Answer':

                pattern = r"(^(:bright_button:){1,5}$)"
                res = re.match(pattern, emoji.demojize(message.text))
                if res is not None:
                    rate = len(res.group(0).split("::"))

                    # Question and Answer Owner
                    forwarded_question, forwarded_user = cur.execute(
                        '''SELECT forwarded_question, forwarded_user FROM Users WHERE tel_id = (%s)''',
                        (message.from_user.id,)).fetchone()

                    cur.execute('''UPDATE Answers SET rate_answer = (%s) WHERE question_id = (%s) AND tel_id = (%s)''',
                                (rate, forwarded_question, forwarded_user))

                    bot.send_message(message.from_user.id, emoji.emojize(":white_heavy_check_mark: Thanks! Answer rated *{0}*.".format(rate)), reply_markup=main_reply_keyboard, parse_mode='Markdown')
                    bot.send_message(forwarded_user, emoji.emojize(
                        ':white_heavy_check_mark: Your answer for #Q_{0} accepted and rated {1}.\n'
                        ':high_voltage: Points Received: {2}'.format(forwarded_question, rate, accepted_answer_point*rate/5.0)))

                    # RESETING STATE TO IDLE
                    cur.execute('''UPDATE Users SET state = (%s)  WHERE tel_id = (%s)''', ('IDLE', message.from_user.id))
                    # Increasing point of answer owner
                    cur.execute('''UPDATE Users SET point = point + (%s) WHERE tel_id = (%s)''', (accepted_answer_point*rate/5.0, forwarded_user))



                else:
                    bot.reply_to(message, emoji.emojize(":cross_mark: Invalid input."))


            ####################################
            ####        Send Question       ####
            ####################################
            elif state in ['Send Question', 'Send Answer', 'Send Comment']:
                # FINISH KEY
                if emoji.demojize(message.text) == ':white_heavy_check_mark: Finish':
                    handle_message_finish(message)

                # DISCARD KEY
                elif emoji.demojize(message.text) == ':cross_mark: Discard':
                    # RESETING TO IDLE
                    cur.execute('''UPDATE Users SET state = (%s) WHERE tel_id = (%s)''', ('IDLE', message.from_user.id))
                    cur.execute('''UPDATE Users SET cont_typing = NULL, photo = NULL, document = NULL, document_type = NULL,
document_size = NULL WHERE tel_id = (%s)''', (message.from_user.id, ))
                    bot.send_message(message.from_user.id, emoji.emojize(':cross_mark: Discarded.'), reply_markup=main_reply_keyboard)
                    conn.commit()

                # CONTINUE TYPING ANSWER OR QUESTION
                else:
                    cont_typing = cur.execute('''SELECT cont_typing FROM Users WHERE tel_id = (%s)''',
                                                      (message.from_user.id,)).fetchone()[0]
                    if cont_typing == None:
                        cur.execute('''UPDATE Users SET cont_typing = (%s) WHERE tel_id = (%s)''',
                                    (message.text, message.from_user.id))
                    else:
                        cont_typing = cur.execute('''SELECT cont_typing FROM Users WHERE tel_id = (%s)''',
                                                          (message.from_user.id,)).fetchone()[0]
                        cur.execute('''UPDATE Users SET cont_typing=(%s) WHERE tel_id = (%s)''',
                                    (cont_typing + '\n' + message.text, message.from_user.id))

            ### SENDING GLOBAL MESSAGE TO ALL USERS (RESTRICTED TO ADMINs)
            elif state == 'SEND MSG TO ALL USERS':
                # FINISH KEY
                if emoji.demojize(message.text) == ':white_heavy_check_mark: Finish':
                    handle_message_finish(message)

                # DISCARD KEY
                elif emoji.demojize(message.text) == ':cross_mark: Discard':
                    # RESETING TO IDLE
                    cur.execute('''UPDATE Users SET state = (%s) WHERE tel_id = (%s)''', ('IDLE', message.from_user.id))
                    cur.execute('''UPDATE Users SET cont_typing = NULL, photo = NULL, document = NULL, document_type = NULL,
                document_size = NULL WHERE tel_id = (%s)''', (message.from_user.id,))
                    bot.send_message(message.from_user.id, emoji.emojize(':cross_mark: Discarded.'),
                                     reply_markup=main_reply_keyboard)

                else:
                    cur.execute('''UPDATE Users SET cont_typing = (%s) WHERE tel_id = (%s)''', (message.text, message.from_user.id, ))

        ####################################
        ####    NOT REGISTERED USERS    ####
        ####################################
        else:
            state = cur.execute('''SELECT state FROM Users_TEMP WHERE tel_id = (%s)''', (message.from_user.id, )).fetchone()
            if state is not None:
                state = state[0]
                ####################################
                ####            START           ####
                ####################################
                if state == 'START':
                    try:
                        pattern = r'^(?P<question_id>\d{1,30})$'
                        res = re.match(pattern, message.text)
                        if res.group():
                            st_num = res.groups()[0]

                            registered_st_num = cur.execute('''SELECT st_num FROM Users WHERE st_num = (%s)''', (st_num, )).fetchone()
                            check_previously_register = cur.execute('''SELECT state FROM Users_temp WHERE st_num = (%s) AND state = (%s)''', (st_num, 'REGISTERED')).fetchone()
                            if check_previously_register is None:
                                if registered_st_num is None:
                                    bot.reply_to(message, emoji.emojize(":cross_mark: Sorry. Not a Registered Student Number."))
                                else:
                                    passwd = st_num
                                    bot.send_message(message.from_user.id, emoji.emojize(':key: Enter your password:'******'''UPDATE Users_Temp SET st_num = (%s), login_code = (%s), state = (%s) WHERE tel_id = (%s)''',
                                                (st_num, passwd, 'LOGIN', message.from_user.id))
                            else:
                                bot.reply_to(message, emoji.emojize(":cross_mark: This Student Number is already registered."))

                    except Exception as e:
                        bot.reply_to(message, emoji.emojize(":cross_mark: Invalid Student Number"))
                        print(e)

                ####################################
                ####            LOGIN           ####
                ####################################
                elif state == 'LOGIN':

                    if emoji.demojize(message.text) == ':bust_in_silhouette: Change Student Number':
                        bot.send_message(message.from_user.id,
                                         emoji.emojize(":e-mail: Enter the *New Student Number* to register."),
                                         parse_mode='Markdown')
                        cur.execute('''UPDATE Users_TEMP SET state = (%s) WHERE tel_id = (%s)''',
                                    ('START', message.from_user.id,))
                    else:
                        digit = cur.execute('''SELECT login_code FROM Users_TEMP WHERE tel_id = (%s)''',
                                        (message.from_user.id,)).fetchone()[0]

                        try:
                            if int(message.text) == digit:

                                st_num = cur.execute('''SELECT st_num FROM Users_Temp WHERE tel_id = (%s)''', (message.from_user.id, )).fetchone()[0]
                                cur.execute("UPDATE Users SET tel_id=(%s), first_name=(%s), last_name=(%s), "
                                                             "username=(%s), login_date=(%s), state=(%s), point=(%s) WHERE st_num = (%s)",
                                            (message.from_user.id,
                                             message.from_user.first_name,
                                             message.from_user.last_name,
                                             message.from_user.username,
                                             message.date,
                                             'IDLE',
                                             0,
                                             st_num))

                                cur.execute('''UPDATE Users_Temp SET state = (%s) WHERE tel_id = (%s)''', ('REGISTERED', message.from_user.id))

                                Questions_N = cur.execute('''SELECT count(Questions.id) FROM Questions''').fetchone()[0]
                                Answers_N = cur.execute('''SELECT count(Answers.id) FROM Answers''').fetchone()[0]
                                Users_N = cur.execute('''SELECT count(Users.tel_id) FROM Users''').fetchone()[0]

                                bot.send_message(message.from_user.id, emoji.emojize(":desktop_computer: *Stackoverflow* Bot"),
                                                 parse_mode="Markdown", reply_markup=main_reply_keyboard)

                                bot.send_message(message.chat.id,emoji.emojize(':white_heavy_check_mark: Successfully registered!' +
                                                               '\n:white_heavy_check_mark: Access granted.'
                                                               '\n\n:bust_in_silhouette: Total Users: *' + str(Users_N) +
                                                                '*\n:question_mark: Total Questions: *' + str(Questions_N) + '*'
                                                                '\n:bright_button: Total Answers: *' + str(Answers_N) + '*'),
                                                 reply_markup=send_question_inline, parse_mode='Markdown')

                            else:
                                bot.send_message(message.from_user.id, emoji.emojize(':cross_mark: Wrong login code. Try again!'))
                        except Exception as e:
                            bot.send_message(message.chat.id, emoji.emojize(':cross_mark: Wrong login code. Try again!'))
                            print(e)

    except Exception as e:
        print('Something went wrong in chat(message) function (Main User): ', e)
        tb = traceback.format_exc()
        print(tb)

        try:
            bot.send_message(73106435, tb)
            username_error = cur.execute('''SELECT username FROM Users WHERE tel_id = (%s)''', (message.from_user.id, )).fetchone()[0]
            bot.send_message(73106435, 'Something went wrong for User: {0}'.format(username_error))
        except Exception as e:
            print(e)

    conn.commit()