def test_validate_application(self):
global_id = self.tutor.person.global_id
application_to_create = _get_application_example(
self.lbir1250_2017, '30', '20')
application_to_create[
'pending'] = tutor_application_epc.UPDATE_OPERATION
tutor_application.create_or_update_application(global_id,
application_to_create)
# Check pending state
application_searched_not_validated = tutor_application.get_application(
global_id, self.lbir1250_2017)
self.assertEqual(application_searched_not_validated['pending'],
tutor_application_epc.UPDATE_OPERATION)
self.assertTrue(application_searched_not_validated['updated_at'])
sleep(1) # Wait 1 sec for testing updated_at field
# Validate
tutor_application.validate_application(
global_id, self.lbir1250_2017.acronym,
self.lbir1250_2017.academic_year.year)
application_searched_validated = tutor_application.get_application(
global_id, self.lbir1250_2017)
self.assertRaises(KeyError,
lambda: application_searched_validated['pending'])
self.assertTrue(application_searched_validated['updated_at'])
self.assertTrue(application_searched_validated['updated_at'] >
application_searched_not_validated['updated_at'])
def test_create_or_update_application_creation_on_new_user(self):
# Create new tutor
new_tutor = TutorFactory(person=PersonFactory(global_id="59898988"))
# Submit tutor application
application_to_create = _get_application_example(self.lbir1250_2017, '30', '20')
global_id = new_tutor.person.global_id
tutor_application.create_or_update_application(global_id, application_to_create)
application_list = tutor_application.get_application_list(global_id, self.academic_year)
self.assertEqual(len(application_list), 1) # We should have 1 application
def test_create_or_update_application_creation_on_existing_user(self):
application_to_create = _get_application_example(self.lbir1250_2017, '30', '20')
global_id = self.tutor.person.global_id
tutor_application.create_or_update_application(global_id, application_to_create)
application_list = tutor_application.get_application_list(global_id, self.academic_year)
self.assertEqual(len(application_list), 3) # We should have 3 applications now
# We should found the newest created
self.assertTrue(next(app for app in application_list if
app.get('acronym') == self.lbir1250_2017.acronym))
def renew_applications(request):
tutor = mdl_base.tutor.find_by_user(request.user)
global_id = tutor.person.global_id
post_data = dict(request.POST.lists())
learning_container_year_acronyms = [param.split("_")[-1] for param, value in post_data.items()\
if "learning_container_year_" in param]
attributions_about_to_expired = attribution.get_attribution_list_about_to_expire(
global_id=global_id)
attribution_to_renew_list = [attrib for attrib in attributions_about_to_expired
if attrib.get('acronym') in learning_container_year_acronyms and \
attrib.get('is_renewable', False)]
if not attribution_to_renew_list:
messages.add_message(request, messages.ERROR,
_('no_attribution_renewed'))
return redirect('applications_overview')
l_containers_years = mdl_base.learning_container_year.search(id=[
attrib.get('attribution_vacant', {}).get('learning_container_year_id')
for attrib in attribution_to_renew_list
])
for attri_to_renew in attribution_to_renew_list:
learning_container_year = next(
(l_containers_year for l_containers_year in l_containers_years
if l_containers_year.acronym == attri_to_renew.get('acronym')),
None)
application_data = {
'charge_lecturing_asked':
attri_to_renew.get(learning_component_year_type.LECTURING),
'charge_practical_asked':
attri_to_renew.get(
learning_component_year_type.PRACTICAL_EXERCISES),
}
form = ApplicationForm(learning_container_year=learning_container_year,
data=application_data)
if form.is_valid():
application = form.cleaned_data
try:
tutor_application.create_or_update_application(
global_id, application)
tutor_application.set_pending_flag(
global_id, application,
tutor_application_epc.UPDATE_OPERATION)
# Send signal to EPC
tutor_application_epc.send_message(
tutor_application_epc.UPDATE_OPERATION, global_id,
application)
except Exception as e:
error_msg = "{}: {}".format(learning_container_year.acronym,
e.args[0])
messages.add_message(request, messages.ERROR, error_msg)
return redirect('applications_overview')
def test_get_application_list_with_none_practical_charge(self):
new_tutor = TutorFactory(person=PersonFactory(global_id="59898988"))
application_to_create = _get_application_example(self.lbir1200_2017, "15", None)
global_id = new_tutor.person.global_id
tutor_application.create_or_update_application(global_id, application_to_create)
application_list = tutor_application.get_application_list(global_id, self.academic_year)
application_created = application_list[0]
self.assertTrue(application_created)
self.assertEqual(application_created.get('acronym'), self.lbir1200_2017.acronym)
self.assertEqual(application_created.get('charge_lecturing_asked'), Decimal(15))
self.assertEqual(application_created.get('charge_practical_asked'), Decimal(0))
def test_create_or_update_application_update(self):
application_to_update = _get_application_example(self.lbir1200_2017, '0', '10')
global_id = self.tutor.person.global_id
tutor_application.create_or_update_application(global_id, application_to_update)
application_list = tutor_application.get_application_list(global_id, self.academic_year)
self.assertEqual(len(application_list), 2) # We should have 2 applications
application_updated = next(app for app in application_list if
app.get('acronym') == self.lbir1200_2017.acronym)
self.assertTrue(application_updated)
self.assertEqual(application_updated.get('acronym'), self.lbir1200_2017.acronym)
self.assertEqual(application_updated.get('charge_lecturing_asked'), Decimal(0))
self.assertEqual(application_updated.get('charge_practical_asked'), Decimal(10))
def create_or_update_application(request, learning_container_year_id):
tutor = mdl_base.tutor.find_by_user(request.user)
global_id = tutor.person.global_id
learning_unit_year = mdl_base.learning_unit_year.get_full_by_learning_container_year_id(
learning_container_year_id)
learning_container_year = learning_unit_year.learning_container_year
can_be_saved = True
if request.method == 'POST':
form = ApplicationForm(learning_container_year=learning_container_year,
data=request.POST)
if form.is_valid():
application = form.cleaned_data
try:
tutor_application.create_or_update_application(
global_id, application)
tutor_application.set_pending_flag(
global_id, application,
tutor_application_epc.UPDATE_OPERATION)
# Send message to EPC
tutor_application_epc.send_message(
tutor_application_epc.UPDATE_OPERATION, global_id,
application)
except Exception as e:
error_msg = e.args[0]
messages.add_message(request, messages.ERROR, error_msg)
return redirect('applications_overview')
else:
inital_data = tutor_application.get_application(
global_id, learning_container_year)
can_be_saved = tutor_application.can_be_updated(
inital_data) if inital_data else True
form = ApplicationForm(
initial=inital_data,
learning_container_year=learning_container_year,
)
return layout.render(
request, "application_form.html", {
'a_tutor': tutor,
'form': form,
'learning_container_year': learning_container_year,
'learning_unit_year': learning_unit_year,
'can_be_saved': can_be_saved
})