1657 lines
50 KiB
Python
Executable file
1657 lines
50 KiB
Python
Executable file
#! /usr/bin/env python
|
|
# -*- coding: iso-8859-15 -*-
|
|
|
|
"""
|
|
Interface utilisateur du système de gestion des machines
|
|
et adhérents du crans
|
|
|
|
Copyright (C) Frédéric Pauget
|
|
Licence : GPLv2
|
|
|
|
Les fonctions set_* permettent de définir certains
|
|
paramètres liés à un adhérent ou une machine, elles posent les questions
|
|
puis apellent la méthode adpatée de la classe adhérent ou machine.
|
|
Elles prennent toute une instances de cette classe en paramètre.
|
|
Elles retournent 1 si l'action à échoué et None si OK.
|
|
Les fonction select permettent de choisir un objet dans la base
|
|
Retournent None si pas d'objet trouvé.
|
|
"""
|
|
|
|
### Rapport de bug automatique
|
|
# Destinataires, si vide n'envoi rien
|
|
To = 'fred@crans.org'
|
|
|
|
import string, os, sys
|
|
from whos import aff
|
|
import time, signal, getopt
|
|
|
|
import affich_tools, config
|
|
from lock import make_lock, remove_lock
|
|
from ldap_crans import adherent, machine, crans_ldap, crans, club, blacklist_items, isadm, isdeconnecteur, ann_scol, droits_possibles, smtpserv, script_utilisateur
|
|
|
|
def dialog(arg) :
|
|
return affich_tools.dialog(u'Gestion des adhérents et machines du Crans',arg)
|
|
|
|
#########################################################################
|
|
## Fonctions de remplissage ou modification des paramètres d'un adhérent
|
|
|
|
def set_bases(adher) :
|
|
"""
|
|
Définition des paramètres de bases d'un adhérent :
|
|
* Nom
|
|
* Prenom
|
|
* Téléphone
|
|
* Chambre
|
|
"""
|
|
|
|
# Construction de la boite de dialogue
|
|
arg = u'--title "Inscription adhérent" '
|
|
arg+= u'--form "" 0 0 0 '
|
|
arg+= u'"Nom :" 1 1 "%s" 1 13 20 20 ' % adher.nom()
|
|
arg+= u'"Prénom :" 2 1 "%s" 2 13 20 20 ' % adher.prenom()
|
|
arg+= u'"Numéro de téléphone :" 3 1 "%s" 3 23 15 00 ' % adher.tel()
|
|
arg+= u'"Chambre :" 4 1 "%s" 4 11 05 00 ' % adher.chbre()
|
|
arg+= u'"(bat+numéro)" 4 17 "" 0 0 0 0 '
|
|
arg+= u'"EXT pour chambre extérieure au campus" 5 1 "" 0 0 0 0 '
|
|
|
|
# Affichage
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
|
|
# Traitement
|
|
err = ''
|
|
try : adher.nom(result[0])
|
|
except ValueError, c : err += c.args[0] + '\n'
|
|
|
|
try : adher.prenom(result[1])
|
|
except ValueError, c : err += c.args[0] + '\n'
|
|
|
|
try : adher.tel(result[2])
|
|
except ValueError, c : err += c.args[0] + '\n'
|
|
|
|
err += _set_chbre(adher,result[3])
|
|
|
|
# Des erreurs ?
|
|
if err :
|
|
arg = u'--title "Inscription adhérent" '
|
|
arg+= u'--msgbox "%s\n\n" 0 0' % err
|
|
dialog(arg)
|
|
# On redemande
|
|
return set_bases(adher)
|
|
|
|
if adher.chbre() =='EXT' :
|
|
# Il faut demander l'adresse extérieure
|
|
if set_addr_ext(adher) :
|
|
# Annulation
|
|
return set_bases(adher)
|
|
|
|
def _set_chbre(adher,chbre) :
|
|
""" Attribution de la chambre chbre à l'adhérent fourni
|
|
Retourne une chaine (unicode) avec l'erreur éventuelle
|
|
"""
|
|
if chbre=='????' :
|
|
# Réservé à un usage interne
|
|
return u'Chambre invalide\n'
|
|
|
|
try : c = adher.chbre(chbre)
|
|
except EnvironmentError, c : return c.args[0] + '\n'
|
|
except ValueError, c :
|
|
try :
|
|
squatteur = c.args[1]
|
|
aff(squatteur)
|
|
arg = u'--title "Inscription adhérent" '
|
|
arg+= u'--yesno "Un adhérent (%s) occupe déjà cette chambre.\n' % squatteur.Nom()
|
|
arg+= u'\nChanger la chambre de cet adhérent ?" 0 0'
|
|
no, res = dialog(arg)
|
|
if no : raise # On laisse l'erreur
|
|
squatteur.chbre('????')
|
|
squatteur.save()
|
|
return _set_chbre(adher,chbre) # On recommence, le géneur doit être parti.
|
|
except :
|
|
return c.args[0] + '\n'
|
|
|
|
return u''
|
|
|
|
def set_addr_ext(adher) :
|
|
""" Définition de l'adresse extérieure d'un adhérent
|
|
La chambre de cet adhérent doit être EXT, sinon erreur """
|
|
arg = u'--title "Adresse extérieure de %s" ' % adher.Nom()
|
|
arg+= u'--form "" 0 0 0 '
|
|
arg+= u'"" 1 1 "%s" 1 1 46 50 ' % adher.adresse()[0]
|
|
arg+= u'"" 2 1 "%s" 2 1 46 50 ' % adher.adresse()[1]
|
|
arg+= u'"Code postal :" 3 1 "%s" 3 15 5 0 ' % adher.adresse()[2]
|
|
arg+= u'"Ville :" 3 21 "%s" 3 30 17 30 ' % adher.adresse()[3]
|
|
# Affichage
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
|
|
try : adher.adresse(result)
|
|
except ValueError, c :
|
|
arg = u'--title "Adresse extérieure de %s" ' % adher.Nom()
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
|
dialog(arg)
|
|
# On redemande
|
|
return set_addr_ext(adher)
|
|
|
|
def set_etudes(adher) :
|
|
"""
|
|
Définition des études en 3 questions :
|
|
* établissement
|
|
* année administrative
|
|
* section/labo
|
|
"""
|
|
|
|
def __etudes_etab() :
|
|
arg = u'--title "Etudes de %s (1/3)" ' % adher.Nom()
|
|
if adher.etudes(0) :
|
|
arg+= u'--default-item "%s" ' % adher.etudes(0)
|
|
arg+= u'--menu "Choisissez l\'établissement : " 0 0 0 '
|
|
if adher.etudes(0) :
|
|
arg+= u'"Autre" "" '
|
|
arg+= u'"ENS" "" '
|
|
arg+= u'"IUT Cachan" "" '
|
|
arg+= u'"Maximilien Sorre" "" '
|
|
arg+= u'"Gustave Eiffel" "" '
|
|
arg+= u'"P1" "Université Panthéon Sorbonne" '
|
|
arg+= u'"P2" "Université Panthéon Assas" '
|
|
arg+= u'"P3" "Université de la Sorbonne Nouvelle" '
|
|
arg+= u'"P4" "Université Paris Sorbonne" '
|
|
arg+= u'"P5" "Université René Descartes" '
|
|
arg+= u'"P6" "Université Pierre et Marie Curie" '
|
|
arg+= u'"P7" "Université Denis Diderot" '
|
|
arg+= u'"P8" "Université Vincennes Saint Denis" '
|
|
arg+= u'"P9" "Université Paris Dauphine" '
|
|
arg+= u'"P10" "Université de Nanterre" '
|
|
arg+= u'"P11" "Université de Paris Sud (Orsay)" '
|
|
arg+= u'"P12" "Université Val de Marne" '
|
|
arg+= u'"P13" "Université Paris Nord" '
|
|
arg+= u'"IUFM" "" '
|
|
if not adher.etudes(0) :
|
|
arg+= u'"Autre" ""'
|
|
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
|
|
if result[0] == 'Autre' :
|
|
arg = u'--title "Etudes de %s (1/3)" ' % adher.Nom()
|
|
arg+= u'--inputbox "Précisez l\'établissement d\'études" 0 0 "%s"' % adher.etudes(0)
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
if result==[''] :
|
|
# Pas bon
|
|
arg = u'--title "Etudes (2/3)" '
|
|
arg+= u'--msgbox "Réponse invalide\n\n\n" 0 0'
|
|
dialog(arg)
|
|
return __etudes_etab()
|
|
|
|
etudes[0] = result[0]
|
|
|
|
def __etudes_annee() :
|
|
arg = u'--title "Etudes de %s (2/3)" ' % adher.Nom()
|
|
if etudes[0]=='ENS' :
|
|
arg+= u'--default-item "%s" ' % adher.etudes(1)
|
|
arg+= u'--menu "Choisissez l\'année administrative" 0 0 0 '
|
|
arg+= u'"1" "1ère année" '
|
|
arg+= u'"2" "2ème année" '
|
|
arg+= u'"3" "3ème année, agrégation" '
|
|
arg+= u'"4" "DEA" '
|
|
arg+= u'"5" "1ère année thèse" '
|
|
arg+= u'"6" "2ème année thèse" '
|
|
arg+= u'"7" "3ème année thèse" '
|
|
arg+= u'"Autre" ""'
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
elif etudes[0] in [ 'P1','P2','P3','P4','P5','P6','P7','P8','P9','P10','P11','P12','P13' ] :
|
|
arg+= u'--default-item "%s" ' % adher.etudes(1)
|
|
arg+= u'--menu "Choisissez l\'année administrative" 0 0 0 '
|
|
arg+= u'"Deug 1" "Deug 1ère année" '
|
|
arg+= u'"Deug 2" "Deug 2ème année" '
|
|
arg+= u'"License" "" '
|
|
arg+= u'"Master 1" "Master 1ère année" '
|
|
arg+= u'"Master 2" "Master 2ème année" '
|
|
arg+= u'"Thèse 1" "1ème année thèse" '
|
|
arg+= u'"Thèse 2" "2ème année thèse" '
|
|
arg+= u'"Thèse 3" "3ème année thèse" '
|
|
arg+= u'"Autre" ""'
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
else :
|
|
result=['Autre']
|
|
|
|
if result[0] == 'Autre' :
|
|
arg = u'--title "Etudes de %s (2/3)" ' % adher.Nom()
|
|
arg+= u'--inputbox "Année adminstrative :\nET UNIQUEMENT l\'ANNEE : la section sera demandée après." 0 0 "%s"' % adher.etudes(1)
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
if result==[''] :
|
|
# Pas bon
|
|
arg = u'--title "Etudes (2/3)" '
|
|
arg+= u'--msgbox "Réponse invalide\n\n\n" 0 0'
|
|
dialog(arg)
|
|
return __etudes_annee()
|
|
else :
|
|
result[0] += '_'
|
|
|
|
etudes[1] = result[0]
|
|
|
|
def __etudes_section() :
|
|
arg = u'--title "Etudes de %s (3/3)" ' % adher.Nom()
|
|
|
|
# Pour l'ENS
|
|
if etudes[0]=='ENS' :
|
|
arg+= u'--default-item "%s" ' % adher.etudes(2)
|
|
if etudes[1] in '1234' :
|
|
arg+= u'--menu "Choisissez la section : " 0 0 0 '
|
|
arg+= u'"A1" "Mathématiques" '
|
|
arg+= u'"A\'1" "Informatique" '
|
|
arg+= u'"A2" "Physique fondamentale" '
|
|
arg+= u'"A\'2" "Physique appliquée" '
|
|
arg+= u'"A\'\'2" "Chimie" '
|
|
arg+= u'"A3" "Biochimie" '
|
|
if etudes[1] == '1' :
|
|
arg+= u'"B123" "Technologie mécanique" '
|
|
else :
|
|
arg+= u'"B1" "Mécanique" '
|
|
arg+= u'"B2" "Génie civil" '
|
|
arg+= u'"B3" "Génie mécanique" '
|
|
arg+= u'"B4" "Génie électrique" '
|
|
arg+= u'"C" "Art et création industrielle" '
|
|
arg+= u'"D2" "Economie gestion" '
|
|
arg+= u'"D3" "Sciences sociales" '
|
|
arg+= u'"E" "Anglais" '
|
|
else :
|
|
arg+= u'--menu "Choisissez le laboratoire :" 0 0 0 '
|
|
arg+= u'"CMLA" "Centre de Mathématiques et de Leurs Applications" '
|
|
arg+= u'"GAPP" "Groupe d\'Analyse des Politiques Publiques" '
|
|
arg+= u'"IDHE" "Institutions et Dynamiques Historiques de l\'Economie" '
|
|
arg+= u'"LBPA" "Laboratoire de Biotechnologies et Pharmacologie génétique Appliquées" '
|
|
arg+= u'"LMT" "Laboratoire de Mécanique et Technologie" '
|
|
arg+= u'"LPQM" "Laboratoire de Photonique Quantique et Moléculaire" '
|
|
arg+= u'"LSV" "Laboratoire de Spécification et Vérification" '
|
|
arg+= u'"LURPA" "Laboratoire Universitaire de Recherche en Production Automatisée" '
|
|
arg+= u'"PPSM" "Laboratoire de Photophysique et Photochimie Supramoléculaires et Macromoléculaires" '
|
|
arg+= u'"SATIE" "Systèmes et Applications des Technologies de l\'Information et de l\'Energie" '
|
|
arg+= u'"STEF" "Sciences Techniques Education Formation" '
|
|
|
|
arg+= u'"Autre" ""'
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
if result==[''] :
|
|
# Pas bon
|
|
arg = u'--title "Etudes (2/3)" '
|
|
arg+= u'--msgbox "Réponse invalide\n\n\n" 0 0'
|
|
dialog(arg)
|
|
return __etudes_annee()
|
|
|
|
else :
|
|
result=['Autre']
|
|
|
|
if result[0] == 'Autre' :
|
|
arg = u'--title "Etudes de %s (3/3)" ' % adher.Nom()
|
|
arg+= u'--inputbox "Section : " 0 0 "%s"' % adher.etudes(2)
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
if result==[''] :
|
|
# Pas bon
|
|
arg = u'--title "Etudes (3/3)" '
|
|
arg+= u'--msgbox "Réponse invalide\n\n\n" 0 0'
|
|
dialog(arg)
|
|
return __etudes_section()
|
|
|
|
etudes[2] = result[0]
|
|
|
|
etudes=['','','']
|
|
|
|
step = 1
|
|
while 1 :
|
|
if step == 1 :
|
|
if __etudes_etab() : return 1
|
|
else : step +=1
|
|
if step == 2 :
|
|
if __etudes_annee() : step -= 1
|
|
else : step +=1
|
|
if step ==3 :
|
|
if __etudes_section(): step -=1
|
|
else : break
|
|
|
|
try :
|
|
adher.etudes(etudes)
|
|
except ValueError, c :
|
|
arg = u'--title "Etudes de %s" ' % adher.Nom()
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
|
dialog(arg)
|
|
return set_etudes(adher)
|
|
|
|
def set_mail(adher) :
|
|
"""
|
|
Choix d'une adresse mail crans ou extérieure.
|
|
Retourne ensuite le résultat de :
|
|
* set_mail_ext si adresse ext
|
|
* set_compte si compte crans
|
|
"""
|
|
if u'Nounou' in adher.droits() and not isadm :
|
|
arg = u'--title "Adresse mail de %s" ' % adher.Nom()
|
|
arg+= u'--msgbox "Vous n\'avez pas les droits necessaires pour effectuer cette opération.\n\n\n" 0 0'
|
|
dialog(arg)
|
|
return
|
|
|
|
while 1 :
|
|
arg = u'--title "Adresse mail de %s" ' % adher.Nom()
|
|
arg+= u'--menu "Adresse mail de l\'adhérent :" 0 0 0 '
|
|
arg+= u'"Adresse mail extérieure" "" '
|
|
if adher.compte() :
|
|
arg+= u'"Laisser le compte sur zamok" "(login : %s)"' % adher.compte()
|
|
else :
|
|
arg+= u'"Créer un compte sur zamok" "(adresse @crans.org)"'
|
|
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
|
|
if result[0].split()[0]=='Laisser' :
|
|
break
|
|
elif result[0].split()[0]=='Créer' :
|
|
if not set_compte(adher) : break
|
|
else :
|
|
if not set_mail_ext(adher) : break
|
|
|
|
def set_mail_ext(adher) :
|
|
"""
|
|
Demande l'adresse mail extérieure d'un adhérent
|
|
"""
|
|
default = adher.mail()
|
|
if default.find('@')==-1 :
|
|
# C'était une adresse crans
|
|
default = ''
|
|
|
|
arg = u'--title "Adresse mail extérieure pour %s" ' % adher.Nom()
|
|
arg+= u'--inputbox "Adresse : " 0 0 "%s"' % default
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
|
|
try : adher.mail(result[0])
|
|
except ValueError, c :
|
|
arg = u'--title "Adresse mail extérieure de %s" ' % adher.Nom()
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
|
dialog(arg)
|
|
return set_mail_ext(adher)
|
|
|
|
def set_compte(adher) :
|
|
"""
|
|
Créé un compte sur zamok pour un adhérent.
|
|
"""
|
|
# Message d'avertissement
|
|
arg = u'--title "Création compte sur zamok pour %s" ' % adher.Nom()
|
|
arg+= u'--colors --yesno "\Zr\Z1AVERTISSEMENT :\Zn \n'
|
|
arg+= u'L\'adhérent devra impérativement consulter l\'adresse mail associée\n\n\n\\ZnContinuer ?" '
|
|
arg+= u'0 0'
|
|
no, res = dialog(arg)
|
|
if no : return 1
|
|
|
|
# Il faut déterminer le login
|
|
login = adher.nom()
|
|
|
|
# Première tentative
|
|
err = 0
|
|
try : login = adher.compte(login)
|
|
except ValueError, c :
|
|
try :
|
|
c.args[1]
|
|
# Le compte existe => 2ème tentative (1ere lettre prénom + nom)
|
|
login = adher.prenom()[0]+login
|
|
login = login.lower()
|
|
err =2
|
|
except :
|
|
err = 1
|
|
except EnvironmentError, c : err = 1 # Locké
|
|
|
|
if err :
|
|
while 1:
|
|
# Mauvais login => on demande
|
|
arg = u'--title "Création d\'un compte sur zamok pour %s" ' % adher.Nom()
|
|
arg+= u'--inputbox "Choix du login\n'
|
|
arg+= u'Le login doit faire au maximum %s caractères\n' % config.maxlen_login
|
|
arg+= u'Il ne doit pas être un pseudo ou prénom mais doit être relié au nom de famille\n'
|
|
arg+= u'Seuls les caractères alphabétiques et le - sont autorisés" '
|
|
arg+= u'0 0 "%s"' % login
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
login=result[0]
|
|
|
|
e = 0
|
|
try : login = adher.compte(login)
|
|
except EnvironmentError, c : e = c.args[0]
|
|
except ValueError, c : e = c.args[0]
|
|
if e :
|
|
arg = u'--title "Création compte sur zamok pour %s" ' % adher.Nom()
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % e
|
|
dialog(arg)
|
|
continue
|
|
break
|
|
|
|
txt = u"Le compte ne sera créé que lors de l'enregistrement des données\n\n"
|
|
txt+= u"L'adresse mail de l'adhérent est : %s@crans.org\n" % login
|
|
|
|
a = adher.cannonical_alias()
|
|
if a :
|
|
txt+= u"L'adhérent possède également l'alias : %s@crans.org" % a
|
|
else :
|
|
txt+= u"\n\Zr\Z1L'adresse mail %s.%s@crans.org étant déja prise l'adhérent ne peux pas l'utiliser.\Zn" % ( adher.prenom(), adher.nom() )
|
|
|
|
txt+= u'\n'
|
|
|
|
arg = u'--title "Création compte sur zamok pour %s" ' % adher.Nom()
|
|
arg+= u'--colors --msgbox "%s\n\n\n" 0 0' % txt
|
|
dialog(arg)
|
|
|
|
def set_droits(adher) :
|
|
""" Définition des droits de l'adhérent """
|
|
arg = u'--title "Droits de %s" ' % adher.Nom()
|
|
arg+= u'--separate-output '
|
|
arg+= u'--checklist "" 0 0 0 '
|
|
|
|
droits = adher.droits()
|
|
for key in droits_possibles :
|
|
actif = key in droits
|
|
if actif : actif = u'on'
|
|
arg+= u'"%s" " " "%s" ' % ( key , actif)
|
|
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
|
|
# Traitement
|
|
adher.droits(result)
|
|
|
|
def del_adher(adher) :
|
|
"""
|
|
Destruction adhérent
|
|
"""
|
|
quoi = u'Toutes les machines associées à cet adhérent seront détruites'
|
|
if adher.mail().find('@')==-1 :
|
|
# L'adhérent a un compte
|
|
machines = adher.machines()
|
|
if not machines :
|
|
quoi = u'Le compte de cet adhérent sera détruit'
|
|
else :
|
|
# Et aussi des machines
|
|
# -> soit on détruit tout
|
|
# -> soit on garde le compte mais on vire les machines
|
|
arg = u'--title "Destruction adhérent %s " ' % adher.Nom()
|
|
arg+= u'--menu "Cette adhérent possède également un compte." 0 0 0 '
|
|
if adher :
|
|
arg+= u'"1" "Détruire seulement les machines de l\'adhérent" '
|
|
arg+= u'"2" "Détruire les machines et le compte de l\'adhérent" '
|
|
annul, res = dialog(arg)
|
|
if annul : return 1
|
|
if res[0]=='2' :
|
|
# On détruit tout
|
|
quoi += u' ainsi que son compte'
|
|
else :
|
|
# Destruction uniquement des machines
|
|
arg = u'--title "Destruction machines adhérent %s " --colors ' % adher.Nom()
|
|
arg+= u'--inputbox "\Zr\Z1ATTENTION\Zn : la destruction est définitive\nToutes les machines associées à cet adhérent seront détruites, seul le compte sera conservé.\nCommentaire à insérer ?" 0 0'
|
|
annul, res = dialog(arg)
|
|
if annul : return 1
|
|
for m in machines :
|
|
m.delete(res[0])
|
|
adher.chbre('EXT')
|
|
arg = u'--title "Destruction machines" '
|
|
arg+= u'--msgbox "Machines détruites\n\n\n" 0 0'
|
|
dialog(arg)
|
|
return
|
|
|
|
while 1 :
|
|
arg = u'--title "Destruction adhérent %s " --colors ' % adher.Nom()
|
|
arg+= u'--inputbox "\Zr\Z1ATTENTION\Zn : la destruction est définitive\n\n%s.\n\nCommentaire à insérer ?" 0 0' % quoi
|
|
annul, res = dialog(arg)
|
|
if annul : return 1
|
|
if res[0] : break
|
|
arg = u'--title "Destruction adherent" '
|
|
arg+= u'--msgbox "Le commentaire est obligatoire\n\n\n" 0 0'
|
|
dialog(arg)
|
|
|
|
if u'Nounou' in adher.droits() and not isadm :
|
|
arg = u'--title "Destruction adherent" '
|
|
arg+= u'--msgbox "Vous n\'avez pas les droits necessaires pour effectuer cette opération.\n\n\n" 0 0'
|
|
dialog(arg)
|
|
return
|
|
|
|
adher.delete(res[0])
|
|
|
|
arg = u'--title "Destruction adhérent" '
|
|
arg+= u'--msgbox "Adhérent détruit\n\n\n" 0 0'
|
|
dialog(arg)
|
|
|
|
|
|
######################################################################################
|
|
## Fonctions de remplissage ou modification des paramètres adhérent ou machine ou club
|
|
## (suivant la classe fournie)
|
|
|
|
def set_rque(clas) :
|
|
"""Définit le commentaire (méthode info de clas)"""
|
|
return __prompt_input_menu(clas.info,u'Remarque',u"Ajouter ou modifier une remarque\nPour ajouter une remarque modifier la dernière de la liste.")
|
|
|
|
def __prompt_input_menu(method,titre,prompt) :
|
|
arg = u'--title "%s" ' % titre
|
|
arg+= u'--extra-label "Ajout/modif" '
|
|
arg+= u'--inputmenu "%s\nPour supprimer, laisser le champ vide." 0 100 7 ' % prompt
|
|
invite = '##nouveau##'
|
|
|
|
i=1
|
|
for item in method() :
|
|
if item=='' : continue
|
|
arg+= u'"%d" "%s" '% (i, item)
|
|
i+= 1
|
|
arg += '"%d" "%s" '% (i, invite)
|
|
|
|
annul , result = dialog(arg)
|
|
if annul :
|
|
return 1
|
|
|
|
# si modif alors result=[ 'RENAMED X nouvelle remarque' ]
|
|
result = result[0].split(' ', 2)
|
|
if result[0]!='RENAMED' :
|
|
# Pas de modif
|
|
return
|
|
|
|
# maintenant result=['RENAMED', 'X', 'nouvelle remarque']
|
|
num = int(result[1])
|
|
val = result[2].strip()
|
|
|
|
if val == invite :
|
|
# Rien à faire
|
|
return
|
|
|
|
try:
|
|
if num==i :
|
|
# Nouvelle valeur
|
|
if val : method(val)
|
|
else :
|
|
method([num-1,val])
|
|
|
|
except ValueError, c :
|
|
arg = u'--title "%s" ' % titre
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
|
dialog(arg)
|
|
return __prompt_input_menu(method,titre,prompt)
|
|
|
|
def confirm(clas) :
|
|
""" Demande confirmation avant enregistrement"""
|
|
# On va faire en texte, les couleurs ne passent pas en curses
|
|
os.system('clear')
|
|
aff(clas)
|
|
while 1 :
|
|
r = affich_tools.prompt("Valider et enregister ? [O/N]")
|
|
if r=='O' or r=='o' :
|
|
break
|
|
elif r=='N' or r=='n' :
|
|
return 1
|
|
try :
|
|
res = clas.save()
|
|
except RuntimeError, c :
|
|
arg = u'--title "Enregistrement" '
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
|
dialog(arg)
|
|
return 1
|
|
|
|
print res
|
|
affich_tools.prompt("Appuyez sur ENTREE pour continuer")
|
|
|
|
def set_blackliste(clas) :
|
|
""" Edite ou ajoute un item de la blackliste """
|
|
bl = clas.blacklist()
|
|
if not bl :
|
|
# Pas d'entrée à éditer
|
|
index = -1
|
|
else :
|
|
arg = u'--title "Edition blackliste de %s" ' % clas.Nom()
|
|
arg+= u'--menu "Choisir l\'entrée à éditer :" 0 0 0 '
|
|
arg+= u'"0" "Ajouter une nouvelle entrée" '
|
|
i = 1
|
|
for b in bl :
|
|
arg += '"%i" "%s" ' % (i, b)
|
|
i += 1
|
|
annul , res = dialog(arg)
|
|
if annul : return 1
|
|
index = int(res[0]) - 1
|
|
|
|
# Edition
|
|
if index != -1 :
|
|
t = clas.blacklist()[index].split(',')
|
|
else :
|
|
t = [ 'now' , '-', '', '' ]
|
|
|
|
step = 1
|
|
while 1 :
|
|
if step == 1 :
|
|
# Sanction
|
|
arg = u'--title "Blacklistage %s" ' % clas.Nom()
|
|
arg+= u'--default-item "%s" ' % t[2]
|
|
arg+= u'--menu "Choisir la sanction :" 0 0 0 '
|
|
for n, c in blacklist_items.items() :
|
|
arg+= u'"%s" "%s" ' % (n, c)
|
|
annul , res = dialog(arg)
|
|
if annul : return 1
|
|
t[2] = res[0]
|
|
step += 1
|
|
|
|
if step == 2 :
|
|
# Dates + commentaire
|
|
arg = u'--title "Blacklistage %s" ' % clas.Nom()
|
|
arg+= u'--form "Entrez les dates de début et de fin (format jj/mm/aaaa) ainsi que le commentaire associé\n" 0 0 0 '
|
|
arg+= u'"Début : " 1 1 "%s" 1 8 10 0 ' % t[0]
|
|
arg+= u'"now pour immédiatement " 1 20 "" 0 0 0 0 '
|
|
arg+= u'"Fin : " 2 1 "%s" 2 8 10 0 ' % t[1]
|
|
arg+= u'"- pour fin indéterminée" 2 20 "" 0 0 0 0 '
|
|
arg+= u'"Les jours de début et de fin sont inclus." 3 1 "" 0 0 0 0 '
|
|
arg+= u'"Sanction : %s" 4 1 "" 0 0 0 0 ' % t[2]
|
|
arg+= u'"Commentaire : (le login sera automatiquement ajouté)" 5 1 "%s" 6 1 52 0 ' % t[3]
|
|
annul , r = dialog(arg)
|
|
if annul : return 1
|
|
|
|
# Ajout des heures
|
|
t[0] = r[0].strip()
|
|
if len(t[0]) == 10 : t[0] += ' 00:00'
|
|
t[1] = r[1].strip()
|
|
if len(t[1]) == 10 : t[1] += ' 23:59'
|
|
|
|
# Commentaire
|
|
c = r[2].strip()
|
|
login = script_utilisateur
|
|
if c.split(' :')[0] != login :
|
|
t[3] = login + ' : ' + c
|
|
|
|
try :
|
|
if index == -1 :
|
|
clas.blacklist(t)
|
|
else :
|
|
clas.blacklist( ( index, t ) )
|
|
step += 1
|
|
except ValueError, c :
|
|
arg = u'--title "Erreur" '
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
|
dialog(arg)
|
|
step -= 1
|
|
|
|
if step == 3 :
|
|
if confirm(clas) : step -= 1
|
|
else : break
|
|
|
|
##########################################################################
|
|
## Fonction de remplissage ou modification des paramètres club ou adhérent
|
|
|
|
def set_admin(proprio) :
|
|
"""
|
|
Définition de l'état administratif : carte d'étudiant et paiement
|
|
"""
|
|
# Le proprietaire a t-il une section carte d'étudiant ?
|
|
if proprio.idn != 'cid' :
|
|
card = 1
|
|
else :
|
|
card = 0
|
|
|
|
# Initialisation
|
|
if card and ann_scol in proprio.carteEtudiant() : carte='on'
|
|
else : carte='off'
|
|
|
|
if ann_scol in proprio.paiement() : paid_now='on'
|
|
else : paid_now='off'
|
|
|
|
if ann_scol+1 in proprio.paiement() : precab='on'
|
|
else : precab='off'
|
|
|
|
arg = u'--title "Etat administratif de %s" ' % proprio.Nom()
|
|
arg+= u'--separate-output '
|
|
arg+= u'--checklist "" 0 0 0 '
|
|
if card :
|
|
arg+= u'"1" "Carte d\'étudiant %d/%d fournie" "%s" ' % (ann_scol,ann_scol+1, carte)
|
|
arg+= u'"2" "Adhésion %d/%d réglée et charte signée" "%s" ' % (ann_scol,ann_scol+1,paid_now)
|
|
if config.precab == 1 :
|
|
arg+= u'"3" "Adhésion %d/%d réglée et charte signée (précâblage)" "%s" ' % (ann_scol+1,ann_scol+2,precab)
|
|
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
|
|
# Traitement
|
|
if card :
|
|
if '1\n' in result : proprio.carteEtudiant(ann_scol)
|
|
else : proprio.carteEtudiant(-ann_scol)
|
|
|
|
if '2\n' in result : proprio.paiement(ann_scol)
|
|
else : proprio.paiement(-ann_scol)
|
|
|
|
if '3\n' in result : proprio.paiement(ann_scol+1)
|
|
else : proprio.paiement(-ann_scol-1)
|
|
|
|
###############################################################
|
|
## Fonctions de remplissage ou modification des paramètres club
|
|
|
|
def set_club(club) :
|
|
step = 1
|
|
while 1 :
|
|
if step == 1 :
|
|
# Responsable
|
|
resp = club.responsable()
|
|
if resp :
|
|
arg = u'--title "Responsable du club" '
|
|
arg+= u'--yesno "\nLe responsable du club est-il toujours %s ?\n\n\n" 0 0' % resp.Nom()
|
|
no, res = dialog(arg)
|
|
if not resp or no :
|
|
arg = u'--title "Responsable du club" '
|
|
arg+= u'--msgbox "Séléctionnez l\'adhérent responsable du club\n\n\n" 0 0'
|
|
dialog(arg)
|
|
resp = select(club,u'du responsable du club a','ro')
|
|
if not resp : return 1
|
|
else :
|
|
club.responsable(resp)
|
|
step += 1
|
|
else :
|
|
step += 1
|
|
if step == 2 :
|
|
# Nom du club
|
|
arg = u'--title "Nom" '
|
|
arg+= u'--inputbox "Nom du club ?" 0 0 "%s"' % club.Nom()
|
|
annul, res = dialog(arg)
|
|
if annul : step -= 1
|
|
else :
|
|
try :
|
|
club.Nom(res[0])
|
|
step += 1
|
|
except ValueError, c :
|
|
arg = u'--title "Nom club" '
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
|
dialog(arg)
|
|
|
|
if step == 3 :
|
|
# Local
|
|
try :
|
|
club.chbre('&é"') # Fait une erreur
|
|
except ValueError, c :
|
|
locaux = c.args[1]
|
|
|
|
arg = u'--title "Local du club" '
|
|
arg+= u'--default-item "%s" ' % club.chbre()
|
|
arg+= u'--menu "Choisissez le local du club :" 0 0 0 '
|
|
key = locaux.keys()
|
|
key.sort()
|
|
for k in key :
|
|
arg+= u'"%s" "%s" ' % ( k , locaux[k] )
|
|
annul , result = dialog(arg)
|
|
if annul : step -= 1
|
|
else :
|
|
club.chbre(result[0])
|
|
step += 1
|
|
|
|
if step == 4 :
|
|
# Administratif
|
|
if set_admin(club) : step -=1
|
|
else : step += 1
|
|
|
|
if step == 5 :
|
|
# Remarque
|
|
if set_rque(club) : step -= 1
|
|
else : step += 1
|
|
|
|
if step == 6 :
|
|
# Confirmation
|
|
if confirm(club) : step -= 1
|
|
else : break
|
|
|
|
def select_club(clas) :
|
|
""" Choix d'un club """
|
|
arg = u'--title "Recherche d\'unclub" '
|
|
|
|
clubs = clas.search('cid=*')['club']
|
|
if not clubs :
|
|
# Pas de club dans la base
|
|
arg += '--msgbox "Il n\'y a pas de clubs inscrits dans la base\n\n\n" 0 0 '
|
|
dialog(arg)
|
|
return
|
|
arg+= u'--menu "Choisissez un club :" 0 0 0 '
|
|
for club in clubs :
|
|
arg += '"%s" "%s" ' % ( club.id(), club.Nom() )
|
|
annul, res = dialog(arg)
|
|
if annul : return
|
|
return clas.search('cid=%s' % res[0],'w')['club'][0]
|
|
|
|
def del_club(club) :
|
|
""" Destruction club """
|
|
quoi ='Toutes les machines associées à cet adhérent seront détruites'
|
|
while 1 :
|
|
arg = u'--title "Destruction club " --colors '
|
|
arg+= u'--inputbox "\Zr\Z1ATTENTION\Zn : la destruction est définitive\n\nToutes les machines de ce club seront également détruites.\n\nCommentaire à insérer ?" 0 0'
|
|
annul, res = dialog(arg)
|
|
if annul : return 1
|
|
if res[0] : break
|
|
arg = u'--title "Destruction club" '
|
|
arg+= u'--msgbox "Le commentaire est obligatoire\n\n\n" 0 0'
|
|
dialog(arg)
|
|
|
|
club.delete(res[0])
|
|
arg = u'--title "Destruction club" '
|
|
arg+= u'--msgbox "Club détruit\n\n\n" 0 0'
|
|
dialog(arg)
|
|
|
|
##################################################################
|
|
## Fonctions de remplissage ou modification des paramètres machine
|
|
|
|
def set_machine(machine) :
|
|
"""
|
|
Définition des paramètres d'une machine :
|
|
* Nom de machine
|
|
* Adresse MAC
|
|
* IP
|
|
* ports ouverts si adm
|
|
* Remarque
|
|
Si borne wifi demande aussi canal et puissance
|
|
"""
|
|
|
|
if machine.proprietaire().__class__ == crans :
|
|
if not isadm :
|
|
arg = u'--title "Erreur" '
|
|
arg+= u'--msgbox "Vous n\'avez pas les droits de modification de cette machine.\n\n" 0 0'
|
|
dialog(arg)
|
|
# On redemande
|
|
return 1
|
|
nom = machine.nom()
|
|
l = 50
|
|
else :
|
|
nom = machine.nom().split('.')[0]
|
|
l = 17
|
|
|
|
# Construction de la boite de dialogue
|
|
arg = u'--title "Paramètres machine" '
|
|
arg+= u'--form "" 0 0 0 '
|
|
arg+= u'"Nom de machine :" 1 1 "%s" 1 18 %i 0 ' % (nom, l)
|
|
arg+= u'"Adresse mac :" 2 1 "%s" 2 15 17 0 ' % machine.mac()
|
|
arg+= u'"IP :" 3 1 "%s" 3 6 15 0 ' % machine.ip()
|
|
if isadm :
|
|
arg+= u'"PortsTCP ext->machine :" 4 1 "%s" 4 25 50 0 ' % machine.portTCPin()
|
|
arg+= u'"PortsTCP machine->ext :" 5 1 "%s" 5 25 50 0 ' % machine.portTCPout()
|
|
arg+= u'"PortsUDP ext->machine :" 6 1 "%s" 6 25 50 0 ' % machine.portUDPin()
|
|
arg+= u'"PortsUDP machine->ext :" 7 1 "%s" 7 25 50 0 ' % machine.portUDPout()
|
|
if machine.puissance()!=None and isadm :
|
|
# Borne wifi
|
|
p = u'Mettre le lieu de la borne comme première remarque.'
|
|
arg+= u'"Canal :" 2 35 "%s" 2 43 4 0 ' % machine.canal()
|
|
arg+= u'"Puissance :" 3 35 "%s" 3 47 4 0 ' % machine.puissance()
|
|
else :
|
|
p = u'Pour ajouter une remarque modifier la dernière de la liste.'
|
|
|
|
# Affichage
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
|
|
# Traitement
|
|
err = ''
|
|
try : machine.nom(result[0])
|
|
except ValueError, c : err += c.args[0] + '\n'
|
|
except EnvironmentError, c : err += c.args[0] + '\n'
|
|
|
|
try : machine.mac(result[1])
|
|
except ValueError, c :
|
|
if len(c.args)>1 and isadm :
|
|
# Mac en double
|
|
arg = u'--title "Adresse MAC" '
|
|
arg+= u'--yesno "L\'adresse MAC existe déja, continuer ? \n" 0 0'
|
|
no, res = dialog(arg)
|
|
if no :
|
|
return set_machine(machine)
|
|
else :
|
|
try : machine.mac(result[1],1)
|
|
except ValueError, c : err += c.args[0] + '\n'
|
|
except EnvironmentError, c : err += c.args[0] + '\n'
|
|
else :
|
|
err += c.args[0] + '\n'
|
|
except EnvironmentError, c : err += c.args[0] + '\n'
|
|
|
|
try : machine.ip(result[2])
|
|
except ValueError, c : err += c.args[0] + '\n'
|
|
except EnvironmentError, c : err += c.args[0] + '\n'
|
|
except RuntimeError,c : err += c.args[0] + '\n' # Plus d'IP libres, peut-être à traiter differement ?
|
|
|
|
if isadm :
|
|
try :
|
|
machine.portTCPin(result[3])
|
|
machine.portTCPout(result[4])
|
|
machine.portUDPin(result[5])
|
|
machine.portUDPout(result[6])
|
|
except ValueError, c : err += c.args[0] + '\n'
|
|
|
|
if isadm and machine.puissance()!=None :
|
|
try : machine.canal(result[7])
|
|
except ValueError, c : err += c.args[0] + '\n'
|
|
try : machine.puissance(result[8])
|
|
except ValueError, c : err += c.args[0] + '\n'
|
|
|
|
# Des erreurs ?
|
|
if err :
|
|
arg = u'--title "Paramètres machine" '
|
|
arg+= u'--msgbox "%s\n\n" 0 0' % err
|
|
dialog(arg)
|
|
# On redemande
|
|
return set_machine(machine)
|
|
|
|
if __prompt_input_menu(machine.info,u'Remarque',u"Entrez ou modifier une remarque\n%s\n" % p) :
|
|
return set_machine(machine)
|
|
|
|
if machine.modifs and confirm(machine) :
|
|
return set_machine(machine)
|
|
|
|
def del_machine(machine) :
|
|
"""
|
|
Destruction machine
|
|
"""
|
|
while 1 :
|
|
arg = u'--title "Destruction machine %s" --colors ' % machine.nom()
|
|
arg+= u'--inputbox "\Zr\Z1ATTENTION\Zn : la destruction est définitive\nCommentaire à insérer ?" 0 0'
|
|
annul, res = dialog(arg)
|
|
if annul : return 1
|
|
if res[0] : break
|
|
arg = u'--title "Destruction machine" '
|
|
arg+= u'--msgbox "Le commentaire est obligatoire\n\n\n" 0 0'
|
|
dialog(arg)
|
|
|
|
try :
|
|
machine.delete(res[0])
|
|
except EnvironmentError, c :
|
|
arg = u'--title "Destruction machine" '
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
|
dialog(arg)
|
|
return 1
|
|
|
|
arg = u'--title "Destruction machine" '
|
|
arg+= u'--msgbox "Machine détruite\n\n\n" 0 0'
|
|
dialog(arg)
|
|
|
|
|
|
####################################
|
|
## Fonctions principales d'interface
|
|
|
|
def all(adher) :
|
|
"""
|
|
Définition des propriétés d'un adhérent
|
|
4 etapes :
|
|
* set_bases
|
|
* set_etudes
|
|
* set_admin
|
|
* set_mail
|
|
* set_rque
|
|
Retourne 1 si annulation.
|
|
"""
|
|
step = 1
|
|
while 1 :
|
|
if step == 1 :
|
|
if set_bases(adher) : return 1
|
|
else : step +=1
|
|
if step == 2 :
|
|
if set_etudes(adher) : step -= 1
|
|
else : step +=1
|
|
if step == 3 :
|
|
if set_admin(adher) : step -= 1
|
|
else : step +=1
|
|
if step == 4 :
|
|
if set_mail(adher) : step -= 1
|
|
else : step +=1
|
|
if step == 5 :
|
|
if set_rque(adher) : step -= 1
|
|
else : step +=1
|
|
if step == 6 :
|
|
if confirm(adher) : step = 1
|
|
else : break
|
|
|
|
arg = u'--title "Inscription Mailing liste de communication ENS" --yesno "\nInscrire l\'adhérent à la mailing liste de communication de l\'ENS ?\n\n\n" 0 0'
|
|
no, res = dialog(arg)
|
|
if not no :
|
|
mail = adher.mail()
|
|
if mail.find('@')==-1 : mail += '@crans.org'
|
|
adher.services_to_restart('ML-ENS',[mail])
|
|
|
|
def modif_adher(adher) :
|
|
"""
|
|
Modification de l'adhérent fourni (instance de adhérent)
|
|
Retourne 1 si annulation.
|
|
"""
|
|
# Préliminaire : si la chambre est inconnue on force la question
|
|
if adher.chbre() =='????' :
|
|
res=['Chambre']
|
|
arg = u'--title "Modification de %s" ' % adher.Nom()
|
|
arg+= u'--msgbox "ERREUR : la chambre de cet adhérent est inconnue !\n\n\n" 0 0'
|
|
dialog(arg)
|
|
else :
|
|
arg = u'--title "Modification de %s" ' % adher.Nom()
|
|
arg+= u'--menu "Que souhaitez vous modifier ?" 0 0 0 '
|
|
arg+= u'"Admistratif" "Précâblage, carte d\'étudiant, études" '
|
|
if adher.chbre() == 'EXT' :
|
|
arg+= u'"Adresse" "Déménagement" '
|
|
else :
|
|
arg+= u'"Chambre" "Déménagement" '
|
|
arg+= u'"Etudes" "Changement d\'année ou de filière" '
|
|
arg+= u'"Téléphone" "Changement de numéro de téléphone" '
|
|
arg+= u'"Mail" "Créer un compte ou changer l\'adresse mail de contact" '
|
|
arg+= u'"Alias" "Créer ou supprimer un alias mail" '
|
|
arg+= u'"Remarque" "Ajouter ou modifer un commentaire" '
|
|
if isadm :
|
|
arg+= u'"Droits" "Modifier les droits alloués à cet adhérent" '
|
|
arg+= u'"Shell" "Changer le shell de cet utilisateur" '
|
|
if isdeconnecteur :
|
|
arg+= u'"Blackliste" "Modifier la blackliste de cet adhérent" '
|
|
annul, res = dialog(arg)
|
|
|
|
if annul : return 1
|
|
|
|
if res[0]=='Etudes' :
|
|
set_etudes(adher)
|
|
elif res[0]=='Admistratif' :
|
|
if not set_admin(adher) :
|
|
set_etudes(adher)
|
|
elif res[0]=='Mail' :
|
|
set_mail(adher)
|
|
elif res[0]=='Remarque' :
|
|
set_rque(adher)
|
|
elif res[0]=='Droits' :
|
|
set_droits(adher)
|
|
elif res[0]=='Blackliste' :
|
|
set_blackliste(adher)
|
|
elif res[0]=='Chambre' :
|
|
while 1 :
|
|
arg = u'--title "Déménagement de la %s" ' % adher.chbre()
|
|
arg+= u'--colors --inputbox "Nouvelle chambre ? (EXT si extérieur au campus)\n\n'
|
|
arg+="\Zr\Z1ATTENTION\Zn : Un changement de bat entrainera un changement d'IP des machines fixes\n"
|
|
arg+= u'" 0 0 '
|
|
annul,res = dialog(arg)
|
|
if annul : return 1
|
|
|
|
e = _set_chbre(adher,res[0])
|
|
if e :
|
|
arg = u'--title "Déménagement de la %s" ' % adher.chbre()
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % e
|
|
dialog(arg)
|
|
else :
|
|
if adher.chbre() =='EXT' :
|
|
# Il faut demander l'adresse extérieure
|
|
if set_addr_ext(adher) :
|
|
# Annulation
|
|
continue
|
|
break
|
|
elif res[0]=='Adresse' :
|
|
arg = u'--title "Déménagement de %s" ' % adher.Nom()
|
|
arg+= u'--menu "Question :" 0 0 0 '
|
|
arg+= u'"1" "Déménagement à l\'extérieur ?" '
|
|
arg+= u'"2" "Déménagement sur le campus ? " '
|
|
annul , result = dialog(arg)
|
|
if annul : return 1
|
|
if result[0]=='1' :
|
|
if set_addr_ext(adher) :
|
|
# Annulation
|
|
return 1
|
|
else :
|
|
while 1 :
|
|
arg = u'--title "Déménagement de %s" ' % adher.Nom()
|
|
arg+= u'--inputbox "Chambre ?" 0 0 '
|
|
annul,res = dialog(arg)
|
|
if annul : return 1
|
|
|
|
e=0
|
|
try :
|
|
c = adher.chbre(res[0])
|
|
if c =='EXT' :
|
|
# Il faut demander l'adresse extérieure
|
|
if set_addr_ext(adher) :
|
|
# Annulation
|
|
continue
|
|
break
|
|
except EnvironmentError, c : e = c.args[0]
|
|
except ValueError, c : e = c.args[0]
|
|
if e :
|
|
arg = u'--title "Déménagement de %s" ' % adher.Nom()
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % e
|
|
dialog(arg)
|
|
|
|
elif res[0]=='Téléphone' :
|
|
while 1 :
|
|
arg = u'--title "Changement numéro de téléphone de de %s" ' % adher.Nom()
|
|
arg+= u'--inputbox "Nouveau numéro ?" 0 0 "%s" ' % adher.tel()
|
|
annul,res = dialog(arg)
|
|
if annul : return 1
|
|
|
|
try :
|
|
adher.tel(res[0].replace(' ',''))
|
|
break
|
|
except ValueError, c :
|
|
arg = u'--title "Changement numéro de téléphone de de %s" ' % adher.Nom()
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
|
dialog(arg)
|
|
|
|
elif res[0]=='Alias' :
|
|
__prompt_input_menu(adher.alias,'Alias mail', "Entrez ou modifier un alias mail.\nPour ajouter un alias modifier le dernier de la liste.")
|
|
|
|
elif res[0]=='Shell' :
|
|
while 1 :
|
|
arg = u'--title "Nouveau shell pour %s" ' % adher.Nom()
|
|
arg+= u'--inputbox "Shell : " 0 0 "%s" ' % adher.chsh()
|
|
annul,res = dialog(arg)
|
|
if annul : return 1
|
|
|
|
try :
|
|
adher.chsh(res[0])
|
|
break
|
|
except ValueError, c :
|
|
arg = u'--title "Changement du shell de %s" ' % adher.Nom()
|
|
arg+= u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
|
dialog(arg)
|
|
|
|
if adher.modifs :
|
|
return confirm(adher)
|
|
|
|
########################################################################
|
|
## Fonction de sélection (adhérent ou machine)
|
|
|
|
def select(clas,quoi,mde='') :
|
|
"""
|
|
Interface de choix d'un adhérent, d'une machine ou d'un club
|
|
Retourne une instance de la classe choisie.
|
|
quoi est la chaine utilisée pour la demande (%sid=?)
|
|
exemples : quoi = 'adhérent a' => Votre choix ? adhérent aid=:
|
|
il faut que le dernier caractère de quoi soit a pour adhérent ou m pour machine
|
|
Retourne None si annulation.
|
|
|
|
si m = ro ouvre l'objet en mode read-only
|
|
"""
|
|
|
|
s=['','','','','','','','','','']
|
|
def f(a) :
|
|
try:
|
|
return unicode(a,'iso-8859-15')
|
|
except:
|
|
return a
|
|
while 1 :
|
|
s = map(f,s)
|
|
arg = u'--title "Recherche %s" ' % ' '.join(quoi.split()[:-1])
|
|
arg+= u'--help-button '
|
|
arg+= u'--form "Entrez vos paramètres de recherche" 0 0 0 '
|
|
arg+= u'"Nom :" 1 1 "%s" 1 13 20 20 ' % s[0]
|
|
arg+= u'"Prenom :" 2 1 "%s" 2 13 20 20 ' % s[1]
|
|
arg+= u'"Téléphone :" 3 1 "%s" 3 13 10 00 ' % s[2]
|
|
arg+= u'"Chambre :" 4 1 "%s" 4 13 05 00 ' % s[3]
|
|
arg+= u'"aid :" 5 1 "%s" 5 13 5 5 ' % s[4]
|
|
arg+= u'"Login / mail :" 6 1 "%s" 6 16 30 00 ' % s[5]
|
|
arg+= u'"Machine :" 1 35 "" 0 0 0 0 '
|
|
arg+= u'"Nom :" 2 37 "%s" 2 43 17 17 ' % s[6]
|
|
arg+= u'"Mac :" 3 37 "%s" 3 43 17 17 ' % s[7]
|
|
arg+= u'"IP :" 4 37 "%s" 4 43 15 15 ' % s[8]
|
|
arg+= u'"mid :" 5 37 "%s" 5 43 5 5 ' % s[9]
|
|
arg+= u'"Les champs vides sont ignorés." 7 1 "" 0 0 0 0'
|
|
|
|
annul , result = dialog(arg)
|
|
if annul : return
|
|
|
|
if result[0][:4]=='HELP' :
|
|
arg = u'--title Aide '
|
|
arg+= u'--msgbox "Il n\'est pas necessaire de remplir tous les champs.\n'
|
|
arg+= u'Il est possible d\'utiliser les * dans les champs de recherche.\n\n\n" 0 0'
|
|
dialog(arg)
|
|
continue
|
|
|
|
s=[]
|
|
for i in result :
|
|
i = i.strip()
|
|
if not i : i=u'*'
|
|
s.append(i)
|
|
|
|
### Contruction de la chaîne de recherche
|
|
filtre_adher = 'nom=%s&prenom=%s&tel=%s&chbre=%s&aid=%s&mail=%s&' % tuple(s[:6])
|
|
filtre_machine = 'host=%s&macAddress=%s&ipHostNumber=%s&mid=%s&' % tuple(s[6:])
|
|
|
|
filtre=''
|
|
if filtre_adher.count('=*&') != 6 :
|
|
# Au moins une condition adhérent
|
|
filtre += filtre_adher[:-1]
|
|
if filtre_machine.count('=*&') != 4 :
|
|
# Au moins une condition machine
|
|
if filtre : filtre += '&'
|
|
filtre += filtre_machine[:-1]
|
|
if filtre == '' :
|
|
# Aucune condion => erreur
|
|
arg = u'--title "Recherche" '
|
|
arg+= u'--msgbox "Il faut au moins une condition.\n\n\n" 0 0'
|
|
dialog(arg)
|
|
continue
|
|
|
|
### Recherche
|
|
try:
|
|
if mde =='ro' :
|
|
res = clas.search(filtre,'ro')
|
|
else :
|
|
res = clas.search(filtre,'w')
|
|
except ValueError :
|
|
arg = u'--title "Recherche" '
|
|
arg+= u'--msgbox "Caractère interdit.\n\n\n" 0 0'
|
|
dialog(arg)
|
|
continue
|
|
|
|
# Affichage
|
|
if quoi[-1] == 'a' :
|
|
valid = res['adherent']
|
|
if not valid and res['machine'] :
|
|
# On va récupérer les adhérents correspondants aux machines trouvés
|
|
deja=[]
|
|
for m in res['machine'] :
|
|
a = m.proprietaire()
|
|
if a.id() in deja : continue
|
|
deja.append(a.id())
|
|
valid.append(a)
|
|
elif quoi[-1] =='m' :
|
|
valid = res['machine']
|
|
if not valid and res['adherent'] :
|
|
# On va récupérer les machines des adhérents trouvés
|
|
for a in res['adherent'] :
|
|
for m in a.machines() :
|
|
valid.append(m)
|
|
else :
|
|
raise TypeError('Argument fonction invalide')
|
|
|
|
if not valid or ( len(valid)==1 and quoi[-1] == 'a' and valid[0].__class__ == crans ) :
|
|
arg = u'--title "Recherche" '
|
|
arg+= u'--msgbox "Aucun résultat.\n\n\n" 0 0'
|
|
dialog(arg)
|
|
# Retour au formulaire
|
|
continue
|
|
|
|
if len(valid)==1 :
|
|
# Une seule réponse
|
|
choix = valid[0]
|
|
else :
|
|
# Il faut choisir
|
|
while 1 :
|
|
os.system('clear')
|
|
choix = None
|
|
print "Plusieurs réponses correspondant à votre requête ont été trouvées :"
|
|
aff(valid)
|
|
txt = u'Votre choix ? (0 pour annuler) %sid =' % quoi
|
|
i = affich_tools.prompt(txt.encode('iso-8859-15'))
|
|
if i == '0' : break
|
|
for v in valid :
|
|
if v.id() == i :
|
|
choix = v
|
|
break
|
|
if not choix :
|
|
# Redemande le choix
|
|
print 'Choix invalide'
|
|
continue
|
|
if choix : break
|
|
|
|
if not choix :
|
|
# Retour à l'interface de recherche
|
|
continue
|
|
|
|
os.system('clear')
|
|
print "Sélection : "
|
|
aff(choix)
|
|
|
|
while 1 :
|
|
r = affich_tools.prompt('Confirmer sélection ? [O/N]' )
|
|
if r=='O' or r=='o' :
|
|
break
|
|
elif r=='N' or r=='n' :
|
|
# Annulation du choix
|
|
choix = None
|
|
break
|
|
print 'Répondre O ou N'
|
|
# Retour à la confirmation
|
|
|
|
if choix :
|
|
if mde!='ro' and not choix._modifiable :
|
|
arg = u'--title "Recherche" '
|
|
arg+= u'--msgbox "Objet sélectionné locké, attendre.\n\n\n" 0 0'
|
|
dialog(arg)
|
|
return
|
|
return choix
|
|
# Sinon retour interface de sélection
|
|
|
|
def menu_principal() :
|
|
"""
|
|
Affiche le menu de choix initial
|
|
"""
|
|
proprio = None
|
|
becane = None
|
|
choix = None
|
|
while 1 :
|
|
arg = u'--title "Menu principal" '
|
|
arg+= u'--help-button --item-help --cancel-label "Quitter" '
|
|
arg+= u'--default-item "%s" ' % choix
|
|
arg+= u'--menu "Que souhaitez vous faire ?" 0 55 13 '
|
|
if proprio.__class__ == adherent :
|
|
arg+= u'"mAc"'
|
|
elif proprio.__class__ == club :
|
|
arg+= u'"mCc"'
|
|
if proprio :
|
|
if proprio.__class__ != crans :
|
|
arg+= u' "Modifier l\'inscription de %s" "" ' % proprio.Nom()
|
|
arg+= u'"aMc" "Ajouter une machine à %s" "" ' % proprio.Nom()
|
|
if isdeconnecteur :
|
|
arg+= u'"ebA" "Editer blackliste de %s" "" ' % proprio.Nom()
|
|
if becane :
|
|
arg+= u'"mMc" "Modifier la machine %s" "Modification du nom, de l\'IP ou de la MAC" ' % becane.nom().split('.')[0]
|
|
if isadm :
|
|
arg+= u'"eac" "Editer les alias de la machine %s" "" ' % becane.nom().split('.')[0]
|
|
if isdeconnecteur :
|
|
arg+= u'"ebM" "Editer blackliste de la machine %s" "" ' % becane.nom().split('.')[0]
|
|
if proprio or becane :
|
|
arg+= u'"" "---------------------------------------" "" '
|
|
|
|
arg+= u'"aA" "Inscrire un nouvel adhérent" "" '
|
|
arg+= u'"mA" "Modifier l\'inscription d\'un adhérent" "Changer la chambre, la remarque, la section, la carte d\'étudiant ou précâbler." '
|
|
arg+= u'"aMA" "Ajouter une machine à un adhérent" "" '
|
|
arg+= u'"dA" "Détruire un adhérent" "Supression de l\'adhérent ainsi que de ses machines" '
|
|
arg+= u'"" "---------------------------------------" "" '
|
|
arg+= u'"mM" "Modifier une machine existante" "Changer le nom ou la MAC d\'une machine." '
|
|
if isadm :
|
|
arg+= u'"ea" "Editer les alias d\'une machine" "" '
|
|
arg+= u'"dM" "Détruire une machine" "" '
|
|
arg+= u'"" "---------------------------------------" "" '
|
|
arg+= u'"aC" "Inscrire un nouveau club" "" '
|
|
arg+= u'"mC" "Modifier un club" "" '
|
|
arg+= u'"aMC" "Ajouter une machine à un club" "" '
|
|
arg+= u'"dC" "Détruire un club" "Supression du club ainsi que de ses machines" '
|
|
if isadm or isdeconnecteur :
|
|
arg+= u'"" "---------------------------------------" "" '
|
|
if isadm :
|
|
arg+= u'"aaM" "Ajouter une machine à l\'association" "" '
|
|
arg+= u'"abW" "Ajouter une borne wifi" "" '
|
|
if isdeconnecteur :
|
|
arg+= u'"bl" "Modifier blackliste" "" '
|
|
annul , result = dialog(arg)
|
|
if annul : break
|
|
|
|
if result[0][:4]=='HELP' :
|
|
arg = u'--title Aide '
|
|
arg+= u'--msgbox "Interface utilisable au clavier ou a la souris pour les terminaux le supportant.\n'
|
|
arg+= u'Pour revenir à une question précédente utiliser le bouton annuler ou Ctrl+C.\n'
|
|
arg+= u'Pour quitter sans enregister les dernières modifications utilisez ESC.\n\n'
|
|
arg+= u'Pour toute remarque ou problème : fred@crans.org\n\n\n" 0 0'
|
|
dialog(arg)
|
|
continue
|
|
|
|
choix = result[0]
|
|
if not choix : continue
|
|
|
|
if choix=='aA' :
|
|
# Inscription nouvel adhérent
|
|
proprio = adherent()
|
|
if all(proprio) :
|
|
del proprio
|
|
proprio = None
|
|
else : choix = 'aMc' # ajout d'une machine
|
|
|
|
elif choix=='mA' :
|
|
# Modif adhérent
|
|
proprio = select(db,u'adhérent à modifier a')
|
|
if not proprio : continue
|
|
choix = 'mAc'
|
|
|
|
elif choix=='aMA' :
|
|
# Ajout machine, adhérent à choisir
|
|
proprio = select(db,u'adhérent auquel ajouter une machine a')
|
|
if not proprio : continue
|
|
choix='aMc'
|
|
|
|
elif choix=='aMC' :
|
|
# Ajout machine, club à choisir
|
|
proprio = select_club(db)
|
|
if not proprio : continue
|
|
choix='aMc'
|
|
|
|
elif choix=='mM' :
|
|
# Modif machine, machine à choisir
|
|
becane = select(db,u'machine à modifier m')
|
|
if not becane : continue
|
|
choix='mMc'
|
|
|
|
elif choix=='ea' :
|
|
# Modif alias machine
|
|
becane = select(db,u'machine à modifier m')
|
|
if not becane : continue
|
|
choix = 'eac'
|
|
|
|
elif choix=='aC' :
|
|
# Ajout d'un club
|
|
proprio = club()
|
|
if set_club(proprio) :
|
|
del proprio ; proprio = None
|
|
else : choix = 'aMc' # ajout d'une machine
|
|
|
|
elif choix=='mC' :
|
|
# Modif club
|
|
proprio = select_club(db)
|
|
if not proprio : continue
|
|
choix='mCc'
|
|
|
|
elif choix=='dA' :
|
|
# Destruction adhérent
|
|
proprio = select(db,u'adhérent à détruire a')
|
|
if not proprio : continue
|
|
if del_adher(proprio) : continue
|
|
del(proprio) ; proprio=None
|
|
del(becane) ; becane=None
|
|
|
|
elif choix=='dM' :
|
|
# Destruction machine
|
|
becane = select(db,u'machine à détruire m')
|
|
if not becane : continue
|
|
if del_machine(becane) : continue
|
|
del(becane) ; becane=None
|
|
|
|
elif choix=='dC' :
|
|
# Destruction club
|
|
proprio = select_club(db)
|
|
if not proprio : continue
|
|
if del_club(proprio) : continue
|
|
del(proprio) ; proprio=None
|
|
del(becane) ; becane=None
|
|
|
|
elif choix=='aaM' :
|
|
# Ajout machine au crans
|
|
becane = machine(crans(),"fixe")
|
|
choix = 'mMc'
|
|
|
|
elif choix=='abW' :
|
|
# Ajout borne wifi
|
|
becane = machine(crans(),"borne")
|
|
choix = 'mMc'
|
|
|
|
elif choix=='bl' :
|
|
# Edition blackliste
|
|
arg = u'--title "Edition blackliste" '
|
|
arg+= u'--menu "Editer la blackliste de : " 0 0 0 '
|
|
arg+= u'"1" "Adhérent" '
|
|
arg+= u'"2" "Machine" '
|
|
arg+= u'"3" "Club" '
|
|
annul , result = dialog(arg)
|
|
if annul : continue
|
|
choix=int(result[0])
|
|
if choix == 1 :
|
|
proprio = select(db,u'adhérent a')
|
|
if proprio : choix = 'ebA'
|
|
elif choix == 2 :
|
|
becane = select(db,u'machine m')
|
|
if becane : choix = 'ebM'
|
|
elif choix == 3 :
|
|
proprio = select_club(db)
|
|
if proprio : choix = 'ebA'
|
|
|
|
##############################################
|
|
|
|
if choix=='aMc' :
|
|
# Ajout d'une machine à l'adhérent courant
|
|
arg = u'--title "Nouvelle machine" '
|
|
arg+= u'--menu "Type de machine ?" 0 0 0 '
|
|
arg+= u'"Fixe" "Machine fixe" '
|
|
arg+= u'"Wifi" "Machine wireless" '
|
|
annul , result = dialog(arg)
|
|
if annul : continue
|
|
choix=result[0]
|
|
try :
|
|
if choix=='Fixe' :
|
|
becane = machine(proprio,'fixe')
|
|
elif choix=='Wifi' :
|
|
becane = machine(proprio,'wifi')
|
|
except ValueError, c:
|
|
arg = '--title "Nouvelle machine" '
|
|
arg += '--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
|
dialog(arg)
|
|
continue
|
|
if set_machine(becane) :
|
|
# Annulation
|
|
del(becane) ; becane = None
|
|
|
|
|
|
if choix=='mAc' :
|
|
# Modif propriétaire courant
|
|
del(becane) ; becane=None
|
|
# On supprime la machine car des modifs du propriétaire (bat) ne seraient
|
|
# alors pas vu par l'instance actuelle de machine
|
|
if modif_adher(proprio) :
|
|
# Annulation des modifs
|
|
proprio.restore()
|
|
|
|
elif choix=='mMc' :
|
|
# Modif machine courante
|
|
if not proprio :
|
|
proprio = becane.proprietaire()
|
|
if proprio.chbre() == '????' :
|
|
arg = u'--title "Ajout d\'une machine" '
|
|
arg+= u'--msgbox "ERREUR : la chambre de %s est inconnue !\n\n\n" 0 0' % proprio.Nom()
|
|
dialog(arg)
|
|
elif set_machine(becane) :
|
|
# Annulation des modifs
|
|
becane.restore()
|
|
|
|
elif choix=='mCc' :
|
|
# Modif club courant
|
|
if set_club(proprio) :
|
|
# Annulation des modifs
|
|
proprio.restore()
|
|
|
|
elif choix=='eac' :
|
|
# Modif alias machine courante
|
|
if __prompt_input_menu(becane.alias,'Alias machine', "Entrez ou modifier un alias machine.\nPour ajouter un alias modifier le dernier de la liste.") or confirm(becane) :
|
|
becane.restore()
|
|
|
|
elif choix=='ebA' :
|
|
# Edition blackliste adhérent ou club
|
|
if set_blackliste(proprio) :
|
|
proprio.restore()
|
|
|
|
elif choix=='ebM' :
|
|
# Edition blackliste machine
|
|
if set_blackliste(becane) :
|
|
becane.restore()
|
|
|
|
os.system('clear')
|
|
|
|
def killed(a,z) :
|
|
sys.exit(254) # Va tomber dans les exceptions
|
|
|
|
if __name__ == '__main__' :
|
|
global db, debug
|
|
debug = 0
|
|
|
|
signal.signal(signal.SIGTERM,killed) # Interception du signal TERM
|
|
signal.signal(signal.SIGINT,signal.SIG_DFL) # Comportement normal de Ctrl-C
|
|
|
|
# Traitement des options
|
|
try :
|
|
if len(sys.argv) > 1 :
|
|
options, arg = getopt.getopt(sys.argv[1:], '', ['debug'])
|
|
else :
|
|
options, arg = ( [],'')
|
|
except getopt.error, msg :
|
|
print msg
|
|
sys.exit(255)
|
|
|
|
for opt, val in options :
|
|
if opt == '--debug' :
|
|
debug = 1
|
|
|
|
# Phase principale
|
|
try :
|
|
db = crans_ldap()
|
|
menu_principal()
|
|
#os.system('clear')
|
|
exit = 0
|
|
except KeyboardInterrupt :
|
|
os.system('clear')
|
|
print "Interruption par l'utilisateur."
|
|
exit = 255
|
|
except SystemExit , c:
|
|
if c.__str__() == '254' :
|
|
os.system('reset')
|
|
print "Votre session d'édition à été tuée."
|
|
exit = c
|
|
except :
|
|
if not debug : os.system('clear')
|
|
print """Une erreur fatale c'est produite durant l'exécution."""
|
|
|
|
# Report de bug
|
|
import traceback
|
|
from cStringIO import StringIO
|
|
from smtplib import SMTP
|
|
|
|
s = StringIO()
|
|
sys.stderr = s
|
|
traceback.print_exc()
|
|
sys.stderr = sys.__stderr__
|
|
traceback = s.getvalue()
|
|
try :
|
|
if not debug and To :
|
|
# Paramètres pour le mail
|
|
From = script_utilisateur + '@crans.org'
|
|
|
|
entete_mail = """From: Crans <%s>
|
|
To: %s
|
|
Subject: Bugreport %s
|
|
|
|
""" % ( From, To, sys.argv[0].split('/')[-1] )
|
|
|
|
# Envoi mail
|
|
conn = SMTP(smtpserv)
|
|
conn.sendmail(From, To , entete_mail + traceback )
|
|
conn.quit()
|
|
sys.stderr.write("Un rapport de bug à été automatiquement envoyé.\n")
|
|
else :
|
|
print "Merci de faire parvenir un rapport de bug à nounou"
|
|
except :
|
|
sys.stderr.write("Impossible d'envoyer le rapport de bug.\n")
|
|
|
|
if debug :
|
|
print '-'*40
|
|
print 'Détails techniques :'
|
|
sys.stderr.write(traceback)
|
|
print '-'*40
|
|
exit = 1
|
|
|
|
# Restart des services
|
|
signal.signal(signal.SIGINT,signal.SIG_IGN) # Pas de Ctrl-C
|
|
signal.signal(signal.SIGTERM,signal.SIG_IGN) # Pas de kill non plus
|
|
|
|
try :
|
|
serv = db.services_to_restart()
|
|
except :
|
|
# Erreur trop tot probablement
|
|
serv = ''
|
|
if serv :
|
|
mn = int(time.strftime('%M'))
|
|
# Restart toutes les 10 min : 03, 13, 23, 33, 43, 53
|
|
t = ( 13 - mn % 10 ) % 10 + 4 # On prend en plus une marge de 4 min
|
|
if t == 0 : t = 10
|
|
print "Les modifications apportées à la base seront prises en compte dans %imin environ." % t
|
|
if debug :
|
|
print "Les services suivants seront redémarrés: "
|
|
print ', '.join(serv.keys())
|
|
|
|
if debug : print '-*- Fin -*-'
|
|
|
|
# Rétablissement du Ctrl-C
|
|
signal.signal(signal.SIGINT,signal.SIG_DFL)
|
|
sys.exit(exit)
|
|
|