def edit_question(short_name):
(project, owner, n_tasks, n_task_runs, overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
pro = pro_features()
project_button = add_custom_contrib_button_to(project, get_user_id_or_ip())
feature_handler = ProFeatureHandler(current_app.config.get('PRO_FEATURES'))
autoimporter_enabled = feature_handler.autoimporter_enabled_for(
current_user)
project_sanitized, owner_sanitized = sanitize_project_owner(
project_button, owner, current_user)
print project_button["contrib_button"]
if (project_button["contrib_button"] == "draft"):
if ("questionSet" not in project.info.keys()):
project.info.update({
"questionSet": {
"images": [],
"videos": [],
"audios": [],
"documents": []
}
})
project_repo.update(project)
session["edit_question"] = {
"images": [],
"documents": [],
"videos": [],
"audios": []
}
return redirect_content_type(
url_for('.images_edit', short_name=short_name))
else:
return ("Sorry, You Edit the questions for draft project only.",
"alert")
def images(short_name):
(project, owner, n_tasks, n_task_runs,
overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
pro=pro_features()
project_button = add_custom_contrib_button_to(project, get_user_id_or_ip())
feature_handler = ProFeatureHandler(current_app.config.get('PRO_FEATURES'))
autoimporter_enabled = feature_handler.autoimporter_enabled_for(current_user)
project_sanitized, owner_sanitized = sanitize_project_owner(project_button, owner, current_user)
if(session.get("question") is None):
return redirect_content_type(url_for('.success',short_name=short_name))
if request.method == 'POST':
type_q="normal"
answer=[]
if(request.form.get('question','')==""):
flash("Atleast 1 question is required","warning")
return render_template('images.html',project=project_sanitized,
pro_features=pro)
if(request.form.get('checkbox','')!=""):
if(request.form.getlist('answer')[0]=="" or request.form.getlist('answer')[1]==""):
flash("Atleast 2 answers are required","warning")
return render_template('images.html',project=project_sanitized,
pro_features=pro)
else:
type_q="mcqs"
answer=request.form.getlist('answer')
dictobj={"questionString":request.form.get('question'),"answers":answer,"type":type_q}
session["question"]["images"].append(dictobj)
if(request.form.get('submit','')=="submit"):
p=draft_project(project)
if(p!="-1"):
return redirect_content_type(url_for('.'+p.lower(),short_name=short_name))
else:
return redirect_content_type(url_for('.success',short_name=short_name))
return render_template('images.html',project=project_sanitized,pro_features=pro) #we are going to tags.html
def create_quiz(short_name):
(project, owner, n_tasks, n_task_runs, overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
project_id = project.id
project_button = add_custom_contrib_button_to(project, get_user_id_or_ip())
feature_handler = ProFeatureHandler(current_app.config.get('PRO_FEATURES'))
autoimporter_enabled = feature_handler.autoimporter_enabled_for(
current_user)
project_sanitized, owner_sanitized = sanitize_project_owner(
project_button, owner, current_user)
form = Add_quiz()
if request.method == "POST" and form.validate():
quiz_name = form.name.data
q = quiz(name=quiz_name, project_id=project_id)
db.session.add(q)
db.session.commit()
project.info.update({"is_quiz_provided": True})
project_repo.update(project)
session['quiz_name'] = quiz_name
session['quiz_id'] = models.quiz.query.filter_by(
name=quiz_name, project_id=project_id).first().quiz_id
flash("Sucessfully created quiz", "success")
return redirect(url_for('quiz.quiz_form', short_name=short_name))
return render_template("add_quiz.html",
title="create quiz",
form=form,
project=project_sanitized,
pro_features=pro_features())
def edit_question(short_name):
(project, owner, n_tasks, n_task_runs,
overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
pro=pro_features()
project_button = add_custom_contrib_button_to(project, get_user_id_or_ip())
feature_handler = ProFeatureHandler(current_app.config.get('PRO_FEATURES'))
autoimporter_enabled = feature_handler.autoimporter_enabled_for(current_user)
project_sanitized, owner_sanitized = sanitize_project_owner(project_button, owner, current_user)
print project_button["contrib_button"]
if "importer_type" in project.info.keys():
if(project.info["importer_type"]=="frg"):
if(project_button["contrib_button"]=="draft"):
if("questionSet" in project.info.keys()):
session["edit_question_list"]=[]
session["edit_question"]={"images":[],"documents":[],"videos":[],"audios":[]}
for i in ["images","documents","videos","audios"]:
if(len(project.info["questionSet"][i])>0):
session["edit_question_list"].append(i)
p=edit_draft_question(project)
print "see"+p
if(p!="-1"):
return redirect_content_type(url_for('.'+p+"_edit",short_name=short_name))
else:
return "-1"
#return render_template('select_type.html',project=project_sanitized,pro_features=pro)
else:
return ("Sorry, You Edit the questions for draft project only.","alert")
return "Sorry , You did not imported questions from Fundamenta Research"
def edit_success(short_name):
(project, owner, n_tasks, n_task_runs,
overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
pro=pro_features()
project_button = add_custom_contrib_button_to(project, get_user_id_or_ip())
feature_handler = ProFeatureHandler(current_app.config.get('PRO_FEATURES'))
autoimporter_enabled = feature_handler.autoimporter_enabled_for(current_user)
project_sanitized, owner_sanitized = sanitize_project_owner(project_button, owner, current_user)
return render_template('edit_success.html',project=project_sanitized,
pro_features=pro) #we are going to tags.html
def import_healthsites_tasks(short_name):
project, owner, ps = project_by_shortname(short_name)
ensure_authorized_to('read', project)
ensure_authorized_to('update', project)
title = project_title(project, "Import Tasks")
loading_text = gettext("Importing tasks, this may take a while, wait...")
pro = pro_features()
dict_project = add_custom_contrib_button_to(project,
get_user_id_or_ip(),
ps=ps)
project_sanitized, owner_sanitized = sanitize_project_owner(
dict_project, owner, current_user, ps)
template_args = dict(
title=title,
loading_text=loading_text,
project=project_sanitized,
owner=owner_sanitized,
n_tasks=ps.n_tasks,
overall_progress=ps.overall_progress,
n_volunteers=ps.n_volunteers,
n_completed_tasks=ps.n_completed_tasks,
target='healthsites_importer.import_healthsites_tasks',
pro_features=pro)
importer_type = "healthsites"
all_importers = importer.get_all_importer_names()
if importer_type is not None and importer_type not in all_importers:
return abort(404)
form = BulkTaskHealthsitesImportForm(request.body)
template_args['form'] = form
if request.method == 'POST':
if form.validate(): # pragma: no cover
try:
return _import_tasks(project, **form.get_import_data())
except BulkImportException as err_msg:
raise
flash(err_msg, 'error')
except Exception as inst: # pragma: no cover
raise
current_app.logger.error(inst)
msg = 'Oops! Looks like there was an error!'
flash(gettext(msg), 'error')
template_args[
'template'] = '/projects/importers/%s.html' % importer_type
return handle_content_type(template_args)
if request.method == 'GET':
template_args[
'template'] = '/projects/importers/%s.html' % importer_type
return handle_content_type(template_args)
def quiz_form(short_name):
(project, owner, n_tasks, n_task_runs, overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
form = Create_quiz() # Fetch appropriate form from forms.py
if request.method == "POST" and form.validate():
#collecting data from forms.py
que = form.question_text.data #collect the entered question text
_file = request.files['file_field']
if _file and allowed_file(_file.filename):
parent_path = current_app.root_path[:current_app.root_path.
rfind("/")]
_file.save(
os.path.join((parent_path + '/uploads/' + CONTAINER),
_file.filename))
file_path = '/uploads/' + CONTAINER + '/' + _file.filename
option_A = form.oA.data #collect entered option A text
option_B = form.oB.data #collect entered option B text
option_C = form.oC.data #collect entered option C text
option_D = form.oD.data #collect entered option D text
correct_answer = form.correct_answer.data #collect entered correct answer
# Based on entered answer, store the option text in the answer field in the database
if correct_answer == 'A':
correct_answer = option_A
elif correct_answer == 'B':
correct_answer = option_B
elif correct_answer == 'C':
correct_answer = option_C
elif correct_answer == 'D':
correct_answer = option_D
category = form.category.data #collect entered question category
q = question(quiz_id=session['quiz_id'],
q_text=que,
file_path=file_path,
option1=option_A,
option2=option_B,
option3=option_C,
option4=option_D,
answer=correct_answer,
category=category
) # Create object of class question from questions.py
db.session.add(q) # Add object q to db.session
db.session.commit() # Commit changes to app.db
if request.form['submit'] == 'ADD':
return redirect(url_for('quiz.quiz_form', short_name=short_name))
elif request.form['submit'] == 'SUBMIT':
return redirect(url_for('quiz.display_quiz',
short_name=short_name))
return render_template("create_quiz.html",
title="Add Question",
quiz_name=session['quiz_name'],
form=form,
project=project,
pro_features=pro_features()) # Render form template
def audios_edit(short_name):
(project, owner, n_tasks, n_task_runs,
overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
pro=pro_features()
project_button = add_custom_contrib_button_to(project, get_user_id_or_ip())
feature_handler = ProFeatureHandler(current_app.config.get('PRO_FEATURES'))
autoimporter_enabled = feature_handler.autoimporter_enabled_for(current_user)
project_sanitized, owner_sanitized = sanitize_project_owner(project_button, owner, current_user)
if request.method == 'POST':
session_count=len(session["edit_question"]["audios"]);
session["edit_question"]["audios"]=[]
for j in range(1,session_count+1):
ans=[]
type_q="normal"
print str(j)+'_question'
if(request.form.get(str(j)+'_question','')!=""):
que=request.form.get(str(j)+'_question')
if(request.form.get(str(j)+'_divcheckbox','')!=""):
type_q="mcqs"
if(request.form.get(str(j)+'_answer','')!=""):
ans=request.form.getlist(str(j)+'_answer')
dictobj={"questionString":request.form.get(str(j)+'_question'),"answers":ans,"type":type_q}
session["edit_question"]["audios"].append(dictobj)
if(request.form.get('submit','')=="submit"):
p=edit_draft_question(project)
project.info["questionSet"]["audios"]=session["edit_question"]["audios"]
project_repo.update(project)
if(p!="-1"):
return redirect_content_type(url_for('.'+p.lower()+"_edit",short_name=short_name))
else:
return redirect_content_type(url_for('.edit_success',short_name=short_name))
else:
type_q="normal"
answer=[]
if(request.form.get('question','')==""):
flash("Question field is Empty","warning")
return render_template('audios_edit.html',project=project_sanitized,
pro_features=pro)
if(request.form.get('checkbox','')!=""):
if(request.form.getlist('answer')[0]=="" or request.form.getlist('answer')[1]==""):
flash("Atleast 2 answers are required","warning")
return render_template('audios_edit.html',project=project_sanitized,
pro_features=pro)
else:
type_q="mcqs"
answer=request.form.getlist('answer')
dictobj={"questionString":request.form.get('question'),"answers":answer,"type":type_q}
session["edit_question"]["audios"].append(dictobj)
return render_template('audios_edit.html',project=project_sanitized,pro_features=pro) #we are going to tags.html
def validation(page=1):
"""Manage validations."""
# response = dict(template='admin/validation.html',
# title=gettext("Manage validations"),
# csrf=generate_csrf())
# return handle_content_type(response)
project, owner, ps = project_by_shortname("frd")
title = project_title(project, "Tasks")
pro = pro_features()
def respond():
per_page = 100
offset = (page - 1) * per_page
count = ps.n_tasks
page_tasks = cached_projects.browse_tasks_validation(project.get('id'),
per_page,
offset,
min_n_answers=3)
pagination = Pagination(page, per_page, count)
project_sanitized, owner_sanitized = sanitize_project_owner(
project, owner, current_user, ps)
data = dict(template='admin/validation.html',
project=project_sanitized,
owner=owner_sanitized,
tasks=page_tasks,
title=title,
pagination=pagination,
n_tasks=ps.n_tasks,
overall_progress=ps.overall_progress,
n_volunteers=ps.n_volunteers,
n_completed_tasks=ps.n_completed_tasks,
pro_features=pro)
return handle_content_type(data)
if project.needs_password():
redirect_to_password = _check_if_redirect_to_password(project)
if redirect_to_password:
return redirect_to_password
else:
ensure_authorized_to('read', project)
zip_enabled(project, current_user)
project = add_custom_contrib_button_to(project, get_user_id_or_ip())
return respond()
def success(short_name):
(project, owner, n_tasks, n_task_runs,
overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
pro=pro_features()
add_task(project)
global previous_data
previous_data=[]
project_button = add_custom_contrib_button_to(project, get_user_id_or_ip())
feature_handler = ProFeatureHandler(current_app.config.get('PRO_FEATURES'))
autoimporter_enabled = feature_handler.autoimporter_enabled_for(current_user)
project_sanitized, owner_sanitized = sanitize_project_owner(project_button, owner, current_user)
flash("Your Tasks Uploded Successfully","success")
#return render_template('success.html',project=project_sanitized,pro_features=pro) #we are going to tags.html
if(not is_quiz_provided(project.id)):
return redirect(url_for('quiz.create_quiz',short_name=short_name))
else:
return redirect(url_for('project.details',short_name=short_name))
def upload_task(short_name):
(project, owner, n_tasks, n_task_runs,
overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
pro=pro_features()
project_button = add_custom_contrib_button_to(project, get_user_id_or_ip())
feature_handler = ProFeatureHandler(current_app.config.get('PRO_FEATURES'))
autoimporter_enabled = feature_handler.autoimporter_enabled_for(current_user)
project_sanitized, owner_sanitized = sanitize_project_owner(project_button, owner, current_user)
if request.method=='POST':
upload_form=TaskUpload()
if upload_form.validate_on_submit():
_file=request.files['avatar']
#extract_files_local(parent_path+"/uploads"+CONTAINER,_file.filename)
if _file and allowed_file(_file.filename):
_file.save(os.path.join((parent_path+'/uploads/'+CONTAINER) , _file.filename))
if(check_file_size(parent_path+'/uploads/'+CONTAINER+"/"+_file.filename)):
global zipobj
zipobj=extract_files_local((parent_path+"/uploads/"+CONTAINER),_file.filename,project.id)
session["zzz"]=zipobj["zzz"]
zipobj.pop("zzz",None)
if "directory_names" not in project.info.keys():
project.info.update({"directory_names":[]})
project.info["directory_names"].append(session["zzz"])
project_repo.update(project)
#add_task(project.id,zipobj["zzz"])
return redirect_content_type(url_for('.select_type',
short_name=short_name))
else:
if os.path.exists(parent_path+'/uploads/'+CONTAINER+"/"+_file.filename):
os.remove(parent_path+'/uploads/'+CONTAINER+"/"+_file.filename)
flash('File Size should be less than 5 MB');
else:
flash(gettext('Please upload the file'),'warning')
upload_form =TaskUpload()
response =dict(template='/upload_form.html',
upload_form=upload_form,
project=project_sanitized,
pro_features=pro
)
return handle_content_type(response)
def create_quiz(short_name):
(project, owner, n_tasks, n_task_runs, overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
project_id = project.id
form = Add_quiz()
if request.method == "POST" and form.validate():
quiz_name = form.name.data
q = quiz(name=quiz_name, project_id=project_id)
db.session.add(q)
db.session.commit()
session['quiz_name'] = quiz_name
session['quiz_id'] = models.quiz.query.filter_by(
name=quiz_name).first().quiz_id
return redirect(url_for('quiz.quiz_form', short_name=short_name))
return render_template("add_quiz.html",
title="create quiz",
form=form,
project=project,
pro_features=pro_features())
def display_result(short_name):
(project, owner, n_tasks, n_task_runs, overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
total = len(
models.response.query.filter_by(quiz_id=session['quiz_id'],
user_id=current_user.id).all())
print total
correct = len(
models.response.query.filter_by(result=True,
quiz_id=session['quiz_id'],
user_id=current_user.id).all())
marks = (correct * 100.0) / total
session['quiz_id'] = -1
return render_template("display_result.html",
title="display result",
marks=marks,
total=total,
correct=correct,
project=project,
pro_features=pro_features())
def display_quiz(short_name):
form = Display_quiz()
(project, owner, n_tasks, n_task_runs, overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
project_id = project.id
if request.method == "POST":
quiz_name = form.name.data
session['quiz_name'] = quiz_name
session['quiz_id'] = models.quiz.query.filter_by(
name=quiz_name).first().quiz_id
return redirect(url_for('quiz.display_question',
short_name=short_name))
q = models.quiz.query.filter_by(project_id=project_id).all()
form.name.choices = []
for quiz in q:
form.name.choices.append((quiz.name, quiz.name))
return render_template("display_quiz.html",
title="Display Quiz",
form=form,
project=project,
pro_features=pro_features())
def select_type(short_name):
(project, owner, n_tasks, n_task_runs,
overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
pro=pro_features()
project_button = add_custom_contrib_button_to(project, get_user_id_or_ip())
feature_handler = ProFeatureHandler(current_app.config.get('PRO_FEATURES'))
autoimporter_enabled = feature_handler.autoimporter_enabled_for(current_user)
project_sanitized, owner_sanitized = sanitize_project_owner(project_button, owner, current_user)
print short_name
global zipobj
li=["Images","Videos",'Audios','Documents'] #classification files
if request.method == 'POST':
global list_container
list_container=request.form.getlist('selecttype') #selected classification list
for i in li:
if i not in list_container:
n=session["zzz"]#this is parent path of the folder which were unchecked by user
if os.path.exists(n+"/"+i.lower()):
shutil.rmtree(n+"/"+i.lower()) #deletion of folder
if(len(list_container)==0):
flash("You must select atleast one file","danger")
return render_template('select_type.html',arr=zipobj,project=project_sanitized,pro_features=pro)
print "Going to function"
global previous_data
p=draft_project(project)
if(len(previous_data)!=0):
l=" , ".join(previous_data)
print l
flash(l+" questions are already uploaded","info")
if(p!="-1"):
return redirect_content_type(url_for('.'+p.lower(),short_name=short_name))
else:
return redirect_content_type(url_for('.success',short_name=short_name))
return render_template('select_type.html',arr=zipobj,project=project_sanitized,
pro_features=pro) #sending the classified information to the select_type.html
def display_question(short_name):
form = Display_question() # Fetch appropriate form to get user response
(project, owner, n_tasks, n_task_runs, overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
if request.method == "POST":
#Collect user submisstion
submission = form.submission.data
if submission == session['correct_answer']:
result = True
else:
result = False
q = response(quiz_id=session['quiz_id'],
user_id=current_user.id,
question_id=session['question_id'],
response=submission,
result=result)
db.session.add(q)
db.session.commit()
# Display Next Question
if session['question_id'] != 0:
session['question_id'] = session['question_id'] + 1
else:
session['question_id'] = 1
q = models.question.query.filter_by(
quiz_id=session['quiz_id'],
question_id=session['question_id']).first()
if q:
form.submission.choices = [(q.option1, q.option1),
(q.option2, q.option2),
(q.option3, q.option3),
(q.option4, q.option4)]
session['question_id'] = q.question_id
session['correct_answer'] = q.answer
return render_template("display_question.html",
q=q,
quiz_name=session['quiz_name'],
form=form,
project=project,
pro_features=pro_features())
else:
#session['quiz_id']=-1;
user = {'nickname': 'Miguel'}
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND user_id = current_user.id AND quiz_id = session['quiz_id'];'''
)
results = db.session.execute(q, dict(category='Image')).fetchall()
image_total = len(results)
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND result = True AND user_id = current_user.id AND quiz_id = session['quiz_id'];'''
)
results_true = db.session.execute(
q, dict(category='Image')).fetchall()
image_correct = len(results_true)
if image_total != 0:
image_score = (image_correct * 100.0) / image_total
else:
image_score = 0
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND user_id = current_user.id AND quiz_id = session['quiz_id'];'''
)
results = db.session.execute(q, dict(category='Video')).fetchall()
video_total = len(results)
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND result = True AND user_id = current_user.id AND quiz_id = session['quiz_id'];'''
)
results_true = db.session.execute(
q, dict(category='Video')).fetchall()
video_correct = len(results_true)
if video_total != 0:
video_score = (image_correct * 100.0) / video_total
else:
video_score = 0
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND user_id = current_user.id AND quiz_id = session['quiz_id'];'''
)
results = db.session.execute(q, dict(category='Audio')).fetchall()
audio_total = len(results)
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND result = True AND user_id = current_user.id AND quiz_id = session['quiz_id'];'''
)
results_true = db.session.execute(
q, dict(category='Audio')).fetchall()
audio_correct = len(results_true)
if audio_total != 0:
audio_score = (audio_correct * 100.0) / audio_total
else:
audio_score = 0
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND user_id = current_user.id AND quiz_id = session['quiz_id'];'''
)
results = db.session.execute(q, dict(category='Pdf')).fetchall()
pdf_total = len(results)
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND result = True AND user_id = current_user.id AND quiz_id = session['quiz_id'];'''
)
results_true = db.session.execute(q,
dict(category='Pdf')).fetchall()
pdf_correct = len(results_true)
if pdf_total != 0:
pdf_score = (pdf_correct * 100.0) / pdf_total
else:
pdf_score = 0
score = user_score(user_id=current_user.id,
image_score=image_score,
video_score=video_score,
audio_score=audio_score,
document_score=pdf_score)
db.session.add(score)
db.session.commit()
return redirect(
url_for('quiz.display_result', short_name=short_name))
else:
q = models.question.query.filter_by(quiz_id=session['quiz_id']).first()
form.submission.choices = [(q.option1, q.option1),
(q.option2, q.option2),
(q.option3, q.option3),
(q.option4, q.option4)]
session['question_id'] = q.question_id
session['correct_answer'] = q.answer
file_type = gettype(q.file_path)
#session['q_no']=1;
return render_template("display_question.html",
q=q,
file_type=file_type,
form=form,
project=project,
pro_features=pro_features())
def quiz_form(short_name):
(project, owner, n_tasks, n_task_runs, overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
form = Create_quiz() # Fetch appropriate form from forms.py
project_button = add_custom_contrib_button_to(project, get_user_id_or_ip())
feature_handler = ProFeatureHandler(current_app.config.get('PRO_FEATURES'))
autoimporter_enabled = feature_handler.autoimporter_enabled_for(
current_user)
project_sanitized, owner_sanitized = sanitize_project_owner(
project_button, owner, current_user)
if request.method == "POST" and form.validate():
#collecting data from forms.py
que = form.question_text.data #collect the entered question text
_file = request.files['file_field']
if _file and allowed_file(_file.filename):
parent_path = current_app.root_path[:current_app.root_path.
rfind("/")]
_file.save(
os.path.join((parent_path + '/uploads/' + CONTAINER),
_file.filename))
file_path = '/uploads/' + CONTAINER + '/' + _file.filename
option_A = form.oA.data #collect entered option A text
option_B = form.oB.data #collect entered option B text
option_C = form.oC.data #collect entered option C text
option_D = form.oD.data #collect entered option D text
correct_answer = form.correct_answer.data #collect entered correct answer
# Based on entered answer, store the option text in the answer field in the database
if correct_answer == 'A':
correct_answer = option_A
elif correct_answer == 'B':
correct_answer = option_B
elif correct_answer == 'C':
correct_answer = option_C
elif correct_answer == 'D':
correct_answer = option_D
category = form.category.data #collect entered question category
q = question(quiz_id=session['quiz_id'],
q_text=que,
file_path=file_path,
option1=option_A,
option2=option_B,
option3=option_C,
option4=option_D,
answer=correct_answer,
category=category
) # Create object of class question from questions.py
db.session.add(q) # Add object q to db.session
db.session.commit() # Commit changes to app.db
if request.form['submit'] == 'ADD':
return redirect(url_for('quiz.quiz_form', short_name=short_name))
elif request.form['submit'] == 'SUBMIT':
flash("Sucessfully added questions to " + session['quiz_name'],
"success")
return redirect(url_for('project.details', short_name=short_name))
return render_template("create_quiz.html",
title="Add Question",
quiz_name=session['quiz_name'],
form=form,
project=project_sanitized,
pro_features=pro_features()) # Render form template
def display_question(short_name):
form = Display_question() # Fetch appropriate form to get user response
(project, owner, n_tasks, n_task_runs, overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
if request.method == "POST":
#Collect user submisstion
submission = form.submission.data
if submission == session['correct_answer']:
result = True
else:
result = False
q = response(quiz_id=session['quiz_id'],
user_id=current_user.id,
question_id=session['question_id'],
response=submission,
result=result)
db.session.add(q)
db.session.commit()
# Display Next Question
if session['question_id'] != 0:
session['question_id'] = session['question_id'] + 1
else:
session['question_id'] = 1
q = models.question.query.filter_by(
quiz_id=session['quiz_id'],
question_id=session['question_id']).first()
if q:
form.submission.choices = [(q.option1, q.option1),
(q.option2, q.option2),
(q.option3, q.option3),
(q.option4, q.option4)]
session['question_id'] = q.question_id
session['correct_answer'] = q.answer
return render_template("display_question.html",
q=q,
quiz_name=session['quiz_name'],
form=form,
project=project,
pro_features=pro_features())
else:
# session['quiz_id']=-1;
user = {'nickname': 'Miguel'}
return redirect(
url_for('quiz.display_result', short_name=short_name))
else:
q = models.question.query.filter_by(quiz_id=session['quiz_id']).first()
form.submission.choices = [(q.option1, q.option1),
(q.option2, q.option2),
(q.option3, q.option3),
(q.option4, q.option4)]
session['question_id'] = q.question_id
session['correct_answer'] = q.answer
file_type = gettype(q.file_path)
#session['q_no']=1;
return render_template("display_question.html",
q=q,
file_type=file_type,
form=form,
project=project,
pro_features=pro_features())
def display_question(short_name):
form = Display_question() # Fetch appropriate form to get user response
(project, owner, n_tasks, n_task_runs, overall_progress, last_activity,
n_results) = project_by_shortname(short_name)
if request.method == "POST":
#Collect user submisstion
submission = form.submission.data
if submission == session['correct_answer']:
result = True
else:
result = False
q = response(quiz_id=session['quiz_id'],
user_id=current_user.id,
question_id=session['question_id'],
response=submission,
result=result)
db.session.add(q)
db.session.commit()
# Display Next Question
if session['question_id'] != 0:
session['question_id'] = session['question_id'] + 1
else:
session['question_id'] = 1
q = models.question.query.filter_by(
quiz_id=session['quiz_id'],
question_id=session['question_id']).first()
if q:
form.submission.choices = [(q.option1, q.option1),
(q.option2, q.option2),
(q.option3, q.option3),
(q.option4, q.option4)]
session['question_id'] = q.question_id
session['correct_answer'] = q.answer
return render_template("display_question.html",
q=q,
quiz_name=session['quiz_name'],
form=form,
project=project_sanitized,
pro_features=pro_features())
else:
#session['quiz_id']=-1;
user = {'nickname': 'Miguel'}
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND user_id = :id AND quiz_id = :q_id;'''
)
results = db.session.execute(
q,
dict(category='Image',
id=current_user.id,
q_id=session['quiz_id'])).fetchall()
image_total = len(results)
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND result = True AND user_id = :id AND quiz_id = :q_id;'''
)
results_true = db.session.execute(
q,
dict(category='Image',
id=current_user.id,
q_id=session['quiz_id'])).fetchall()
image_correct = len(results_true)
if image_total != 0:
image_score = (image_correct * 100.0) / image_total
else:
image_score = 0
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND user_id = :id AND quiz_id = :q_id;'''
)
results = db.session.execute(
q,
dict(category='Video',
id=current_user.id,
q_id=session['quiz_id'])).fetchall()
video_total = len(results)
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND result = True AND user_id = :id AND quiz_id = :q_id;'''
)
results_true = db.session.execute(
q,
dict(category='Video',
id=current_user.id,
q_id=session['quiz_id'])).fetchall()
video_correct = len(results_true)
if video_total != 0:
video_score = (image_correct * 100.0) / video_total
else:
video_score = 0
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND user_id = :id AND quiz_id = :q_id;'''
)
results = db.session.execute(
q,
dict(category='Audio',
id=current_user.id,
q_id=session['quiz_id'])).fetchall()
audio_total = len(results)
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND result = True AND user_id = :id AND quiz_id = :q_id;'''
)
results_true = db.session.execute(
q,
dict(category='Audio',
id=current_user.id,
q_id=session['quiz_id'])).fetchall()
audio_correct = len(results_true)
if audio_total != 0:
audio_score = (audio_correct * 100.0) / audio_total
else:
audio_score = 0
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND user_id = :id AND quiz_id = :q_id;'''
)
results = db.session.execute(
q,
dict(category='Pdf',
id=current_user.id,
q_id=session['quiz_id'])).fetchall()
pdf_total = len(results)
q = text(
'''SELECT * FROM response WHERE question_id IN (SELECT question_id FROM question WHERE category = :category) AND result = True AND user_id = :id AND quiz_id = :q_id;'''
)
results_true = db.session.execute(
q,
dict(category='Pdf',
id=current_user.id,
q_id=session['quiz_id'])).fetchall()
pdf_correct = len(results_true)
if pdf_total != 0:
pdf_score = (pdf_correct * 100.0) / pdf_total
else:
pdf_score = 0
score = user_score(user_id=current_user.id,
project_id=project.id,
image_score=image_score,
video_score=video_score,
audio_score=audio_score,
document_score=pdf_score)
db.session.add(score)
db.session.commit()
###### shruthi
db_session = db.slave_session
user_obj = db_session.query(User).filter_by(
id=current_user.id).first()
if "score" not in user_obj.info.keys():
user_obj.info.update({"score": []})
dictobj = {
"project_id": project.id,
"image_score": image_score,
"video_score": video_score,
"document_score": pdf_score,
"audio_score": audio_score
}
user_obj.info["score"].append(dictobj)
user_repo.update(user_obj)
####### end
flash("Responses recorded Successfully", "success")
return redirect(url_for('project.presenter',
short_name=short_name))
else:
q = models.question.query.filter_by(quiz_id=session['quiz_id']).first()
form.submission.choices = [(q.option1, q.option1),
(q.option2, q.option2),
(q.option3, q.option3),
(q.option4, q.option4)]
session['question_id'] = q.question_id
session['correct_answer'] = q.answer
file_type = gettype(q.file_path)
#session['q_no']=1;
return render_template("display_question.html",
q=q,
file_type=file_type,
form=form,
project=project,
pro_features=pro_features())
