def rol_activeer_rol(request, rolurl):
""" Activeer een andere rol, als dit toegestaan is
geen foutmelding of exceptions als het niet mag.
"""
try:
nwe_rol = url2rol[rolurl]
except KeyError:
# onbekende rol
from_ip = get_safe_from_ip(request)
my_logger.error('%s ROL verzoek activeer onbekende rol %s' %
(from_ip, repr(rolurl)))
else:
try:
rollen_vast = request.session[SESSIONVAR_ROL_PALLET_VAST]
except KeyError:
pass
else:
# kijk of dit een toegestane rol is
if nwe_rol == Rollen.ROL_NONE or nwe_rol in rollen_vast:
request.session[SESSIONVAR_ROL_HUIDIGE_FUNCTIE_PK] = None
request.session[SESSIONVAR_ROL_HUIDIGE] = nwe_rol
request.session[
SESSIONVAR_ROL_BESCHRIJVING] = rol_bepaal_beschrijving(
nwe_rol)
else:
from_ip = get_safe_from_ip(request)
my_logger.error(
'%s ROL verzoek activeer niet toegekende rol %s' %
(from_ip, repr(rolurl)))
def receive_bevestiging_functie_email(request, functie):
""" deze functie wordt aangeroepen als een tijdelijke url gevolgd wordt
om een nieuw email adres te bevestigen voor een functie.
We moeten een url teruggeven waar een http-redirect naar gedaan kan worden
of een HttpResponse object.
"""
# het is mogelijk om meerdere keren hetzelfde e-mailadres te koppelen
# je hebt dan meerdere mails met tijdelijke urls om te volgen
# deze functie wordt voor elke gevolgde url aangeroepen
# na de eerste keer is nieuwe_email leeg en gebeurt er niets
# we geven wel steeds het succes verhaal terug
if functie.nieuwe_email:
# schrijf in het logboek
from_ip = get_safe_from_ip(request)
msg = "Bevestigd vanaf IP %s voor functie %s" % (from_ip,
functie.beschrijving)
schrijf_in_logboek(account=None,
gebruikte_functie="Bevestig e-mail",
activiteit=msg)
# zet het e-mailadres door
functie.bevestigde_email = functie.nieuwe_email
functie.nieuwe_email = ''
functie.save()
context = {'functie': functie}
return render(request, TEMPLATE_EMAIL_BEVESTIGD, context)
def account_otp_koppel(request, account, code):
""" Breng de 2FA koppeling tot stand als de juiste code opgegeven is
als deze klopt, dan wordt koppeling vastgelegd en extra rechten vrijgegeven
als de control mislukt, dan wordt dit in het logboek geschreven
Returns: True: Gelukt
False: Mislukt
"""
if not request.user.is_authenticated:
return False
from_ip = get_safe_from_ip(request)
otp = pyotp.TOTP(account.otp_code)
# valid_window=1 staat toe dat er net een nieuwe code gegenereerd is tijdens het intikken van de code
is_valid = otp.verify(code, valid_window=1)
if is_valid:
# controle is gelukt --> koppeling maken
account.otp_is_actief = True
account.save()
my_logger.info('%s 2FA koppeling gelukt voor account %s' % (from_ip, account.username))
# propageer het succes zodat de gebruiker meteen aan de slag kan
account_rechten_otp_controle_gelukt(request)
return True
# controle is mislukt - schrijf dit in het logboek
schrijf_in_logboek(account=None,
gebruikte_functie="OTP controle",
activiteit='Gebruiker %s OTP koppeling controle mislukt vanaf IP %s' % (
repr(account.username), from_ip))
my_logger.info('%s 2FA koppeling mislukte controle voor account %s' % (from_ip, account.username))
return False
def account_otp_controleer(request, account, code):
""" deze functie controleert de opgegeven account code
als deze klopt, dan worden extra rechten vrijgegeven
als de control mislukt, dan wordt dit in het logboek geschreven
Returns: True: Gelukt
False: Mislukt
"""
if not request.user.is_authenticated:
return False
if not request.user.otp_is_actief:
return False
from_ip = get_safe_from_ip(request)
otp = pyotp.TOTP(account.otp_code)
# valid_window=1 staat toe dat er net een nieuwe code gegenereerd is tijdens het intikken van de code
is_valid = otp.verify(code, valid_window=1)
if is_valid:
# controle is gelukt
account_rechten_otp_controle_gelukt(request)
my_logger.info('%s 2FA controle gelukt voor account %s' % (from_ip, account.username))
return True
# controle is mislukt - schrijf dit in het logboek
schrijf_in_logboek(account=None,
gebruikte_functie="OTP controle",
activiteit='Gebruiker %s OTP controle mislukt vanaf IP %s' % (repr(account.username), from_ip))
my_logger.info('%s 2FA mislukte controle voor account %s' % (from_ip, account.username))
return False
def _zoek_account(self, form):
# zoek een bestaand account
# we doen hier alvast een stukje voorwerk dat normaal door het backend gedaan wordt
# ondersteunen inlog met Account.username en Account.bevestigde_email
from_ip = get_safe_from_ip(self.request)
login_naam = form.cleaned_data.get('login_naam')
account = None
try:
account = Account.objects.get(username=login_naam)
except Account.DoesNotExist:
# account met deze username bestaat niet
# sta ook toe dat met het email adres ingelogd wordt
try:
email = AccountEmail.objects.get(
bevestigde_email__iexact=login_naam
) # iexact = case insensitive volledige match
except AccountEmail.DoesNotExist:
# email is ook niet bekend
# LET OP! dit kan heel snel heel veel data worden! - voorkom storage overflow!!
# my_logger.info('%s LOGIN Mislukte inlog voor onbekend inlog naam %s' % (from_ip, repr(login_naam)))
# schrijf_in_logboek(None, 'Inloggen', 'Mislukte inlog vanaf IP %s: onbekende inlog naam %s' % (from_ip, repr(login_naam)))
pass
except AccountEmail.MultipleObjectsReturned:
# kan niet kiezen tussen verschillende accounts
# werkt dus niet als het email hergebruikt is voor meerdere accounts
form.add_error(
None,
'Inloggen met e-mail is niet mogelijk. Probeer het nog eens.'
)
account = None
else:
# email gevonden
# pak het account erbij
account = email.account
if account:
# blokkeer inlog als het account geblokkeerd is door te veel wachtwoord pogingen
now = timezone.now()
if account.is_geblokkeerd_tot:
if account.is_geblokkeerd_tot > now:
schrijf_in_logboek(
account, 'Inloggen',
'Mislukte inlog vanaf IP %s voor geblokkeerd account %s'
% (from_ip, repr(login_naam)))
my_logger.info(
'%s LOGIN Mislukte inlog voor geblokkeerd account %s' %
(from_ip, repr(login_naam)))
context = {'account': account}
menu_dynamics(self.request, context)
return render(self.request, TEMPLATE_GEBLOKKEERD,
context), None
return None, account
def post(self, request, *args, **kwargs):
from_ip = get_safe_from_ip(request)
context = super().get_context_data(**kwargs)
context['foutmelding'] = ''
email = request.POST.get('email',
'')[:150] # afkappen voor extra veiligheid
if not mailer_email_is_valide(email):
context[
'foutmelding'] = 'Voer een valide e-mailadres in van een bestaand account'
if not context['foutmelding']:
username = request.POST.get(
'lid_nr', '')[:10] # afkappen voor extra veiligheid
# zoek een account met deze email
try:
account_email = (
AccountEmail.objects.get(
bevestigde_email__iexact=
email, # iexact = case insensitive volledige match
account__username=username))
except AccountEmail.DoesNotExist:
# email is niet bekend en past niet bij de inlog naam
context[
'foutmelding'] = 'Voer het e-mailadres en NHB nummer in van een bestaand account'
# (niet te veel wijzer maken over de combi NHB nummer en e-mailadres)
# we controleren hier niet of het account inactief is, dat doet login wel weer
menu_dynamics(self.request, context)
if not context['foutmelding']:
# we hebben nu het account waar we een de e-mail voor moeten sturen
schrijf_in_logboek(
account=None,
gebruikte_functie="Wachtwoord",
activiteit=
"Stuur e-mail naar adres %s voor account %s, verzocht vanaf IP %s."
%
(repr(account_email.bevestigde_email),
repr(account_email.account.get_account_full_name()), from_ip))
account_stuur_email_wachtwoord_vergeten(
account_email,
wachtwoord='vergeten',
email=account_email.bevestigde_email)
httpresp = render(request, TEMPLATE_EMAIL, context)
else:
httpresp = render(request, self.template_name, context)
return httpresp
def post(request, *args, **kwargs):
""" deze functie wordt aangeroepen als een POST request ontvangen is
we zorgen voor het uitloggen en sturen door naar een andere pagina
"""
from_ip = get_safe_from_ip(request)
my_logger.info('%s LOGOUT voor account %s' %
(from_ip, repr(request.user.username)))
# integratie met de authenticatie laag van Django
# dit wist ook de session data gekoppeld aan het cookie van de gebruiker
logout(request)
# redirect naar het plein
return HttpResponseRedirect(reverse('Plein:plein'))
def receiver_account_wissel(request, obj):
""" Met deze functie kan een geautoriseerd persoon tijdelijk inloggen op de site
als een andere gebruiker.
obj is een AccountEmail object.
We moeten een url teruggeven waar een http-redirect naar gedaan kan worden.
"""
account = obj.account
old_last_login = account.last_login
# integratie met de authenticatie laag van Django
login(request, account)
from_ip = get_safe_from_ip(request)
my_logger.info('%s LOGIN automatische inlog met account %s' %
(from_ip, repr(account.username)))
for _, func in account_plugins_login:
httpresp = func(request, from_ip, account)
if httpresp:
# plugin has decided that the user may not login
# and has generated/rendered an HttpResponse that we cannot handle here
return httpresp
if account.otp_is_actief:
# fake de OTP passage
account_rechten_otp_controle_gelukt(request)
else:
account_rechten_login_gelukt(request)
# herstel de last_login van de echte gebruiker
account.last_login = old_last_login
account.save(update_fields=['last_login'])
# gebruiker mag NIET aangemeld blijven
# zorg dat de session-cookie snel verloopt
request.session.set_expiry(0)
# schrijf in het logboek
schrijf_in_logboek(
account=None,
gebruikte_functie="Inloggen",
activiteit="Automatische inlog als gebruiker %s vanaf IP %s" %
(repr(account.username), from_ip))
return reverse('Plein:plein')
def receive_wachtwoord_vergeten(request, obj):
""" deze functie wordt aangeroepen als een tijdelijke url gevolgd wordt
voor een vergeten wachtwoord.
obj is een AccountEmail object.
We moeten een url teruggeven waar een http-redirect naar gedaan kan worden.
We loggen automatisch in op het account waar de link bij hoort
en sturen dan door naar de wijzig-wachtwoord pagina
"""
account = obj.account
# integratie met de authenticatie laag van Django
login(request, account)
from_ip = get_safe_from_ip(request)
my_logger.info(
'%s LOGIN automatische inlog voor wachtwoord-vergeten met account %s' %
(from_ip, repr(account.username)))
for _, func, _ in account_plugins_login:
httpresp = func(request, from_ip, account)
if httpresp:
# plugin has decided that the user may not login
# and has generated/rendered an HttpResponse that we cannot handle here
return httpresp
account_rechten_login_gelukt(request)
# gebruiker mag NIET aangemeld blijven
# zorg dat de session-cookie snel verloopt
request.session.set_expiry(0)
request.session['moet_oude_ww_weten'] = False
# schrijf in het logboek
schrijf_in_logboek(
account=None,
gebruikte_functie="Wachtwoord",
activiteit="Automatische inlog op account %s vanaf IP %s" %
(repr(account.get_account_full_name()), from_ip))
return reverse('Account:nieuw-wachtwoord')
def receive_bevestiging_accountemail(request, obj):
""" deze functie wordt aangeroepen als een tijdelijke url gevolgd wordt
om een email adres te bevestigen, zowel de eerste keer als wijziging van email.
obj is een AccountEmail object.
We moeten een url teruggeven waar een http-redirect naar gedaan kan worden.
"""
account_email_bevestiging_ontvangen(obj)
# schrijf in het logboek
from_ip = get_safe_from_ip(request)
account = obj.account
msg = "Bevestigd vanaf IP %s voor account %s" % (
from_ip, account.get_account_full_name())
schrijf_in_logboek(account=account,
gebruikte_functie="Bevestig e-mail",
activiteit=msg)
context = dict()
if not request.user.is_authenticated:
context['show_login'] = True
return render(request, TEMPLATE_BEVESTIGD, context)
def post(self, request, *args, **kwargs):
from_ip = get_safe_from_ip(self.request)
if 'rol' in kwargs:
# activeer rol
my_logger.info(
'%s ROL account %s wissel naar rol %s' %
(from_ip, self.request.user.username, repr(kwargs['rol'])))
rol_activeer_rol(request, kwargs['rol'])
else:
# activeer functie
my_logger.info('%s ROL account %s wissel naar functie %s' %
(from_ip, self.request.user.username,
repr(kwargs['functie_pk'])))
rol_activeer_functie(request, kwargs['functie_pk'])
rol_beschrijving = rol_get_beschrijving(request)
my_logger.info('%s ROL account %s is nu %s' %
(from_ip, self.request.user.username, rol_beschrijving))
# stuur een aantal rollen door naar een functionele pagina
# de rest blijft in Wissel van Rol
rol_nu, functie_nu = rol_get_huidige_functie(request)
# if rol == Rollen.ROL_BB:
# return redirect('Competitie:kies')
if rol_nu in (Rollen.ROL_SEC, Rollen.ROL_HWL, Rollen.ROL_WL):
return redirect('Vereniging:overzicht')
if rol_nu in (Rollen.ROL_BKO, Rollen.ROL_RKO, Rollen.ROL_RCL):
url = get_url_voor_competitie(functie_nu)
# print('rol=%s, comp_type=%s, url=%s' % (functie_nu.rol, functie_nu.comp_type, url))
if url:
return redirect(url)
return redirect('Functie:wissel-van-rol')
def post(self, request, *args, **kwargs):
""" wordt aangeroepen als de OPSLAAN knop gebruikt wordt op het formulier
om een nieuw wachtwoord op te geven.
"""
context = super().get_context_data(**kwargs)
account = request.user
huidige_ww = request.POST.get(
'huidige', '')[:50] # afkappen voor extra veiligheid
nieuw_ww = request.POST.get('nieuwe',
'')[:50] # afkappen voor extra veiligheid
from_ip = get_safe_from_ip(self.request)
try:
moet_oude_ww_weten = self.request.session['moet_oude_ww_weten']
except KeyError:
moet_oude_ww_weten = True
# controleer het nieuwe wachtwoord
valid, errmsg = account_test_wachtwoord_sterkte(
nieuw_ww, account.username)
# controleer het huidige wachtwoord
if moet_oude_ww_weten and valid:
if not authenticate(username=account.username,
password=huidige_ww):
valid = False
errmsg = "Huidige wachtwoord komt niet overeen"
schrijf_in_logboek(
account=account,
gebruikte_functie="Wachtwoord",
activiteit=
'Verkeerd huidige wachtwoord vanaf IP %s voor account %s' %
(from_ip, repr(account.username)))
my_logger.info(
'%s LOGIN Verkeerd huidige wachtwoord voor account %s' %
(from_ip, repr(account.username)))
if not valid:
context['foutmelding'] = errmsg
try:
context['moet_oude_ww_weten'] = self.request.session[
'moet_oude_ww_weten']
except KeyError:
context['moet_oude_ww_weten'] = True
if account.sporter_set.count(
) > 0: # FUTURE: ongewenste kennis over Sporter.account
menu_dynamics(self.request, context, actief="sporter-profiel")
else:
menu_dynamics(self.request, context)
return render(request, self.template_name, context)
# wijzigen van het wachtwoord zorgt er ook voor dat alle sessies van deze gebruiker vervallen
# hierdoor blijft de gebruiker niet ingelogd op andere sessies
account.set_password(nieuw_ww)
account.save()
# houd de gebruiker ingelogd in deze sessie
update_session_auth_hash(request, account)
try:
del request.session['moet_oude_ww_weten']
except KeyError:
pass
# schrijf in het logboek
schrijf_in_logboek(account=account,
gebruikte_functie="Wachtwoord",
activiteit="Nieuw wachtwoord voor account %s" %
repr(account.get_account_full_name()))
return HttpResponseRedirect(reverse('Plein:plein'))
def post(request, *args, **kwargs):
""" deze functie wordt aangeroepen als een POST request ontvangen is.
dit is gekoppeld aan het drukken op de Registreer knop.
"""
form = RegistreerForm(request.POST)
if form.is_valid():
nhb_nummer = form.cleaned_data.get('nhb_nummer')
email = form.cleaned_data.get('email')
nieuw_wachtwoord = form.cleaned_data.get('nieuw_wachtwoord')
from_ip = get_safe_from_ip(request)
try:
sporter_create_account_nhb(nhb_nummer, email, nieuw_wachtwoord)
except SporterGeenEmail as exc:
schrijf_in_logboek(account=None,
gebruikte_functie="Registreer met NHB nummer",
activiteit='NHB lid %s heeft geen email adres.' % nhb_nummer)
my_logger.info('%s REGISTREER Geblokkeerd voor NHB nummer %s (geen email)' % (from_ip, repr(nhb_nummer)))
# redirect naar een pagina met een uitgebreider duidelijk bericht
context = {'sec_email': '',
'sec_naam': '',
'email_bb': settings.EMAIL_BONDSBUREAU}
ver = exc.sporter.bij_vereniging
if ver:
secs = Secretaris.objects.filter(vereniging=ver).exclude(sporter=None).all()
if secs.count() > 0:
sec = secs[0].sporter
context['sec_naam'] = sec.volledige_naam()
functie = Functie.objects.get(rol='SEC', nhb_ver=ver)
context['sec_email'] = functie.bevestigde_email
menu_dynamics(request, context)
return render(request, TEMPLATE_REGISTREER_GEEN_EMAIL, context)
except AccountCreateError as exc:
form.add_error(None, str(exc))
# schrijf in het logboek
schrijf_in_logboek(account=None,
gebruikte_functie="Registreer met NHB nummer",
activiteit="Mislukt voor nhb nummer %s vanaf IP %s: %s" % (repr(nhb_nummer), from_ip, str(exc)))
my_logger.info('%s REGISTREER Mislukt voor NHB nummer %s met email %s (reden: %s)' % (from_ip, repr(nhb_nummer), repr(email), str(exc)))
except SporterInactief:
# NHB lid is mag niet gebruik maken van de diensten van de NHB, inclusief deze website
schrijf_in_logboek(account=None,
gebruikte_functie="Registreer met NHB nummer",
activiteit='NHB lid %s is inactief (geblokkeerd van gebruik NHB diensten).' % nhb_nummer)
form.add_error(None, 'Gebruik van NHB diensten is geblokkeerd. Neem contact op met de secretaris van je vereniging.')
my_logger.info('%s REGISTREER Geblokkeerd voor NHB nummer %s (inactief)' % (from_ip, repr(nhb_nummer)))
# FUTURE: redirect naar een pagina met een uitgebreider duidelijk bericht
else:
# schrijf in het logboek
schrijf_in_logboek(account=None,
gebruikte_functie="Registreer met NHB nummer",
activiteit="Account aangemaakt voor NHB nummer %s vanaf IP %s" % (repr(nhb_nummer), from_ip))
my_logger.info('%s REGISTREER account aangemaakt voor NHB nummer %s' % (from_ip, repr(nhb_nummer)))
request.session['login_naam'] = nhb_nummer
request.session['partial_email'] = mailer_obfuscate_email(email)
return HttpResponseRedirect(reverse('Account:aangemaakt'))
# still here --> re-render with error message
context = {'form': form}
menu_dynamics(request, context)
return render(request, TEMPLATE_REGISTREER, context)
def post(self, request, *args, **kwargs):
from_ip = get_safe_from_ip(request)
context = super().get_context_data(**kwargs)
context['foutmelding'] = ''
email = request.POST.get('email',
'')[:150] # afkappen voor extra veiligheid
if not mailer_email_is_valide(email):
context[
'foutmelding'] = 'Voer het e-mailadres in van een bestaand account'
if not context['foutmelding']:
# zoek een account met deze email
try:
account_email = (
AccountEmail.objects.get(bevestigde_email__iexact=email)
) # iexact = case insensitive volledige match
except AccountEmail.DoesNotExist:
# email is ook niet bekend
context[
'foutmelding'] = 'Voer het e-mailadres in van een bestaand account'
except AccountEmail.MultipleObjectsReturned:
# kan niet kiezen tussen verschillende accounts
# werkt dus niet als het email hergebruikt is voor meerdere accounts
context[
'foutmelding'] = 'Er is een probleem met dit e-mailadres. Neem contact op met het bondsburo!'
# schrijf de intentie in het logboek
schrijf_in_logboek(
account=None,
gebruikte_functie="Wachtwoord",
activiteit=
"E-mail adres %s wordt gebruikt voor meer dan een account. Dit wordt niet ondersteund."
% repr(email))
# we controleren hier niet of het account inactief is, dat doet login wel weer
if not context['foutmelding']:
# we hebben nu het account waar we een de e-mail voor moeten sturen
schrijf_in_logboek(
account=None,
gebruikte_functie="Wachtwoord",
activiteit=
"Stuur e-mail naar adres %s voor account %s, verzocht vanaf IP %s."
%
(repr(account_email.bevestigde_email),
repr(account_email.account.get_account_full_name()), from_ip))
account_stuur_email_wachtwoord_vergeten(
account_email,
wachtwoord='vergeten',
email=account_email.bevestigde_email)
httpresp = render(request, TEMPLATE_EMAIL, context)
else:
httpresp = render(request, self.template_name, context)
return httpresp
def post(self, request, *args, **kwargs):
""" deze functie wordt aangeroepen als een POST request ontvangen is """
# begrens hoe snel deze functie misbruikt kan worden
time.sleep(1)
code = kwargs['code'][:32] # afkappen voor veiligheid
email = request.POST.get('email', '')
email = email.strip().lower()
if len(code) != 32 or not mailer_email_is_valide(email):
# geen goede code of geen valide email ingevoerd
return self.get(request, *args, **kwargs)
try:
levering = (Levering
.objects
.select_related('opdracht')
.get(url_code=code))
except Levering.DoesNotExist:
return render(request, TEMPLATE_LEVERING_NIET_GEVONDEN)
if levering.is_geblokkeerd:
return render(request, TEMPLATE_LEVERING_NIET_GEVONDEN)
if levering.to_email.strip().lower() != email:
# verkeerde e-mail: laat de gebruiker opnieuw een e-mail invoeren
return self.get(request, *args, **kwargs)
# zoek het bestand erbij en stuur deze over
product = levering.product
fpath, naam = get_path_to_product_bestand(product)
klein = naam.lower()
if '.zip' in klein:
content_type = 'application/zip'
elif '.pdf' in klein:
content_type = 'application/pdf'
else:
content_type = 'application/octet-stream'
try:
with open(fpath, 'rb') as file_handle:
response = HttpResponse(file_handle, content_type=content_type)
response['Content-Disposition'] = 'attachment; filename="%s"' % naam
except (FileNotFoundError, OSError) as exc:
# bestand niet gevonden
my_logger.error('Download levering %s (%s) mislukt: %s' % (levering.pk, fpath, str(exc)))
return render(request, TEMPLATE_LEVERING_NIET_GEVONDEN)
from_ip = get_safe_from_ip(request)
my_logger.info('Download levering %s (%s) vanaf IP %s' % (levering.pk, fpath, from_ip))
if levering.download_count > 0:
levering.download_count -= 1
if levering.download_count <= 0:
levering.is_geblokkeerd = True
levering.save()
opdracht = levering.opdracht
if opdracht:
if not opdracht.is_afgehandeld:
opdracht.is_afgehandeld = True
opdracht.save()
return response
def _probeer_login(self, form, account):
""" Kijk of het wachtwoord goed is en het account niet geblokkeerd is """
from_ip = get_safe_from_ip(self.request)
login_naam = form.cleaned_data.get('login_naam')
wachtwoord = form.cleaned_data.get('wachtwoord')
next_url = form.cleaned_data.get('next')
# controleer het wachtwoord
account2 = authenticate(username=account.username, password=wachtwoord)
if not account2:
# authenticatie is niet gelukt
# reden kan zijn: verkeerd wachtwoord of is_active=False
# onthoudt precies wanneer dit was
account.laatste_inlog_poging = timezone.now()
schrijf_in_logboek(
account, 'Inloggen',
'Mislukte inlog vanaf IP %s voor account %s' %
(from_ip, repr(login_naam)))
my_logger.info('%s LOGIN Mislukte inlog voor account %s' %
(from_ip, repr(login_naam)))
# onthoudt hoe vaak dit verkeerd gegaan is
account.verkeerd_wachtwoord_teller += 1
account.save()
# bij te veel pogingen, blokkeer het account
if account.verkeerd_wachtwoord_teller >= settings.AUTH_BAD_PASSWORD_LIMIT:
account.is_geblokkeerd_tot = (
timezone.now() +
timedelta(minutes=settings.AUTH_BAD_PASSWORD_LOCKOUT_MINS))
account.verkeerd_wachtwoord_teller = 0 # daarna weer volle mogelijkheden
account.save()
schrijf_in_logboek(
account, 'Inlog geblokkeerd',
'Account %s wordt geblokkeerd tot %s' %
(repr(login_naam),
account.is_geblokkeerd_tot.strftime('%Y-%m-%d %H:%M:%S')))
context = {'account': account}
return render(self.request, TEMPLATE_GEBLOKKEERD, context)
# wachtwoord klopt niet, doe opnieuw
return None
# wachtwoord is goed
account = account2
# kijk of er een reden is om gebruik van het account te weren
for _, func in account_plugins_login:
httpresp = func(self.request, from_ip, account)
if httpresp:
# plugin has decided that the user may not login
# and has generated/rendered an HttpResponse
return httpresp
# integratie met de authenticatie laag van Django
login(self.request, account)
my_logger.info('%s LOGIN op account %s' %
(from_ip, repr(account.username)))
if account.verkeerd_wachtwoord_teller > 0:
account.verkeerd_wachtwoord_teller = 0
account.save()
# Aangemeld blijven checkbox
if not form.cleaned_data.get('aangemeld_blijven', False):
# gebruiker wil NIET aangemeld blijven
# zorg dat de session-cookie snel verloopt
self.request.session.set_expiry(0)
account_rechten_login_gelukt(self.request)
# voer de automatische redirect uit, indien gevraagd
if next_url:
# reject niet bestaande urls
# resolve zoekt de view die de url af kan handelen
if next_url[-1] != '/':
next_url += '/'
try:
resolve(next_url)
except Resolver404:
pass
else:
# is valide url
return HttpResponseRedirect(next_url)
if account.otp_is_actief:
return HttpResponseRedirect(reverse('Functie:otp-controle'))
return HttpResponseRedirect(reverse('Plein:plein'))