def test_application_form_prevent_duplicate_emails():
event = Event.objects.create(name='Test',
city='Test',
country='Test',
is_page_live=True,
page_url='test')
form = Form.objects.create(event=event)
# Override default questions, we need just the e-mail
form.question_set.all().delete()
question = Question.objects.create(title="Your e-mail address:",
question_type="email",
form=form,
order=1)
assert Application.objects.count() == 0
form_data = {
'newsletter_optin': 'yes',
'g-recaptcha-response': 'PASSED',
'question_{}'.format(question.pk): '*****@*****.**'
}
application_form = ApplicationForm(form_data, form=form)
assert application_form.is_valid()
application_form.save()
assert Application.objects.count() == 1
application_form = ApplicationForm(form_data, form=form)
assert not application_form.is_valid()
def test_application_form_prevent_duplicate_emails(self):
form_questions = [{
"title": "Your e-mail address:",
"question_type": "email",
}]
# Override default questions, we need just the e-mail
self.form.question_set.all().delete()
for i, question in enumerate(form_questions, start=1):
question['form'] = self.form
question['order'] = i
Question.objects.create(**question)
self.assertEqual(Application.objects.count(), 0)
questions = self.form.question_set.all()
form_data = {
'newsletter_optin': 'yes',
'g-recaptcha-response': 'PASSED'
}
for question in questions:
if question.title == "Your e-mail address:":
form_data.update(
{'question_{}'.format(question.pk): '*****@*****.**'})
continue
form = ApplicationForm(form_data, form=self.form)
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(Application.objects.count(), 1)
form = ApplicationForm(form_data, form=self.form)
self.assertFalse(form.is_valid())
def test_application_form_prevent_duplicate_emails(self):
form_questions = [
{
"title": "Your e-mail address:",
"question_type": "email",
}
]
# Override default questions, we need just the e-mail
self.form.question_set.all().delete()
for i, question in enumerate(form_questions, start=1):
question['form'] = self.form
question['order'] = i
Question.objects.create(**question)
self.assertEqual(Application.objects.count(), 0)
questions = self.form.question_set.all()
form_data = {
'newsletter_optin': 'yes',
'g-recaptcha-response': 'PASSED'
}
for question in questions:
if question.title == "Your e-mail address:":
form_data.update({
'question_{}'.format(question.pk): '*****@*****.**'
})
continue
form = ApplicationForm(form_data, form=self.form)
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(Application.objects.count(), 1)
form = ApplicationForm(form_data, form=self.form)
self.assertFalse(form.is_valid())
def test_should_not_be_valid_if_resume_not_pdf(self):
opening = OpeningFactory()
files = {'resume': self._get_temporary_file(type='evil/hacker')}
form = ApplicationForm(self.form_data, files, opening=opening)
self.assertFalse(form.is_valid())
files = {'resume': self._get_temporary_file(extension='py')}
form = ApplicationForm(self.form_data, files, opening=opening)
self.assertFalse(form.is_valid())
def test_should_be_valid_if_resume_is_doc_docx(self):
opening = OpeningFactory()
files = {'resume': self._get_temporary_file(
type='application/msword', extension='.DOC')}
form = ApplicationForm(self.form_data, files, opening=opening)
self.assertTrue(form.is_valid())
files = {'resume': self._get_temporary_file(
type='application/vnd.oasis.opendocument.text', extension='.dOcX')}
form = ApplicationForm(self.form_data, files, opening=opening)
self.assertTrue(form.is_valid())
def post(self, request, *args, **kwargs):
try:
opening = Opening.objects.get(id=self.kwargs['opening_id'])
except Opening.DoesNotExist:
raise Http404
if not opening.published_date:
raise Http404
form = ApplicationForm(request.POST, request.FILES, opening=opening)
if form.is_valid():
applicant = form.save()
send_customised_email(
"application_received",
company=opening.company,
to=applicant.email,
context=dict(applicant_first_name=applicant.first_name,
applicant_last_name=applicant.last_name,
company=mark_safe(opening.company.name),
opening=mark_safe(opening.title)))
return redirect('public:confirmation', opening_id=opening.id)
else:
context = {
'opening': opening,
'company': opening.company,
'form': form
}
return self.render_to_response(context)
def regular_application(request):
application = ApplicationFormModel.objects.get(user_id=request.user.id)
if request.method == 'POST':
application_form = ApplicationForm(request.POST, instance=application)
if application_form.is_valid():
application_form.save()
return HttpResponseRedirect('/')
else:
print('forms not valid')
# dictionary of all user application fields
application_dict = application.__dict__
# fields to exclude from form:
excluded_fields = {'id', 'user_id', '_state'}
# dictionary of fields to include on form
application_fields = {
k: v
for (k, v) in application_dict.items() if k not in excluded_fields
}
# generate dictionary that includes all needed keys and default values:
default_dict = {}
default_dict['user'] = request.user.id
for k, v in application_fields.items():
default_dict[k] = v
application_form = ApplicationForm(initial=default_dict)
return render(request, 'regular_application.html', {
'application_form': application_form,
})
def edit_application(request, id=None):
application = get_object_or_404(Application, id=id)
form = ApplicationForm(request.Post or None, instance=application)
if form.is_valid():
form.save()
return render(request, 'applications/application_form.htlm',
{'form': form})
def event_view(request, event_id):
event = Event.objects.get(pk=event_id)
ctx = {
'event': event
}
user = request.user
if user.is_authenticated():
application = Application.objects.filter(user=user,
event=event_id)
already_applied = application.count() > 0 #len == 1
is_applicant_user = is_applicant(user)
if is_applicant_user:
if not already_applied:
if request.method == 'POST':
form = ApplicationForm(request.POST)
if form.is_valid():
instance = form.save(commit=False)
instance.user = user
instance.event = event
instance.status = 0
instance.save()
else:
form = ApplicationForm()
ctx['form'] = form
else:
ctx['application'] = application[0]
ctx['already_applied'] = already_applied
ctx['is_applicant_user'] = is_applicant_user
return render(request, 'events/event.html', ctx)
def post(self, request, *args, **kwargs):
try:
opening = Opening.objects.get(id=self.kwargs['opening_id'])
except Opening.DoesNotExist:
raise Http404
if not opening.published_date:
raise Http404
form = ApplicationForm(request.POST, request.FILES, opening=opening)
if form.is_valid():
applicant = form.save()
send_customised_email("application_received",
company=opening.company,
to=applicant.email,
context=dict(applicant_first_name=applicant.first_name,
applicant_last_name=applicant.last_name,
company=mark_safe(opening.company.name),
opening=mark_safe(opening.title))
)
return redirect('public:confirmation', opening_id=opening.id)
else:
context = {
'opening': opening,
'company': opening.company,
'form': form
}
return self.render_to_response(context)
def test_application_without_questions_valid(self):
opening = OpeningFactory()
files = {'resume': self._get_temporary_file()}
form = ApplicationForm(self.form_data, files, opening=opening)
self.assertTrue(form.is_valid())
def test_application_without_questions_invalid(self):
opening = OpeningFactory()
invalid = dict(self.form_data)
del invalid['first_name']
files = {'resume': self._get_temporary_file()}
form = ApplicationForm(invalid, files, opening=opening)
self.assertFalse(form.is_valid())
def test_application_with_questions_valid(self):
opening = OpeningWithQuestionFactory()
data = dict(self.form_data)
data.update(self.question_data)
files = {'resume': self._get_temporary_file()}
form = ApplicationForm(data, files, opening=opening)
self.assertTrue(form.is_valid())
def create(request):
form = ApplicationForm(request.POST)
form.owner = request.user
if form.is_valid():
form.save()
else:
# report errors (just the text)
for k, v in form.errors.iteritems():
messages.add_message(request, messages.ERROR, v[0].capitalize())
return redirect(reverse("applications.views.index"))
def test_application_with_missing_required_valid(self):
opening = OpeningWithQuestionFactory()
data = dict(self.form_data)
data.update(self.question_data)
del data['question-1']
files = {'resume': self._get_temporary_file()}
form = ApplicationForm(data, files, opening=opening)
self.assertFalse(form.is_valid())
def create(request):
form = ApplicationForm(request.POST)
form.owner = request.user
if form.is_valid():
form.save()
else:
# report errors (just the text)
for k, v in form.errors.iteritems():
messages.add_message(request, messages.ERROR, v[0].capitalize())
return redirect(reverse('applications.views.index'))
def create(request):
form = ApplicationForm()
if request.method == 'POST':
form = ApplicationForm(request.POST)
form.owner = request.user
if form.is_valid():
app = form.save()
return redirect(reverse('applications.views.index'))
ctx = {'form': form}
return render_to_response('applications/create_application.html',
ctx,
context_instance=RequestContext(request))
def create(request):
form = ApplicationForm()
if request.method == 'POST':
form = ApplicationForm(request.POST)
form.owner = request.user
if form.is_valid():
app = form.save()
return redirect(reverse('applications.views.index'))
ctx = {
'form': form
}
return render_to_response('applications/create_application.html', ctx,
context_instance=RequestContext(request))
def test_should_not_create_new_applicant_if_exists(self):
ApplicantFactory(email='*****@*****.**')
company = CompanyFactory()
opening = OpeningFactory(company=company)
InterviewStageFactory(tag='RECEIVED', company=company)
files = {'resume': self._get_temporary_file()}
form = ApplicationForm(self.form_data, files, opening=opening)
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(Applicant.objects.count(), 1)
def create_application(request):
if request.method == 'POST':
form = ApplicationForm(request.POST)
if form.is_valid():
application = form.save(commit=False)
application.save()
else:
form = ApplicationForm()
return render(request,
'applications/application_form.html',
context={
'form': form,
'COMPANY_NAME': settings.BRAND_DICT['COMPANY_NAME'],
})
def test_save_with_company_stage(self):
ApplicantFactory(email='*****@*****.**')
company1 = CompanyFactory()
company2 = CompanyFactory()
opening = OpeningFactory(company=company1)
stage_company1 = InterviewStageFactory(tag='RECEIVED', company=company1)
stage_company2 = InterviewStageFactory(tag='RECEIVED', company=company2)
files = {'resume': self._get_temporary_file()}
form = ApplicationForm(self.form_data, files, opening=opening)
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(Applicant.objects.count(), 1)
def details(request, app_uuid=None):
app = Application.objects.get(uuid=app_uuid)
form = ApplicationForm(instance=app)
if request.method == 'POST':
form = ApplicationForm(request.POST, instance=app)
if form.is_valid():
form.save()
try:
app.update_config()
messages.add_message(request, messages.INFO,
_('Application updated'))
return redirect(reverse('applications.views.index'))
except KeyError, e:
messages.add_message(request, messages.ERROR,
_('Error updating hipache. Invalid container port') + \
': {}'.format(e[0]))
def details(request, app_uuid=None):
app = Application.objects.get(uuid=app_uuid)
form = ApplicationForm(instance=app)
if request.method == 'POST':
form = ApplicationForm(request.POST, instance=app)
if form.is_valid():
form.save()
try:
app.update_config()
messages.add_message(request, messages.INFO,
_('Application updated'))
return redirect(reverse('applications.views.index'))
except KeyError, e:
messages.add_message(request, messages.ERROR,
_('Error updating hipache. Invalid container port') + \
': {}'.format(e[0]))
def manage_application(request, event):
if request.method == 'POST':
form = ApplicationForm(request.POST)
if form.is_valid():
instance = form.save(commit=False)
instance.user = request.user
#FIXME
instance.event = event
instance.status = 0 #pending
instance.save()
else:
form = ApplicationForm()
return render_to_response("applications/application_form.html",
{"form": form},
context_instance=RequestContext(request)
)
def test_application_form_no_questions():
event = Event.objects.create(name='Test',
city='Test',
country='Test',
is_page_live=True,
page_url='test')
form = Form.objects.create(event=event)
# Override default questions, we need just the e-mail
form.question_set.all().delete()
assert Application.objects.count() == 0
form_data = {'newsletter_optin': 'yes', 'g-recaptcha-response': 'PASSED'}
application_form = ApplicationForm(form_data, form=form)
assert application_form.is_valid()
def post(self, request, *args, **kwargs):
applicant_id = kwargs.get('applicant_id')
application_form = ApplicationForm(request.POST)
if application_form.is_valid():
institute_id = request.POST.get('institute')
institute_obj = get_object_or_404(InstitutionProfile,
id=institute_id)
applicant_obj = get_object_or_404(ApplicantProfile,
id=applicant_id)
if institute_obj.gender == '1' and applicant_obj.gender == '2':
messages.error(
request,
f"{institute_obj.institute_name} Is Only Allow Male Student"
)
return redirect('applications:apply', applicant_obj.id)
if institute_obj.gender == '2' and applicant_obj.gender == '1':
messages.error(
request,
f"{institute_obj.institute_name} Is Only Allow Female Student"
)
return redirect('applications:apply', applicant_obj.id)
check_application = Application.objects.filter(
applicant=applicant_obj, institute=institute_obj).first()
if check_application and check_application.paid:
messages.info(
request,
f"You Already Apply For {institute_obj.institute_name}.Please Wiat For Admit Card"
)
return redirect('applications:application_list')
if check_application and not check_application.paid:
messages.info(
request,
f"You Already Apply For {institute_obj.institute_name}.Please Pay The Fees"
)
return redirect('applications:application_list')
check_session = AdmissionSession.objects.filter(
institute=institute_obj, status=True).first()
if not check_session:
messages.error(
request,
f"Now Admission Is Closed For {institute_obj.institute_name}"
)
return redirect('applications:apply', applicant_obj.id)
if check_session.level == '1' and request.POST.get('level') == '2':
messages.error(
request,
f"{institute_obj.institute_name} Only Avialable For Bachelor Admission"
)
return redirect('applications:apply', applicant_obj.id)
if check_session.level == '2' and request.POST.get('level') == '1':
messages.error(
request,
f"{institute_obj.institute_name} Only Avialable For Masters Admission"
)
return redirect('applications:apply', applicant_obj.id)
subject_obj = get_object_or_404(InstitutionSubject,
id=request.POST.get('subject'))
if subject_obj.level == '1' and request.POST.get('level') == '2':
messages.error(
request,
f"{subject_obj.subject_name} In {institute_obj.institute_name} Only Avialable For Bachelor"
)
return redirect('applications:apply', applicant_obj.id)
if subject_obj.level == '2' and request.POST.get('level') == '1':
messages.error(
request,
f"{subject_obj.subject_name} In {institute_obj.institute_name} Only Avialable For Masters"
)
return redirect('applications:apply', applicant_obj.id)
application_form_obj = application_form.save(commit=False)
application_form_obj.owner = request.user
application_form_obj.applicant = applicant_obj
application_form_obj.save()
messages.success(
request,
f"Apply For {applicant_obj.student_name} In {institute_obj.institute_name} Is Successfully Completed"
)
return redirect('applications:application_list')
else:
context = {
'title': 'Apply',
'applicant_id': applicant_id,
'application_form': application_form
}
return render(request, 'applicant/applications/apply.html',
context)
