def call(self, chat, author, arguments):
poll = db.get_poll(chat)
if poll is None:
telegram.send(chat, "No active polls")
return
db.add_answer(poll, arguments)
telegram.send(chat, "Answer addded")
def add_answer():
this_year = request.form["this_year"]
season = request.form["season"]
after_today = request.form["after_today"]
prefecture = request.form["prefecture"]
region = request.form["region"]
db.add_answer(this_year, season, after_today, prefecture, region)
return redirect(url_for("voice"))
def record_response(color, text_color):
try:
color = validate_color(color)
if text_color is not None:
text_color = validate_color(text_color)
except ColorError as e:
logging.exception(e)
return
conn = db_conn(app)
db.add_answer(conn, color, text_color)
conn.close()
def answer(message):
try:
global isgamestarted
global players
if message.from_user.id not in players:
bot.send_message(message.chat.id, 'You didn\'t register.\n*/start* please.',
parse_mode='Markdown')
return
if isgamestarted is True:
key, status, response = qna.check(message.text)
if status is not None:
isnotanswered = db.add_answer(message.from_user.id, key, message.date, status, message.text)
if isnotanswered is True:
bot.send_message(message.chat.id, response, parse_mode='Markdown')
elif isnotanswered is False:
bot.send_message(message.chat.id, 'You already answered this question.')
else:
bot.send_message(message.chat.id, response, parse_mode='Markdown')
elif isgamestarted is False:
bot.send_message(message.chat.id, gamestatus)
except Exception as e:
print(e)
bot.send_message(message.chat.id, 'Exception :(')
def assign_interview(self):
# intro message
self.client_socket.send( ('Interview Assignment').encode( ))
#Receives a username from client
User_Search = self.client_socket.recv(1024).decode() # "Enter the username of the interviewee:"
###CHECK DATABASE FOR###
# import sqlite3 first
conn= sqlite3.connect( 'interview.db' )
interview_user = ''
while True:
try:
interview_user = db.retrieve_user_by_name(conn, User_Search)
break
except TypeError:
#if no existing user
self.client_socket.send( ('User does not exist, try again.').encode() )
if interview_user == 'quit':
return
User_Search = self.client_socket.recv(1024).decode()
#interview_user = db.retrieve_user_by_name(conn, User_Search)
self.client_socket.send( ('User exists').encode() )#user_conf
#User_Found = User_Row[0]
#else
#display list of available interviews
conn= sqlite3.connect( 'interview.db' )
interviews = db.retrieve_interview_all(conn)
for interview in interviews:
self.client_socket.send( ('(' + str(interview[0]) + ') ' + interview[1]).encode() )
#Receives a interview from client
self.client_socket.send( ('end').encode() )
interview_id = self.client_socket.recv(1024).decode()
while True:
try:
interview_name = db.retrieve_interview_title(conn, interview_id)
break
except TypeError:
self.client_socket.send( ('Interview does not exist, try again.').encode() )
if interview_name == 'quit':
return
interview_id = self.client_socket.recv(1024).decode()
self.client_socket.send( ('Assigning Interview').encode() ) #interview_conf
###ADD INTERVIEW TO USER'S INBOX###
#db.assign_interview(conn, interview_id, interview_user )
#self.client_socket.send( (interview_name + " has been assigned to " + User_Search + ".").encode() ) #interview_conf
conn= sqlite3.connect( 'interview.db' )
questions = db.retrieve_questions(conn, interview_id)
for question in questions:
db.add_answer(conn, interview_user, question[0], None, interview_id)
print('created answer space for question: ' + str(question[0]))
#self.client_socket.send( ('(' + str(interview[0]) + ') ' + interview[1]).encode() )
self.client_socket.send( (interview_name + " has been assigned to " + User_Search + ".").encode() ) #interview_conf
conn.close()
return
async def add_reaction_on_survey_answer(client, member, survey_id, question_id,
emoji, message):
logging.info(
f"Adding reaction ({emoji}) from user {member_to_string(member)} for survey ({survey_id}) question ({question_id})."
)
if db.is_survey_progress_finished(survey_id, member.id):
logging.info(
f"User {member_to_string(member)} survey ({survey_id}) already finished. Removing reaction from message."
)
await message.remove_reaction(emoji, member)
return
existing_answer_to_question = db.get_answer_of_answered_survey_question_or_none(
question_id, member.id)
if (not db.is_multiple_choice_survey_question(question_id)
and existing_answer_to_question is not None):
logging.info(
f"Removing existing answer from user {member_to_string(member)} for survey ({survey_id}) question ({question_id})."
)
# Remove answer from db
db.remove_user_answer(member.id, question_id,
existing_answer_to_question)
# Remove reaction from answer
emoji_to_delete = db.get_emoji_from_survey_answer(
existing_answer_to_question)
await message.remove_reaction(emoji_to_delete, member)
db.add_answer(member.id, question_id, db.get_answer_id(question_id, emoji))
if db.are_all_survey_questions_answered(member.id, survey_id):
logging.info(
f"User {member_to_string(member)} answered all survey ({survey_id}) questions."
)
await add_receive_role_if_exists(client, member, survey_id)
db.finish_user_survey_progress(survey_id, member.id)
logging.info(
f"User {member_to_string(member)} finished survey ({survey_id}).")
await message.channel.send(SURVEY_FINISHED_MESSAGE)
elif db.is_last_question(survey_id, question_id):
logging.info(
f"Sending unanswered questions to user {member_to_string(member)} on survey ({survey_id})."
)
await message.remove_reaction(emoji, member)
unanswered_questions = db.get_unanswered_question_texts(
survey_id, member.id)
embed_description = "\n".join(
["- " + question for question in unanswered_questions])
embed = discord.Embed(
title=UNANSWERED_QUESTIONS_TEXT,
description=embed_description,
colour=discord.Colour(0xFFFF00),
)
await message.channel.send(embed=embed)
elif existing_answer_to_question is None:
await send_next_question(message.channel, member, survey_id,
question_id)
