def test_attend_with_payment_creates_paymentdelay(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
event = G(Event)
G(
AttendanceEvent,
event=event,
registration_start=timezone.now() - timedelta(days=1),
registration_end=timezone.now() + timedelta(days=1),
)
self.event_payment = generate_payment(event,
payment_type=3,
delay=timedelta(days=2))
G(PaymentPrice, price=200, payment=self.event_payment)
url = reverse("attend_event", args=(event.id, ))
form_params = {"g-recaptcha-response": "PASSED"}
G(
Membership,
username=self.user.ntnu_username,
expiration_date=timezone.now() + timedelta(days=1),
)
MarkRuleSet.accept_mark_rules(self.user)
self.client.post(url, form_params, follow=True)
self.assertTrue(PaymentDelay.objects.filter(user=self.user).exists())
def test_attend_twice(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
event = G(Event)
G(
AttendanceEvent,
event=event,
registration_start=timezone.now() - timedelta(days=1),
registration_end=timezone.now() + timedelta(days=1),
)
url = reverse("attend_event", args=(event.id, ))
form_params = {"g-recaptcha-response": "PASSED"}
G(
Membership,
username=self.user.ntnu_username,
expiration_date=timezone.now() + timedelta(days=1),
)
MarkRuleSet.accept_mark_rules(self.user)
self.client.post(url, form_params, follow=True)
response = self.client.post(url, form_params, follow=True)
self.assertRedirects(response, event.get_absolute_url())
self.assertInMessages("Du er allerede meldt på dette arrangementet.",
response)
def test_changing_an_old_ruleset_does_not_replace_the_current(self):
new_rule_set: MarkRuleSet = G(MarkRuleSet)
self.rule_set.version = "1.0.1"
self.rule_set.content = "Changed the old rules"
self.rule_set.save()
self.assertEqual(MarkRuleSet.get_current_rule_set(), new_rule_set)
def test_attend_invalid_captcha(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=False)
url = reverse("attend_event", args=(self.event.id, ))
form_params = {"g-recaptcha-response": "WRONG"}
G(
Membership,
username=self.user.ntnu_username,
expiration_date=timezone.now() + timedelta(days=1),
)
MarkRuleSet.accept_mark_rules(self.user)
response = self.client.post(url, form_params, follow=True)
self.assertRedirects(response, self.event.get_absolute_url())
self.assertInMessages("Du klarte ikke captchaen! Er du en bot?",
response)
def update_mark_rules(request):
if request.is_ajax():
if request.method == "POST":
accepted = request.POST.get("rules_accepted") == "true"
if accepted:
return_status = json.dumps(
{"message": _("Du har valgt å akseptere prikkereglene.")})
MarkRuleSet.accept_mark_rules(request.user)
else:
return_status = json.dumps({
"message":
_("Du kan ikke endre din godkjenning av prikkereglene.")
})
return HttpResponse(status=403, content=return_status)
return HttpResponse(status=212, content=return_status)
return HttpResponse(status=405)
def clean(self):
super(CaptchaForm, self).clean()
cleaned_data = self.cleaned_data
if "mark_rules" in self.fields:
if "mark_rules" in cleaned_data:
mark_rules = cleaned_data["mark_rules"]
if mark_rules:
MarkRuleSet.accept_mark_rules(self.user)
if "phone_number" in self.fields:
if "phone_number" in cleaned_data:
phone_number = cleaned_data["phone_number"]
if phone_number:
self.user.phone_number = phone_number
self.user.save()
return cleaned_data
def test_attend_before_registration_start(self, mocked_submit):
mocked_submit.return_value = RecaptchaResponse(is_valid=True)
event = G(Event)
G(
AttendanceEvent,
event=event,
registration_start=timezone.now() + timedelta(days=1),
registration_end=timezone.now() + timedelta(days=2),
)
url = reverse("attend_event", args=(event.id, ))
form_params = {"g-recaptcha-response": "PASSED"}
G(
AllowedUsername,
username=self.user.ntnu_username,
expiration_date=timezone.now() + timedelta(days=1),
)
MarkRuleSet.accept_mark_rules(self.user)
response = self.client.post(url, form_params, follow=True)
self.assertRedirects(response, event.get_absolute_url())
self.assertInMessages("Påmeldingen har ikke åpnet enda.", response)
def test_creating_a_ruleset_for_the_past_does_not_replace_current(self):
past_date = timezone.now() - timezone.timedelta(days=2)
G(MarkRuleSet, valid_from_date=past_date)
self.assertEqual(MarkRuleSet.get_current_rule_set(), self.rule_set)
def test_creating_new_rule_set_for_the_future_does_not_supplant_yet(self):
future_date = timezone.now() + timezone.timedelta(days=2)
G(MarkRuleSet, valid_from_date=future_date)
self.assertEqual(MarkRuleSet.get_current_rule_set(), self.rule_set)
def test_creating_new_rule_set_supplants_the_old(self):
new_rule_set: MarkRuleSet = G(MarkRuleSet)
self.assertEqual(MarkRuleSet.get_current_rule_set(), new_rule_set)
def test_creating_new_mark_rules_sets_accepted_to_false(self):
MarkRuleSet.accept_mark_rules(self.user)
self.assertTrue(self.user.mark_rules_accepted)
G(MarkRuleSet, valid_from_date=timezone.now())
self.assertFalse(self.user.mark_rules_accepted)
def test_accepting_mark_rules_sets_them_as_accepted(self):
MarkRuleSet.accept_mark_rules(self.user)
self.assertTrue(self.user.mark_rules_accepted)
def mark_rules_accepted(self):
from apps.marks.models import MarkRuleSet
return MarkRuleSet.has_user_accepted_mark_rules(user=self)
def _create_profile_context(request):
groups = Group.objects.all()
Privacy.objects.get_or_create(user=request.user) # This is a hack
"""
To make sure a privacy exists when visiting /profiles/privacy/.
Until now, it has been generated upon loading models.py, which is a bit hacky.
The code is refactored to use Django signals, so whenever a user is created, a privacy-property is set up.
"""
if request.user.is_staff and not request.user.online_mail:
create_online_mail_alias(request.user)
context = {
# edit
"position_form": PositionForm(),
"user_profile_form": ProfileForm(instance=request.user),
# positions
"groups": groups,
# privacy
"privacy_form": PrivacyForm(instance=request.user.privacy),
# nibble information
"transactions": PaymentTransaction.objects.filter(user=request.user),
"orders": Order.objects.filter(order_line__user=request.user).order_by(
"-order_line__datetime"
),
# SSO / OAuth2 approved apps
"connected_apps": AccessToken.objects.filter(
user=request.user, expires__gte=timezone.now()
).order_by("expires"),
# marks
"mark_rule_set": MarkRuleSet.get_current_rule_set(),
"mark_rules_accepted": request.user.mark_rules_accepted,
"marks": [
# Tuple syntax ('title', list_of_marks, is_collapsed)
(_("aktive prikker"), Mark.marks.active(request.user), False),
(_("inaktive prikker"), Mark.marks.inactive(request.user), True),
],
"suspensions": [
# Tuple syntax ('title', list_of_marks, is_collapsed)
(
_("aktive suspensjoner"),
Suspension.objects.filter(user=request.user, active=True),
False,
),
(
_("inaktive suspensjoner"),
Suspension.objects.filter(user=request.user, active=False),
True,
),
],
# password
"password_change_form": PasswordChangeForm(request.user),
# email
"new_email": NewEmailForm(),
# approvals
"field_of_study_application": FieldOfStudyApplicationForm(),
"has_active_approvals": MembershipApproval.objects.filter(
applicant=request.user, processed=False
).count()
> 0,
"approvals": [
# Tuple syntax ('title', list_of_approvals, is_collapsed)
(
_("aktive søknader"),
MembershipApproval.objects.filter(
applicant=request.user, processed=False
),
False,
),
(
_("avslåtte søknader"),
MembershipApproval.objects.filter(
applicant=request.user, processed=True, approved=False
),
True,
),
(
_("godkjente søknader"),
MembershipApproval.objects.filter(
applicant=request.user, processed=True
),
True,
),
],
"payments": [
(
_("ubetalt"),
PaymentDelay.objects.all().filter(user=request.user, active=True),
False,
),
(
_("betalt"),
PaymentRelation.objects.all().filter(user=request.user),
True,
),
],
"internal_services_form": InternalServicesForm(),
"in_comittee": has_access(request),
"enable_dataporten_application": settings.DATAPORTEN.get("STUDY").get("ENABLED")
or settings.DATAPORTEN.get("STUDY").get("TESTING"),
}
return context
