def add_resource():
form = AddResourceForm(request.form)
if form.validate():
get_db().resources.insert_one(form.data)
return "", 200
else:
return abort(400)
def test_delete_survey_fail2(self, client):
survey_count = get_db().surveys.count()
sid = objectId_str(ex.survey2["_id"])
path = "/surveys/{sid}".format(sid=sid)
res = client.delete(path)
self.assertEqual(survey_count, get_db().surveys.count())
assert_redirect_page(self, res)
def _write_deque(d):
# upsert = update or insert if not there.
get_db().qotd_meta.update_one({}, {"$set": {
"hd": d[0]["_id"]
}},
upsert=True)
for q in d:
get_db().questions.update_one({"_id": q["_id"]}, {"$set": q})
def test_delete_survey_fail1(self, client):
survey_count = get_db().surveys.count()
sid = objectId_str(ex.survey2["_id"])
path = "/surveys/{sid}".format(sid=sid)
res = client.delete(path)
self.assertEqual(res.status_code, 403)
self.assertEqual(get_db().surveys.count(), survey_count)
def test_delete_survey_question_fail1(self, client):
question_count = get_db().survey_questions.count()
qid = objectId_str(ex.survey_question5["_id"])
path = "/surveys/questions/{qid}".format(qid=qid)
res = client.delete(path)
self.assertEqual(get_db().survey_questions.count(), question_count)
self.assertEqual(res.status_code, 403)
def test_delete_survey_question_fail2(self, client):
question_count = get_db().survey_questions.count()
qid = objectId_str(ex.survey_question5["_id"])
path = "/surveys/questions/{qid}".format(qid=qid)
res = client.delete(path)
self.assertEqual(get_db().survey_questions.count(), question_count)
assert_redirect_page(self, res)
def test_answer1(self):
self.assertTrue(answer_question_list(ex.nq1["_id"], "c"))
q = get_db().questions.find_one({"_id": ex.nq1["_id"]})
self.assertEqual(ex.nq1["history"]["c"] + 1, q["history"]["c"])
self.assertEqual(ex.nq1["response_count"] + 1, q["response_count"])
q = get_db().questions.find_one({"_id": ex.nq2["_id"]})
self.assertEqual(ex.nq2["history"]["c"], q["history"]["c"])
self.assertEqual(ex.nq2["response_count"], q["response_count"])
def test_answer3(self):
self.assertFalse(answer_question_list(ObjectId(), "d"))
q = get_db().questions.find_one({"_id": ex.nq1["_id"]})
self.assertEqual(ex.nq1["history"]["c"], q["history"]["c"])
self.assertEqual(ex.nq1["response_count"], q["response_count"])
q = get_db().questions.find_one({"_id": ex.nq2["_id"]})
self.assertEqual(ex.nq2["history"]["c"], q["history"]["c"])
self.assertEqual(ex.nq2["response_count"], q["response_count"])
def test_delete_survey_success2(self, client):
survey_count = get_db().surveys.count()
sid = objectId_str(ex.survey3["_id"])
path = "/surveys/{sid}".format(sid=sid)
res = client.delete(path)
self.assertEqual(get_db().surveys.count(), survey_count - 1)
self.assertEqual(0, get_db().responses.find({"survey_id": sid}).count())
assert_404_page(self, client.get(path))
def delete_survey(sid):
try:
removed_survey = get_db().surveys.remove({"_id": ObjectId(sid)})
if removed_survey is None:
abort(400, "Invalid survey id: {sid}".format(sid=sid))
else:
get_db().responses.remove({"survey_id": str(sid)})
return "Success!" #response is ignored in case of success anyway
except Exception as e:
abort(400, str(e))
def do_something_to_resource(should_activate):
id = request.args.get("id", None)
doc = check_resource_id(id)
if doc is None:
return abort(404)
get_db().resources.update_one({"_id": doc["_id"]},
{"$set": {"active": should_activate}})
return "", 200
def get_survey_questions():
if request.args.get("ajax") is not None:
if json.loads(request.args.get("ajax")):
return json.dumps(
(CreateSurveyForm.get_survey_questions(get_db())))
else:
abort(400, "What are you trying to do?")
else:
questions = [(q["_id"], q["question"])
for q in get_db().survey_questions.find()]
return render_template("/surveys/survey_question_list.html",
questions=questions)
def test_answer_question_endpoint(self, client):
res = client.get('/questions/answer',
data={
"qid": ex.nq1["_id"],
"answer": "c"
})
self.assertEqual(200, res.status_code)
q = get_db().questions.find_one({"_id": ex.nq1["_id"]})
self.assertEqual(ex.nq1["history"]["c"] + 1, q["history"]["c"])
self.assertEqual(ex.nq1["response_count"] + 1, q["response_count"])
q = get_db().questions.find_one({"_id": ex.nq2["_id"]})
self.assertEqual(ex.nq2["history"]["c"], q["history"]["c"])
self.assertEqual(ex.nq2["response_count"], q["response_count"])
def answer_question_list(qid, answer):
qid = get_obj_id(qid)
question = get_question_by_id(qid)
if question is None:
return False
if answer not in question["history"]:
return False
question["history"][answer] += 1
question["response_count"] += 1
get_db().questions.update_one({"_id": qid}, {"$set": question})
return True
def create_survey():
form = CreateSurveyForm(get_db())
if request.method == "GET":
return render_template("surveys/create_survey.html")
else:
form.set_name(request)
form.set_questions(request)
validated, reason = form.validate()
if validated:
sid = store_survey(form, get_db())
return redirect("/surveys/{sid}".format(sid=sid))
else:
abort(400, reason)
def test_add1(self, client):
f = make_add_form_data()
res = client.post('/resources/add', data=f)
self.assertEqual(200, res.status_code)
doc = get_db().resources.find_one({"link": f["link"]})
del doc["_id"]
self.assertEqual(f, doc)
def test_deactivate_staff(self, client):
self.assertTrue(ex.staff1["active"])
res = post_edit_staff(client, ex.staff1["_id"], {"edit_active": False})
self.assertEqual(200, res.status_code)
staff_page = client.get('/page/staff.html')
self.assertFalse(ex.staff1["name"] in staff_page.data)
editted = get_db().staff.find_one({"_id": ex.staff1["_id"]})
self.assertFalse(editted["active"])
def complete_survey(sid):
db = get_db()
form = SubmitResponseForm(sid, db)
if request.method == "GET":
return render_template("surveys/survey.html", survey=form.survey)
else:
form.set_timestamp()
form.set_ans_ids(request)
validated, error_msg = form.validate()
if validated:
store_response(form, get_db())
return render_template("surveys/thank_you.html")
else:
abort(400, error_msg)
def test_enable_question_endpoint(self, client):
new_id = get_db().questions.insert_one({"stuff": True}).inserted_id
res = client.post('/questions/enable',
data={
"qid": str(new_id),
"idx": 0
})
self.assertEqual(200, res.status_code)
self.assertEqual(new_id, get_question_by_idx(0)["_id"])
def delete_survey_question(qid):
surveys = get_db().surveys.find()
for survey in surveys:
for question in survey["qids"]:
if qid == question:
abort(
400,
"This question currently exists on a survey. Delete all surveys that reference this question to delete it"
)
try:
removed = get_db().survey_questions.remove({"_id": ObjectId(qid)})
if removed is None:
abort(400, "Invalid question id: {qid}".format(qid=qid))
else:
return "Success!" #response is ignored in case of success anyway
except Exception as e:
abort(400, str(e))
def get_survey_question(qid):
try:
question = get_db().survey_questions.find_one({"_id": ObjectId(qid)})
except:
abort(404)
if question is None:
abort(404)
else:
return render_template("/surveys/survey_question.html",
question=question)
def test_add4(self, client):
f = make_add_form_data()
l = ["link", "name", "category", "rtype"]
ll = len(l)
for idx, x in enumerate(l):
fnew = dict(f)
del fnew[x]
res = client.post('/resources/add', data=fnew)
self.assertEqual(400, res.status_code)
key = l[(idx + 1) % ll]
doc = get_db().resources.find_one({key: f[key]})
self.assertIsNone(doc)
def test_edit_staff(self, client):
res = post_edit_staff(client, ex.staff1["_id"], {
"edit_name": "Dummy",
"edit_title": "Dummy Title",
"edit_active": "y"
})
self.assertEqual(200, res.status_code)
staff_page = client.get('/page/staff.html')
editted = get_db().staff.find_one({"_id": ex.staff1["_id"]})
self.assertEqual(editted["name"], "Dummy")
self.assertEqual(editted["title"], "Dummy Title")
self.assertTrue("Dummy" in staff_page.data)
def _log_question():
today = datetime_today()
yesterday = today - timedelta(days=1)
# This check has to do with the possibility of delayed running of the
# transition job.
# Really all we need is to put the next question in.
if get_db().qotd_meta.find_one({"qlog.day": yesterday}) is not None:
# Current question actually belongs to yesterday
q_time = yesterday
else:
# Current question actually belongs to today
q_time = today
get_db().qotd_meta.update_one(
{},
{"qlog": {
"$push": {
"day": q_time,
"qid": get_question_by_idx(0)
}
}})
def create_question():
if request.method == "GET":
form = CreateQuestionForm()
return render_template("surveys/create_survey_question.html",
form=form)
else:
form = CreateQuestionForm(request.form)
validated, reason = form.validate()
if validated:
qid = store_question(form, get_db())
return redirect("/surveys/questions/{qid}".format(qid=qid))
else:
abort(400, reason)
def test_add_question_endpoint(self, client):
data = json.dumps({
"question": "What is the answer?",
"choices": {
"a": "This one",
"b": "This one",
"c": "This one"
},
"answer": "c"
})
res = client.post('/questions/add',
data=data,
content_type='application/json')
self.assertEqual(200, res.status_code)
x = get_db().questions.find_one({"question": "What is the answer?"})
self.assertTrue("history" in x)
def retrieve_response_data(sid):
ret_val = {"sid": sid, "questions": []}
db = get_db()
survey = db.surveys.find_one({"_id": ObjectId(sid)})
if survey is None:
abort(404)
ret_val["name"] = survey["name"]
questions = [
db.survey_questions.find_one({"_id": ObjectId(str(qid))})
for qid in survey["qids"]
]
#[[0, 1, 2, 3], [2, 1, 0 2]...]
#[[0, 1], [3, 2]...]
responses = [
r["ans_ids"]
for r in db.responses.find({"survey_id": str(survey["_id"])})
]
ret_val["num_responses"] = len(responses)
for q_idx, question in enumerate(questions):
new_q = dict(question=question["question"], q_idx=q_idx, answers={})
for ans_idx, ans in enumerate(question["answers"]):
chosen_count = 0
for ans_arr in responses:
if ans_arr[
q_idx] == ans_idx: #if they answered the question with this option
chosen_count += 1
new_q["answers"][ans["answer"]] = chosen_count
ret_val["questions"].append(new_q)
return ret_val
def add_question():
d = request.get_json()
if "question" not in d or \
"choices" not in d or \
"answer" not in d:
return abort(400)
question_text = d["question"]
choices = d["choices"]
answer = d["answer"]
history = {}
for key in choices:
history[key] = 0
response_count = 0
return str(get_db().questions.insert_one({
"question": question_text,
"choices": choices,
"answer": answer,
"history": history,
"response_count": 0,
"next": None,
"prev": None
}).inserted_id)
def update_password_for(uid, new_pass):
get_db().users.update_one({"_id": uid}, {"$set": {"password": gen_hash(new_pass)}})
def use_time_for_user(uid, date):
get_db().reset_times.insert_one({"user": uid, "time": date})
