241 lines
8.3 KiB
Python
241 lines
8.3 KiB
Python
# -*- coding: iso-8859-1 -*-
|
|
u"""
|
|
_vi
|
|
<Ii _aa.
|
|
:I> aZ2^
|
|
v` .we^
|
|
. . .. + _2~
|
|
._auqXZZX ._auqXZZZ` ...._... ~ ._|ii~
|
|
.aXZZY""^~~ vX#Z?""~~~._=ii|+++++++ii=, _=|+~-
|
|
JXXX` )XXX' _|i+~ .__..._. +l= -~-
|
|
SXXo )XZX: |i> ._%i>~~+|ii| .i| ._s_ass,,. ._a%ssssssss
|
|
-SXZ6,,. )XZX: =l> _li+~` iii| .ii _uZZXX??YZ#Za, uXUX*?!!!!!!!
|
|
"!XZ#ZZZZZXZXZ` <i> =i: .|ii| .l|.dZXr 4XXo.XXXs,.
|
|
-~^^^^^^^` -||, +i|=. |ii| :i>:ZXZ( ]XZX.-"SXZUZUXoa,,
|
|
+l|, ~~|++|++i|||+~:ZXZ( ]ZZX ---~"?Z#m
|
|
.__;=- ~+l|=____.___, :ZXZ( ]ZXX_________auXX2
|
|
._||>+~- . -~+~++~~~- :ZXZ( ]ZXZZ#######UX*!"
|
|
-+-- .>` _
|
|
.<}` 3;
|
|
.<l> .Zc
|
|
.ii^ )Xo
|
|
]XX
|
|
|
|
MoinMoin - Formulaire d'inscription
|
|
|
|
Un formulaire de préinscription au Crans
|
|
|
|
Copyright 2009 Antoine Durand-Gasselin <adg@crans.org>
|
|
|
|
License: GPLv3
|
|
"""
|
|
|
|
import re, locale, base64, sys, unicodedata
|
|
from commands import getstatusoutput as gso
|
|
sys.path.append("/usr/scripts/gestion")
|
|
from iptools import AddrInNet
|
|
from MoinMoin import wikiutil
|
|
from MoinMoin.widget import html
|
|
from MoinMoin.Page import Page
|
|
from MoinMoin.PageEditor import PageEditor
|
|
from MoinMoin.formatter.text_html import Formatter
|
|
|
|
class Field():
|
|
"""Une classe pour représenter les champs
|
|
|
|
Attention, elle ne permet que de rendre les champs en html, et
|
|
permet d'effectuer des tests unitaires"""
|
|
|
|
error_txt=''
|
|
error_msg=''
|
|
error_field=''
|
|
|
|
def __init__(self, id, prompt, default = "", input_type = "text", check=None):
|
|
self.id = id
|
|
self.prompt = html.Text(prompt)
|
|
self.default = default
|
|
self.input_type = input_type
|
|
if check != None: self.check_hook = check
|
|
else: self.check_hook = (lambda x: True)
|
|
|
|
def fill(self, string):
|
|
self.input = string[0]
|
|
|
|
def check(self):
|
|
self.error_txt= '' # Devrait pourtant être déjà vide
|
|
|
|
self.default = self.input
|
|
ok = self.check_hook(self)
|
|
|
|
if ok:
|
|
self.content = self.__dict__.get('content', self.input) # des fois qu'on ait oublié de le faire
|
|
if self.content != self.default and self.default == self.input:
|
|
self.default = self.content
|
|
|
|
if not self.error_txt and not ok:
|
|
self.error_txt = u'Valeur %s incorrecte pour le champ %s.' % (self.input, self.id)
|
|
return ok
|
|
|
|
def render(self, request, parser):
|
|
champ = html.UL(CLASS="formulaire_field")
|
|
champ.append(html.LI(CLASS="formulaire_id").append(self.prompt))
|
|
|
|
input = html.INPUT(type=self.input_type,name=self.id,value=self.default)
|
|
champ.append(html.LI(CLASS="formulaire_input").append(input))
|
|
|
|
if self.error_txt:
|
|
error = wikiutil.renderText(request, parser, self.error_txt)
|
|
champ.append(html.LI(CLASS="formulaire_error").append(error))
|
|
|
|
if self.error_msg:
|
|
request.add_msg(self.error_msg)
|
|
return champ
|
|
|
|
def is_name(self):
|
|
"""Vérifie que le champ input de l'objet passé en argument est un nom valide."""
|
|
analysed_content = unicodedata.normalize('NFKD', self.input)
|
|
try: stripped_content = analysed_content.encode('ASCII', 'ignore')
|
|
except UnicodeEncodeError: stripped_content = '<ugly utf-8>'
|
|
if re.match('[a-z][-a-z _]*', stripped_content.lower()):
|
|
return True
|
|
else:
|
|
self.error_txt = u"""Valeur %s incorrecte pour le champ %s.
|
|
Seules les lettres (éventuellement accentuées),
|
|
l'espace et le tiret '-' sont acceptés.""" % (self.input, self.id)
|
|
return False
|
|
|
|
def is_phonenumber(self):
|
|
chiffres = self.input.replace('.', '')
|
|
if re.match('(0|\+[0-9][0-9])[0-9]{9}', chiffres):
|
|
return True
|
|
else:
|
|
self.content = ''
|
|
return True
|
|
|
|
def is_dns(self):
|
|
dns = self.input.lower()
|
|
if re.match('[a-z][-a-z0-9_]*', dns):
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def get_mac(ip):
|
|
"Récupère la mac"
|
|
mac= 'XX' + ':XX'*5
|
|
if AddrInNet(ip, '138.231.136.0/21'):
|
|
status, mac = gso("/usr/sbin/arp %s | perl -nle '{print $& if /00(:[0-9a-f]{2}){5}/}'" % ip) # gruik, gruik, grUUIIIk !
|
|
mac= mac.strip()
|
|
return mac
|
|
|
|
def is_valid_mac(self):
|
|
mac = self.input.lower()
|
|
if re.search("00((:|-|)[a-f0-9][a-f0-9]){5}", mac):
|
|
return True
|
|
else:
|
|
self.default = get_mac(self.ip)
|
|
return False
|
|
|
|
class FormulaireInscription():
|
|
"""Une classe qui représente le formulaire d'inscription
|
|
|
|
Elle contient un champs ``champs'', qui contient une liste de
|
|
Fields, qui est la liste des champs qui doivent être demandés (dans
|
|
le bon ordre l'ordre).
|
|
"""
|
|
def __init__(self, request):
|
|
|
|
ip = request.remote_addr
|
|
|
|
def erase_password(self):
|
|
self.default = ''
|
|
return True
|
|
|
|
pass2_field = Field("pass2", u"Mot de passe", input_type='password', check=erase_password)
|
|
|
|
def is_correctpassword(self):
|
|
self.default = ''
|
|
if pass2_field.input == self.input:
|
|
return True
|
|
else:
|
|
self.error_txt=u'Attention les mots de passe diffèrent'
|
|
return False
|
|
|
|
mac_field = Field("mac", u"Adresse physique de votre carte réseau", check=is_valid_mac, default=get_mac(ip))
|
|
mac_field.ip = ip
|
|
|
|
self.champs = [ Field("nom", "Nom", check=is_name),
|
|
Field("prenom", u"Prénom", check=is_name),
|
|
Field("tel", u"Numéro de téléphone", check=is_phonenumber),
|
|
Field("pass1", u"Mot de passe", input_type='password', check=is_correctpassword),
|
|
pass2_field,
|
|
Field("dns", u"Nom de votre ordinateur", check=is_dns),
|
|
mac_field
|
|
]
|
|
|
|
|
|
def _create_form(request, parser, formulaire):
|
|
url = request.page.url(request)
|
|
ret = html.FORM(action=url)
|
|
ret.append(html.INPUT(type='hidden', name='action', value='inscription'))
|
|
|
|
f = html.UL(CLASS="formulaire_preinscription")
|
|
|
|
for field in formulaire.champs:
|
|
champ = field.render(request, parser)
|
|
f.append(html.LI().append(champ))
|
|
|
|
ret.append(f)
|
|
ret.append(html.HR(CLASS= "invisiblesep"))
|
|
ret.append(html.INPUT(type="submit", name="inscrire", value=u"Me préinscrire"))
|
|
|
|
return unicode(ret)
|
|
|
|
def _check_form(post, formulaire):
|
|
u"""Vérifie les paramètres postés par l'utilisateur.
|
|
|
|
Vérifie que toutes les entrées du formulaire (formulaire.fields)
|
|
sont présentes et bien valides, (en appelant check() pour chaque
|
|
champs).
|
|
"""
|
|
errors = []
|
|
for field in formulaire.champs:
|
|
field.fill(post.get(field.id, ''))
|
|
for field in formulaire.champs:
|
|
if not field.check():
|
|
errors.append(field.id)
|
|
return errors
|
|
|
|
def _perform_inscription(request, formulaire):
|
|
request.emit_http_headers(more_headers = ['Content-Type: text/plain'])
|
|
results = ''
|
|
for field in formulaire.champs:
|
|
results += '%(id)s: %(content)s\n' % field.__dict__
|
|
request.write(results)
|
|
|
|
|
|
def execute(pagename, request):
|
|
request.page = Page(request, pagename)
|
|
request.formatter.setPage(request.page)
|
|
request.loadTheme('crans-www')
|
|
formulaire = FormulaireInscription(request)
|
|
post = request.form
|
|
parser = wikiutil.searchAndImportPlugin(request.cfg, "parser", request.page.pi['format'])
|
|
if not request.dicts.has_member("GroupeAdmin", request.user.name) and not request.user == 'AntoineDurandGasselin':
|
|
request.theme.add_msg(u"Non, car tu es méchant", "error")
|
|
return(page.send_page())
|
|
|
|
if post.has_key('inscrire'):
|
|
if _check_form(post, formulaire) == []:
|
|
return(_perform_inscription(request, formulaire))
|
|
|
|
request.emit_http_headers()
|
|
request.theme.send_title(u"Formulaire de préinscription", pagename=pagename)
|
|
request.write(request.formatter.startContent("content"))
|
|
|
|
form = _create_form(request, parser, formulaire)
|
|
# THIS IS A BIG HACK. IT NEEDS TO BE CLEANED UP
|
|
request.write(form)
|
|
request.write(request.formatter.endContent())
|
|
request.theme.send_footer(pagename)
|
|
request.theme.send_closing_html()
|
|
|