def uhn_create_sessions(subject_id, bundle):
'''
Generate 7 sessions and specify start dates (spaced one month apart).
'''
today = datetime.datetime.now().date()
subject = Subject.objects.get(user_id=subject_id)
if bundle.name_id == 'uhn_web':
session_type = Session_Type.objects.get(name='website')
elif bundle.name_id == 'uhn_phone':
session_type = Session_Type.objects.get(name='phone')
# Call generate_session in views.py 7 times
for _ in range(UHN_NUM_SESSIONS):
generate_session(subject, session_type)
start_dates = [today] * UHN_NUM_SESSIONS
for idx in range(UHN_NUM_SESSIONS):
if idx == 0:
continue
start_dates[idx] = start_dates[idx-1] + DURATION_BETWEEN_SESSIONS
sessions = Session.objects.filter(subject_id=subject_id)
for idx, session in enumerate(sessions):
session_id = session.session_id
Session.objects.filter(session_id=session_id).update(start_date=start_dates[idx])
def bundle_create_sessions(subject_id, bundle):
'''
Generate 7 sessions and specify start dates (spaced one month apart).
'''
today = datetime.datetime.now().date()
subject = Subject.objects.get(user_id=subject_id)
session_type = BUNDLE_TO_SESSION_TYPE[bundle.name_id]
total_num_sessions = BUNDLE_TO_NUM_SESSIONS[bundle.name_id]
for _ in range(total_num_sessions):
if 'wch' in bundle.name_id:
generate_session_wch(subject, session_type)
else:
generate_session(subject, session_type)
start_dates = [today] * total_num_sessions
for idx in range(total_num_sessions):
if idx == 0:
continue
start_dates[idx] = start_dates[idx-1] + DURATION_BETWEEN_SESSIONS
sessions = Session.objects.filter(subject_id=subject_id)
for idx, session in enumerate(sessions):
session_id = session.session_id
Session.objects.filter(session_id=session_id).update(start_date=start_dates[idx])
def test_generate_session_uhn_multiple_sessions(self):
'''
test_generate_session_uhn_multiple_sessions should populate the session with
different task instances if specified.
'''
first_session = views.generate_session(self.subject_uhn_bundle,
self.session_type_web)
first_session_task_no_repeat = Session_Task.objects.get(
session_id=first_session.session_id,
task_id=self.task_repeat.task_id)
first_session_task_no_repeat_instance = Session_Task_Instance.objects.get(
session_task_id=first_session_task_no_repeat.session_task_id)
first_session_task_no_repeat_value = Session_Task_Instance_Value.objects.get(
session_task_instance_id=first_session_task_no_repeat_instance.
session_task_instance_id)
first_session_task_repeat = Session_Task.objects.get(
session_id=first_session.session_id,
task_id=self.task_repeat.task_id)
first_session_task_repeat_instance = Session_Task_Instance.objects.get(
session_task_id=first_session_task_repeat.session_task_id)
first_session_task_repeat_value = Session_Task_Instance_Value.objects.get(
session_task_instance_id=first_session_task_repeat_instance.
session_task_instance_id)
second_session = views.generate_session(self.subject_uhn_bundle,
self.session_type_web)
second_session_task_no_repeat = Session_Task.objects.get(
session_id=second_session.session_id,
task_id=self.task_no_repeat.task_id)
second_session_task_no_repeat_instance = Session_Task_Instance.objects.get(
session_task_id=second_session_task_no_repeat.session_task_id)
second_session_task_no_repeat_value = Session_Task_Instance_Value.objects.get(
session_task_instance_id=second_session_task_no_repeat_instance.
session_task_instance_id)
second_session_task_repeat = Session_Task.objects.get(
session_id=second_session.session_id,
task_id=self.task_repeat.task_id)
second_session_task_repeat_instance = Session_Task_Instance.objects.get(
session_task_id=second_session_task_repeat.session_task_id)
second_session_task_repeat_value = Session_Task_Instance_Value.objects.get(
session_task_instance_id=second_session_task_repeat_instance.
session_task_instance_id)
self.assertEqual(first_session_task_repeat_value.value,
second_session_task_repeat_value.value)
self.assertNotEqual(first_session_task_no_repeat_value.value,
second_session_task_no_repeat_value.value)
def session(request):
# Validate the headers
auth_token = lib.validate_authorization_header(request.META)
if not auth_token:
response = HttpResponse(status=400, \
content=json.dumps({"status_code": "400"}))
response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
return response
# Validate the access token
subject = lib.authenticate(auth_token)
if not subject:
response = HttpResponse(status=401, \
content=json.dumps({"status_code": "401"}))
response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
return response
if request.method == 'GET':
# Return all phone sessions for the authenticated user
sessions = Session.objects.filter(subject=subject,
session_type__name='phone')
list_sessions = []
date_format = "%Y-%m-%d %H:%M:%S"
for session in sessions:
str_startdate = session.start_date.strftime(date_format)
str_enddate = session.end_date
if str_enddate is not None:
str_enddate = str_enddate.strftime(date_format)
list_sessions += [{"session_id": session.session_id, \
"start_date": str_startdate, \
"end_date": str_enddate, \
"session_type": session.session_type.name}]
return HttpResponse(status=200,
content=json.dumps({
"status_code": "200",
"sessions": list_sessions
}))
elif request.method == 'POST':
# Create a new session for the user
session_type = Session_Type.objects.get(name='phone')
new_session = generate_session(subject, session_type)
return HttpResponse(status=200,
content=json.dumps({
"status_code":
"200",
"session_id":
new_session.session_id
}))
return HttpResponse(status=405,
content=json.dumps({
"status_code": "405",
"error": "Invalid method"
}))
def test_generate_session_uhn(self):
'''
test_generate_session_uhn should only return tasks in UHN bundle and respect
their defined order
'''
uhn_session = views.generate_session(self.subject_uhn_bundle,
self.session_type_web)
session_tasks = Session_Task.objects.filter(
session=uhn_session).order_by('order')
self.assertEquals(session_tasks[0].task_id, self.bundle_task.task_id)
self.assertEquals(session_tasks[1].task_id, self.task_repeat.task_id)
def test_delete_session(self):
'''
test_delete_session should remove all session tasks
'''
session = views.generate_session(self.subject_uhn_bundle,
self.session_type_web)
self.assertEqual(
len(Session_Task.objects.filter(session_id=session.session_id)), 2)
views.delete_session(session.session_id)
self.assertEqual(
len(Session_Task.objects.filter(session_id=session.session_id)), 0)
self.assertEqual(
len(Session.objects.filter(session_id=session.session_id)), 0)
def test_generate_session_vocabulary_task(self):
'''
test_generate_session_vocabulary_task should generate task instances with
3 words of low difficulty, 2 words of medium difficulty, and 1 word of high difficulty
'''
num_instances_vocabulary = 6
num_instances_vocabulary_low = 3
num_instances_vocabulary_medium = 2
num_instances_vocabulary_high = 1
# Get difficulties
low_difficulty = Value_Difficulty.objects.get(value_difficulty_id=1)
medium_difficulty = Value_Difficulty.objects.get(value_difficulty_id=2)
high_difficulty = Value_Difficulty.objects.get(value_difficulty_id=3)
# Create vocabulary task
vocabulary_task = Task.objects.create(task_id=views.VOCABULARY_TASK_ID,
name_id='vocabulary',
name='vocabulary',
instruction='instruction',
default_order=1,
is_order_fixed=1,
default_delay=0,
default_embedded_delay=0,
is_active=1)
bundle_task_vocabulary = Bundle_Task.objects.create(
bundle_task_id=views.VOCABULARY_UHN_WEB_BUNDLE_TASK_ID,
bundle_id=self.uhn_web_bundle.bundle_id,
task_id=vocabulary_task.task_id,
default_num_instances=num_instances_vocabulary)
# Create task field for vocabulary task
task_field_vocabulary = Task_Field.objects.create(
task_field_id=10,
name='',
task_id=vocabulary_task.task_id,
field_type_id=self.field_type.field_type_id,
field_data_type_id=self.field_data_type.field_data_type_id,
embedded_response=0,
generate_value=1)
# Insert some values for vocabulary task instance
for difficulty in [low_difficulty, medium_difficulty, high_difficulty]:
for i in range(3):
Task_Field_Value.objects.create(
task_field_value_id=difficulty.value_difficulty_id * 100 +
i,
task_field_id=task_field_vocabulary.task_field_id,
value='word',
difficulty_id=difficulty.value_difficulty_id)
Bundle_Task_Field_Value.objects.create(
bundle_task_field_value_id=difficulty.value_difficulty_id *
100 + i,
bundle_task_id=bundle_task_vocabulary.bundle_task_id,
task_field_value_id=difficulty.value_difficulty_id * 100 +
i)
# Create session
vocabulary_session = views.generate_session(self.subject_uhn_bundle,
self.session_type_web)
vocabulary_session_tasks = Session_Task.objects.get(
session_id=vocabulary_session.session_id,
task_id=vocabulary_task.task_id)
vocabulary_session_task_instance_ids = Session_Task_Instance.objects.filter(
session_task_id=vocabulary_session_tasks.session_task_id)
vocabulary_session_task_instances_low = Session_Task_Instance_Value.objects.filter(
session_task_instance_id__in=vocabulary_session_task_instance_ids,
difficulty_id=low_difficulty.value_difficulty_id)
vocabulary_session_task_instances_medium = Session_Task_Instance_Value.objects.filter(
session_task_instance_id__in=vocabulary_session_task_instance_ids,
difficulty_id=medium_difficulty.value_difficulty_id)
vocabulary_session_task_instances_high = Session_Task_Instance_Value.objects.filter(
session_task_instance_id__in=vocabulary_session_task_instance_ids,
difficulty_id=high_difficulty.value_difficulty_id)
self.assertEquals(len(vocabulary_session_task_instances_low),
num_instances_vocabulary_low)
self.assertEquals(len(vocabulary_session_task_instances_medium),
num_instances_vocabulary_medium)
self.assertEquals(len(vocabulary_session_task_instances_high),
num_instances_vocabulary_high)