2273 lines
81 KiB
Python
Executable file
2273 lines
81 KiB
Python
Executable file
#! /usr/bin/env python
|
||
# -*- coding: utf-8 -*-
|
||
|
||
"""
|
||
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', 'glondu@crans.org', 'dimino@crans.org',
|
||
'salles@crans.org', 'cohen@crans.org', 'segaud@crans.org',
|
||
'adg@crans.org']
|
||
|
||
import string, os, sys
|
||
import dialog
|
||
from whos import aff
|
||
import signal, getopt
|
||
from time import strftime, strptime, localtime, mktime
|
||
import re
|
||
|
||
import affich_tools, config
|
||
from lock import make_lock, remove_lock
|
||
from ldap_crans import crans_ldap, blacklist_items, ann_scol, droits_possibles, droits_critiques, smtpserv, script_utilisateur
|
||
from ldap_crans import Adherent, AssociationCrans, Club
|
||
from ldap_crans import Machine, MachineFixe, MachineWifi, MachineCrans, BorneWifi
|
||
import user_tests
|
||
|
||
isadm = user_tests.isadm()
|
||
isdeconnecteur = user_tests.isdeconnecteur()
|
||
|
||
db = crans_ldap()
|
||
droits = db.search("uid=%s" % script_utilisateur)['adherent'][0].droits()
|
||
isimprimeur = u"Imprimeur" in droits
|
||
iscontroleur = u'Tresorier' in droits
|
||
isbureau = u'Bureau' in droits
|
||
encoding = sys.stdin.encoding or 'ISO-8859-15'
|
||
|
||
if u'Nounou' in droits:
|
||
if os.path.exists(os.path.expanduser('~/.dialogrc')):
|
||
dialogrc='~/.dilalogrc'
|
||
else:
|
||
dialogrc='/etc/dialog.rc'
|
||
dlg = dialog.Dialog(DIALOGRC=dialogrc)
|
||
dialog_theme='DIALOGRC='+dialogrc
|
||
else:
|
||
dlg = dialog.Dialog()
|
||
dialog_theme=''
|
||
|
||
|
||
def dialog(arg):
|
||
return affich_tools.dialog(u'Gestion des adhérents et machines du Crans', arg, dialog_theme)
|
||
|
||
|
||
#########################################################################
|
||
## 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:
|
||
if len(c.args) == 2:
|
||
# La chambre est occup-Aée-b
|
||
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 not no:
|
||
squatteur.chbre('????')
|
||
squatteur.save()
|
||
# On recommence, le géneur doit être parti.
|
||
return _set_chbre(adher, chbre)
|
||
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 6 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" "" '
|
||
arg += u'"Personnel ENS" "dans les appartements de l\'ENS" '
|
||
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" "License" '
|
||
arg += u'"2" "Master 1" '
|
||
arg += u'"3" "Agrégation" '
|
||
arg += u'"4" "Master 2" '
|
||
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'"Licence" "" '
|
||
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
|
||
elif etudes[0] == "Personnel ENS":
|
||
result = ['0']
|
||
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()
|
||
|
||
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 '
|
||
else:
|
||
arg += u'--menu "Choisissez le laboratoire :" 0 0 0 '
|
||
if not etudes[1] in '1234':
|
||
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" '
|
||
if etudes[1] in '1234':
|
||
arg += u'"A0" "Informatique" '
|
||
arg += u'"A1" "Mathématiques" '
|
||
arg += u'"A2" "Physique fondamentale" '
|
||
arg += u'"A\'\'2" "Chimie" '
|
||
arg += u'"A3" "Biochimie" '
|
||
if etudes[1] == '1':
|
||
arg += u'"B123" "Technologie mécanique" '
|
||
arg += u'"EEA" "Électronique, électrotechnique et automatique" '
|
||
elif etudes[1] == '2':
|
||
arg += u'"EEA" "Électronique, électrotechnique et automatique" '
|
||
arg += u'"B1" "Mécanique" '
|
||
arg += u'"B2" "Génie civil" '
|
||
arg += u'"B3" "Génie mécanique" '
|
||
else:
|
||
arg += u'"B1" "Mécanique" '
|
||
arg += u'"B2" "Génie civil" '
|
||
arg += u'"B3" "Génie mécanique" '
|
||
arg += u'"A\'2" "Physique appliquée" '
|
||
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" '
|
||
|
||
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()
|
||
elif etudes[0] == 'Personnel ENS':
|
||
result = ['n/a']
|
||
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
|
||
|
||
if not isinstance(adher, Club) and not adher.adherentPayant():
|
||
set_mail_ext(adher)
|
||
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 crans" "(login : %s)"' % adher.compte()
|
||
else:
|
||
arg += u'"Créer un compte crans" "(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_etat_civil(adher):
|
||
u"""
|
||
Modifie l'état-civil (nom, prénom) d'un adhérent.
|
||
"""
|
||
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
|
||
|
||
# Construction de la boite de dialogue
|
||
arg = u'--title "État-civil de %s" ' % adher.Nom()
|
||
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()
|
||
|
||
# Affichage
|
||
annul, result = dialog(arg)
|
||
if annul: return
|
||
|
||
# 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'
|
||
|
||
# Des erreurs ?
|
||
if err:
|
||
arg = u'--title "État-civil de %s" ' % adher.Nom()
|
||
arg += u'--msgbox "%s\n\n" 0 0' % err
|
||
dialog(arg)
|
||
# On redemande
|
||
return set_etat_civil(adher)
|
||
|
||
# On change éventuellement le compte
|
||
if adher.compte():
|
||
# On demande au câbleur s'il faut garder le compte ou pas
|
||
arg = u'--title "Modification du compte de %s" ' % adher.Nom()
|
||
arg += u'--colors --defaultno --yesno "Changer le login de l\'adhérent ?\n'
|
||
arg += u'Son login actuel est %s.\n\n' % adher.compte()
|
||
arg += u'Choisir Oui si l\'adhérent n\'a jamais utilisé son compte.\n\n'
|
||
arg += u'\Zr\Z1AVERTISSEMENT :\n'
|
||
arg += u'Le changement de login entraîne la suppression irréversible du compte, '
|
||
arg += u'et donc de tous les fichiers, mails, etc. associés !\Z0\ZR\n\n\n" '
|
||
arg += u'0 0'
|
||
no = not dialog(arg)[0]
|
||
|
||
if no:
|
||
# L'utilisateur n'utilise pas son compte, on le supprime...
|
||
adher.supprimer_compte()
|
||
# ..et on le recrée (ou on met une adresse mail extérieure)
|
||
if set_mail(adher):
|
||
# Le changement d'adresse a été annulé, on recommence tout
|
||
adher.restore()
|
||
return set_etat_civil(adher)
|
||
|
||
def set_compte(adher):
|
||
"""
|
||
Créé un compte sur vert pour un adhérent.
|
||
"""
|
||
|
||
# Message d'avertissement
|
||
arg = u'--title "Création compte crans 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 crans 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 crans 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.canonical_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 peut pas l'utiliser.\Zn" % (adher.prenom(), adher.nom())
|
||
|
||
txt += u'\n'
|
||
|
||
arg = u'--title "Création compte crans 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'
|
||
if isadm or key not in droits_critiques:
|
||
arg += u'"%s" " " "%s" ' % (key, actif)
|
||
|
||
annul, result = dialog(arg)
|
||
if annul: return 1
|
||
|
||
|
||
# Traitement
|
||
# Dans le cas ou l'utilisateur qui modiifie n'est pas nounou
|
||
if not isadm:
|
||
for key in droits_critiques:
|
||
if key in adher.droits():
|
||
result.append(key.encode("ISO-8859-15"))
|
||
adher.droits_light(result)
|
||
else:
|
||
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 club
|
||
|
||
def set_responsable(club):
|
||
""" Modifie le responsable d'un club """
|
||
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)
|
||
|
||
def set_imprimeurs(club):
|
||
""" Modifie les imprimeurs d'un club """
|
||
while 1:
|
||
arg = u'--title "Imprimeurs de %s" ' % club.Nom()
|
||
if len(club.imprimeurs()) > 0:
|
||
arg += u'--menu "Action ?" 0 0 0 '
|
||
arg += u'"Enlever" "Enlever un imprimeur" '
|
||
else:
|
||
arg += u'--menu "Il n\'y a aucun imprimeur pour ce club." 0 0 0 '
|
||
arg += u'"Ajouter" "Ajouter un imprimeur" '
|
||
annul, res = dialog(arg)
|
||
if annul: break
|
||
if res[0] == 'Enlever':
|
||
liste = map(lambda s: db.search("aid=%s" % s)['adherent'][0], club.imprimeurs())
|
||
if len(liste) == 1:
|
||
# Une seule réponse
|
||
choix = liste[0]
|
||
else:
|
||
# Il faut choisir
|
||
while 1:
|
||
os.system('clear')
|
||
choix = None
|
||
print "Ce club a plusieurs imprimeurs :"
|
||
aff(liste)
|
||
i = affich_tools.prompt(u'Votre choix ? (0 pour annuler) aid =')
|
||
if i == '0': break
|
||
for v in liste:
|
||
if v.id() == i:
|
||
choix = v
|
||
break
|
||
if not choix:
|
||
# Redemande le choix
|
||
print 'Choix invalide'
|
||
continue
|
||
if choix: break
|
||
|
||
if not choix:
|
||
continue
|
||
|
||
arg = u'--title "Enlever un imprimeur" '
|
||
arg += u'--yesno "Enlever l\'imprimeur %s ? \n\n" 0 0' % choix.Nom()
|
||
no, res = dialog(arg)
|
||
if not no:
|
||
if club.imprimeurs(retirer=str(choix.id())):
|
||
arg = u'--title "Enlever un imprimeur" '
|
||
arg += u'--msgbox "Imprimeur enlevé\n\n\n" 0 0'
|
||
dialog(arg)
|
||
else:
|
||
arg = u'--title "Enlever un imprimeur" '
|
||
arg += u'--msgbox "Cet adhérent n\'est pas imprimeur du club !\n\n\n" 0 0'
|
||
dialog(arg)
|
||
|
||
elif res[0] == 'Ajouter':
|
||
newimp = select(club, u'd\'un nouvel imprimeur a', 'ro')
|
||
if newimp:
|
||
if club.imprimeurs(ajouter=str(newimp.id())):
|
||
arg = u'--title "Ajout imprimeur" '
|
||
arg += u'--msgbox "Imprimeur ajouté\n\n\n" 0 0'
|
||
dialog(arg)
|
||
else:
|
||
arg = u'--title "Ajout imprimeur" '
|
||
arg += u'--msgbox "Cet adhérent est déjà imprimeur !\n\n\n" 0 0'
|
||
dialog(arg)
|
||
continue
|
||
|
||
def set_club_nom(club):
|
||
# Nom du club
|
||
arg = u'--title "Nom" '
|
||
arg += u'--inputbox "Nom du club ?" 0 0 "%s"' % club.Nom()
|
||
annul, res = dialog(arg)
|
||
if annul: return 1
|
||
else:
|
||
try:
|
||
club.Nom(res[0])
|
||
except ValueError, c:
|
||
arg = u'--title "Nom club" '
|
||
arg += u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
||
dialog(arg)
|
||
|
||
def set_local(club):
|
||
""" Défini le local d'un club """
|
||
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()
|
||
# on tri par ordre alphébétique avec 'EXT' à la fin
|
||
key.pop(key.index('EXT'))
|
||
key.sort()
|
||
key.append('EXT')
|
||
for k in key:
|
||
arg += u'"%s" "%s" ' % (k, locaux[k])
|
||
annul, result = dialog(arg)
|
||
if annul: return 1
|
||
else:
|
||
club.chbre(result[0])
|
||
|
||
|
||
def set_club_compte(club):
|
||
"""
|
||
Créé un compte sur vert pour un club.
|
||
"""
|
||
|
||
while 1:
|
||
arg = u'--title "Création d\'un compte crans pour %s" ' % club.Nom()
|
||
arg += u'--inputbox "Choix du login\n'
|
||
arg += u'Le nom pour le login doit faire au maximum %s caractères\n' % config.maxlen_login
|
||
arg += u'Le login sur ssh sera club-\'nom du club\'\n'
|
||
arg += u'Le site web du club sera accessible via l\'adresse http://clubs.ens-cachan.fr/\'nom du club\'\n'
|
||
arg += u'Seuls les caractères alphabétiques et le - sont autorisés" '
|
||
arg += u'0 0 ""'
|
||
annul, result = dialog(arg)
|
||
if annul: return 1
|
||
login = result[0]
|
||
|
||
e = 0
|
||
try: login = club.compte(login)
|
||
except EnvironmentError, c: e = c.args[0]
|
||
except ValueError, c: e = c.args[0]
|
||
if e:
|
||
arg = u'--title "Création compte crans pour %s" ' % club.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 du club est : %s@crans.org\n" % login
|
||
|
||
txt += u'\n'
|
||
|
||
arg = u'--title "Création compte crans pour %s" ' % club.Nom()
|
||
arg += u'--colors --msgbox "%s\n\n\n" 0 0' % txt
|
||
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)
|
||
else:
|
||
return __prompt_input_menu(method, titre, prompt)
|
||
|
||
def set_solde(clas):
|
||
""" Débit ou crédit d'un compte """
|
||
while 1:
|
||
arg = u'--title "Crédit / débit du compte de %s" ' % clas.Nom()
|
||
arg += u'--inputbox "Solde actuel : %s\n Opération à effectuer (+ pour crédits et - pour débit) ?" 0 0 "" ' % clas.solde()
|
||
annul, res = dialog(arg)
|
||
if annul: return 1
|
||
|
||
# Ajout du commentaire
|
||
arg = u'--title "Crédit / débit du compte de %s" ' % clas.Nom()
|
||
arg += u'--inputbox "Commentaire à insérer ?" 0 0'
|
||
annul, comment = dialog(arg)
|
||
|
||
if not annul:
|
||
if comment[0]:
|
||
comment = comment[0]
|
||
else:
|
||
comment = None
|
||
|
||
try:
|
||
clas.solde(res[0], comment)
|
||
db.services_to_restart('mail_solde', ['%s a fait %s euros pour %s [%s]' %(script_utilisateur, res[0],clas._data['uid'][0], comment)])
|
||
break
|
||
except ValueError, c:
|
||
arg = u'--title "Opération impossible" '
|
||
arg += u'--msgbox "%s\n\n\n" 0 0' % c.args[0]
|
||
dialog(arg)
|
||
|
||
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(u"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(u"Appuyez sur ENTREE pour continuer")
|
||
|
||
def set_blackliste(clas):
|
||
""" Édite ou ajoute un item de la blackliste """
|
||
bl = clas.blacklist()
|
||
if not bl:
|
||
# Pas d'entrée à éditer
|
||
index = -1
|
||
else:
|
||
arg = u'--title "Édition 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:
|
||
champs = b.split('$')
|
||
arg += '"%i" "%s [%s]" ' % (i, champs[2], champs[3])
|
||
i += 1
|
||
annul, res = dialog(arg)
|
||
if annul: return 1
|
||
index = int(res[0]) - 1
|
||
|
||
# Édition
|
||
if index != -1:
|
||
t = clas.blacklist()[index].split('$')
|
||
if t[0] != 'now':
|
||
t[0] = strftime('%d/%m/%Y %H:%M', localtime(int(t[0])))
|
||
if t[1] != 'now' and t[1] != '-':
|
||
t[1] = strftime('%d/%m/%Y %H:%M', localtime(int(t[1])))
|
||
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 hh:mm) ainsi que le commentaire associé\n" 0 0 0 '
|
||
arg += u'"Début : " 1 1 "%s" 1 8 16 0 ' % t[0]
|
||
arg += u'"now pour immédiatement " 1 25 "" 0 0 0 0 '
|
||
arg += u'"Fin : " 2 1 "%s" 2 8 16 0 ' % t[1]
|
||
arg += u'"- pour fin indéterminée" 2 25 "" 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 (pas de dollar) : " 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'
|
||
|
||
# Vérification des heures
|
||
try:
|
||
if t[0] != 'now':
|
||
t[0] = int(mktime(strptime(t[0], '%d/%m/%Y %H:%M')))
|
||
except:
|
||
arg = u'--title "Erreur" '
|
||
arg += u'--msgbox "Heure de début incorrecte (%s)\n\n\n" 0 0' % t[0]
|
||
dialog(arg)
|
||
step -= 1
|
||
continue
|
||
|
||
try:
|
||
if t[1] != 'now' and t[1] != '-':
|
||
t[1] = int(mktime(strptime(t[1], '%d/%m/%Y %H:%M')))
|
||
except:
|
||
arg = u'--title "Erreur" '
|
||
arg += u'--msgbox "Heure de fin incorrecte (%s)\n\n\n" 0 0' % t[1]
|
||
dialog(arg)
|
||
step -= 1
|
||
continue
|
||
|
||
# Commentaire
|
||
c = r[2].strip()
|
||
login = script_utilisateur
|
||
if c:
|
||
if c.split(' :')[0] != login:
|
||
t[3] = login + ' : ' + c
|
||
else:
|
||
t[3] = c
|
||
else:
|
||
t[3] = login
|
||
|
||
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 on_off(condition):
|
||
"""
|
||
Renvoie 'on' ou 'off' selon la condition (pour dialog).
|
||
"""
|
||
if condition:
|
||
return 'on'
|
||
else:
|
||
return 'off'
|
||
|
||
def set_type_de_connexion(adherent):
|
||
"""
|
||
Définition du type de connexion: gratuite limité ou normale.
|
||
"""
|
||
if isinstance(adherent, Club): return
|
||
|
||
annul, result = dlg.menu(u"Type de connexion",
|
||
choices=[("1", u"Connexion normale"),
|
||
("2", u"Connexion gratuite")])
|
||
if annul: return 1
|
||
adherent.adherentPayant(result == "1")
|
||
|
||
def set_admin(proprio):
|
||
"""
|
||
Définition de l'état administratif : carte d'étudiant, paiement
|
||
et caution.
|
||
"""
|
||
# Le proprietaire a-t-il une section carte d'étudiant (pas les clubs) ?
|
||
has_card = proprio.idn != 'cid'
|
||
|
||
# Initialisation des différentes checkbox
|
||
carte = on_off(ann_scol in proprio.carteEtudiant())
|
||
paiement = on_off(ann_scol in proprio.paiement())
|
||
precab = on_off(ann_scol + 1 in proprio.paiement())
|
||
caution = on_off('k' in proprio.controle())
|
||
paiement_ok = on_off('p' in proprio.controle())
|
||
carte_ok = on_off('c' in proprio.controle())
|
||
if has_card: charte_MA = on_off(proprio.charteMA())
|
||
|
||
# Construction de la boîte de dialogue
|
||
texte = []
|
||
checklist = []
|
||
|
||
if has_card:
|
||
if carte_ok == 'off' or iscontroleur:
|
||
checklist.append(u'"1" "Carte d\'étudiant %d/%d fournie" "%s"' %
|
||
(ann_scol, ann_scol+1, carte))
|
||
else:
|
||
texte.append(u'Carte vérifiée')
|
||
|
||
if isinstance(proprio, Club) or proprio.adherentPayant():
|
||
if paiement_ok == 'off' or iscontroleur:
|
||
checklist.append(u'"2" "Cotisation %d/%d réglée et charte signée" "%s"' %
|
||
(ann_scol, ann_scol+1, paiement))
|
||
else:
|
||
texte.append(u'Cotisation/charte vérifiées')
|
||
else:
|
||
texte.append(u'Adhérent non payant')
|
||
|
||
# TODO: controle pour le précâblage
|
||
if config.precab:
|
||
checklist.append(u'"3" "Adhésion %d/%d réglée et charte signée (précâblage)" "%s"' %
|
||
(ann_scol+1, ann_scol+2, precab))
|
||
|
||
if iscontroleur:
|
||
if has_card:
|
||
checklist.append(u'"4" "Carte d\'étudiant vérifiée" "%s"' % carte_ok)
|
||
checklist.append(u'"5" "Cotisation/charte/caution vérifées" "%s"' % paiement_ok)
|
||
|
||
if (isbureau or isadm) and has_card:
|
||
checklist.append(u'"6" "Charte des MA signee" "%s"' % charte_MA)
|
||
|
||
if not checklist:
|
||
# Il n'y a rien de modifiable
|
||
dialog(u'--title "État administratif de %s non modifiable" --msgbox "%s\n" 0 0 ' %
|
||
(proprio.Nom(), '\n'.join(texte)))
|
||
return
|
||
|
||
|
||
# Il y a qqch de modifiable, on construit la checklist
|
||
arg = u'--title "Etat administratif de %s" ' % proprio.Nom()
|
||
arg += u'--separate-output '
|
||
arg += u'--checklist "%s\n" 0 0 0 ' % '\n'.join(texte)
|
||
arg += u' '.join(checklist)
|
||
|
||
annul, result = dialog(arg)
|
||
if annul: return 1
|
||
|
||
# Traitement
|
||
if has_card:
|
||
if '1\n' in result:
|
||
proprio.carteEtudiant(ann_scol)
|
||
elif iscontroleur or carte_ok == 'off':
|
||
proprio.carteEtudiant(-ann_scol)
|
||
if '4\n' in result:
|
||
proprio.controle('+c')
|
||
elif iscontroleur:
|
||
proprio.controle('-c')
|
||
|
||
if '2\n' in result and ann_scol not in proprio.paiement():
|
||
# On est en train de renouveller l'adhésion
|
||
# Combien a-t-il de machines ?
|
||
if proprio.idn != 'cid' and len(proprio.machines_fixes()) > 1 and not proprio.droits():
|
||
# Il a plus d'une machine fixe et n'est pas membre actif
|
||
arg = u'--title "Trop de machines fixes" '
|
||
arg += u'--menu " Cet adhérent a trop de machines fixes.\n\n'
|
||
arg += u'Seuls les membres actifs peuvent posséder plusieurs\n'
|
||
arg += u'machines fixes. L\'adhérent actuel n\'est pas membre\n'
|
||
arg += u'actif, il n\'est donc pas possible de lui laisser autant\n'
|
||
arg += u'de machines fixes..." 0 0 0 '
|
||
arg += u'"OK" "OK, je vais lui virer des machines" '
|
||
annul, result = dialog(arg)
|
||
if not annul and result[0] == "Si":
|
||
proprio.paiement(ann_scol)
|
||
else:
|
||
set_admin(proprio)
|
||
return
|
||
else:
|
||
proprio.paiement(ann_scol)
|
||
elif '2\n' not in result and (paiement_ok == 'off' or iscontroleur):
|
||
proprio.paiement(-ann_scol)
|
||
|
||
if '3\n' in result:
|
||
proprio.paiement(ann_scol+1)
|
||
elif paiement_ok == 'off' or iscontroleur:
|
||
proprio.paiement(-ann_scol-1)
|
||
|
||
if '5\n' in result:
|
||
proprio.controle('+p')
|
||
elif iscontroleur:
|
||
proprio.controle('-p')
|
||
|
||
if has_card:
|
||
if '6\n' in result:
|
||
proprio.charteMA(True)
|
||
elif isadm or isbureau:
|
||
proprio.charteMA(False)
|
||
|
||
if 'C\n' in result:
|
||
proprio.controle('+k')
|
||
if not iscontroleur:
|
||
proprio.controle('-p')
|
||
elif iscontroleur:
|
||
proprio.controle('-k')
|
||
|
||
###############################################################
|
||
## Fonctions de remplissage ou modification des paramètres club
|
||
|
||
def new_club(club):
|
||
step = 1
|
||
while 1:
|
||
|
||
if step == 1:
|
||
# Responsable
|
||
if set_responsable(club): return 1
|
||
else: step += 1
|
||
|
||
if step == 2:
|
||
# Nom du club
|
||
if set_club_nom(club): step -= 1
|
||
else: step += 1
|
||
|
||
if step == 3:
|
||
# Local
|
||
if set_local(club): step -= 1
|
||
else: 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 modif_club(club):
|
||
"""
|
||
Modification du club fourni (instance de club)
|
||
Retourne 1 si annulation.
|
||
"""
|
||
arg = u'--title "Modification du club %s" ' % club.Nom()
|
||
arg += u'--menu "Que souhaitez vous modifier ?" 0 0 0 '
|
||
arg += u'"NomClub" "Modifier le nom du club" '
|
||
arg += u'"Responsable" "Changer le responsable du club %s" ' % club.responsable().Nom()
|
||
arg += u'"Imprimeurs" "Changer la liste des imprimeurs" '
|
||
arg += u'"Administratif" "Précâblage" '
|
||
arg += u'"Local" "Modifier le local du club" '
|
||
arg += u'"Compte" "Créer un compte crans." '
|
||
if club.compte():
|
||
arg += u'"Alias" "Créer ou supprimer un alias mail" '
|
||
if isdeconnecteur:
|
||
arg += u'"Blackliste" "Modifier la blackliste du club" '
|
||
if isimprimeur:
|
||
arg += u'"Solde" "Effectuer un débit/crédit pour ce club" '
|
||
|
||
arg += u'"Remarque" "Ajouter ou modifer un commentaire" '
|
||
annul, res = dialog(arg)
|
||
|
||
if annul: return 1
|
||
|
||
elif res[0] == 'NomClub':
|
||
set_club_nom(club)
|
||
elif res[0] == 'Responsable':
|
||
set_responsable(club)
|
||
elif res[0] == 'Imprimeurs':
|
||
set_imprimeurs(club)
|
||
elif res[0] == 'Administratif':
|
||
set_admin(club)
|
||
elif res[0] == 'Compte':
|
||
set_club_compte(club)
|
||
elif res[0] == 'Remarque':
|
||
set_rque(club)
|
||
elif res[0] == 'Blackliste':
|
||
set_blackliste(club)
|
||
elif res[0] == 'Local':
|
||
set_local(club)
|
||
elif res[0] == 'Alias':
|
||
__prompt_input_menu(club.alias, 'Alias mail', "Entrez ou modifier un alias mail.\nPour ajouter un alias modifier le dernier de la liste.")
|
||
elif res[0] == 'Solde':
|
||
set_solde(club)
|
||
|
||
if club.modifs:
|
||
return confirm(club)
|
||
|
||
def select_club(clas):
|
||
""" Choix d'un club """
|
||
arg = u'--title "Recherche d\'un club" '
|
||
|
||
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_wifi(machine):
|
||
"""
|
||
Définition des paramètres spécifiques d'une borne wifi :
|
||
* Canaux
|
||
* Puissance
|
||
* Position GPS
|
||
* Variables nvram
|
||
* hotspot
|
||
"""
|
||
if not isadm:
|
||
#ça ne devrait jamais arriver mais on n'est jamais trop prudent
|
||
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()
|
||
|
||
# Construction de la boite de dialogue
|
||
arg = u'--title "Paramètres spécifiques wifi de "%s"" ' % (nom)
|
||
arg += u'--form "" 0 0 0 '
|
||
# Borne wifi
|
||
arg += u'"Canaux :" 1 1 "%s" 1 14 10 0 ' % machine.canal(None, False)
|
||
arg += u'"Puissance :" 2 1 "%s" 2 14 4 0 ' % machine.puissance()
|
||
try:
|
||
arg += u'"Position N :" 3 1 "%s" 3 14 12 0 ' % machine.position()[0]
|
||
arg += u'"Position E :" 3 29 "%s" 3 42 12 0 ' % machine.position()[1]
|
||
except:
|
||
arg += u'"Position N :" 3 1 "%s" 3 14 12 0 ' % ""
|
||
arg += u'"Position E :" 3 29 "%s" 3 42 12 0 ' % ""
|
||
|
||
arg += u'"Hotspot :" 4 1 "%s" 4 10 5 0 ' % (machine.hotspot() and 'oui' or 'non')
|
||
arg += u'"Nvram (cf wiki) :" 5 1 "%s" 6 1 100 0 ' % ', '.join(machine.nvram())
|
||
|
||
# Affichage
|
||
annul, result = dialog(arg)
|
||
if annul: return 1
|
||
|
||
# Traitement
|
||
err = ''
|
||
try: machine.canal(result[0])
|
||
except ValueError, c: err += c.args[0] + '\n'
|
||
|
||
try: machine.puissance(result[1])
|
||
except ValueError, c: err += c.args[0] + '\n'
|
||
|
||
try:
|
||
#On n'enregistre pas une position vide
|
||
if result[2].strip() and result[3].strip():
|
||
if result[2].strip().lower() == "none" or result[3].strip().lower() == "none":
|
||
machine.position(None)
|
||
else:
|
||
machine.position((result[2].strip(),result[3].strip()))
|
||
except ValueError, c: err += c.args[0] + '\n'
|
||
|
||
if result[4].lower().strip() == "oui":
|
||
machine.hotspot(True)
|
||
elif result[4].lower().strip() == "non":
|
||
machine.hotspot(False)
|
||
else:
|
||
err += "Les valeurs possibles pour le parametre hotspot\n sont \"oui\" ou \"non\"\n"
|
||
|
||
try:
|
||
#On vérifie toutes les variables avant de sauvegarder
|
||
for nvram in result[5].split(','):
|
||
if len(nvram.strip()): #On évite les variables vides
|
||
if not '=' in nvram:
|
||
raise ValueError("Une variable nvram doit etre de la forme : 'variable=valeur'\n")
|
||
for nvram in result[5].split(','):
|
||
if len(nvram.strip()): #On évite les variables vides
|
||
variable = nvram.split('=')[0].strip()
|
||
valeur = nvram.split('=')[1].strip()
|
||
if valeur.lower() == "none":
|
||
valeur=None
|
||
machine.nvram(variable, valeur)
|
||
except ValueError, c: err += c.args[0] + '\n'
|
||
# Des erreurs ?
|
||
if err:
|
||
arg = u'--title "Paramètres machine wifi" '
|
||
arg += u'--msgbox "%s\n\n" 0 0' % err
|
||
dialog(arg)
|
||
# On redemande
|
||
return set_wifi(machine)
|
||
|
||
if machine.modifs and confirm(machine):
|
||
return set_wifi(machine)
|
||
|
||
def set_machine(machine):
|
||
"""
|
||
Définition des paramètres d'une machine :
|
||
* Nom de machine
|
||
* Adresse MAC
|
||
* IP
|
||
* ports ouverts si adm
|
||
"""
|
||
if machine.proprietaire().__class__ == AssociationCrans:
|
||
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 ' % ' '.join(machine.portTCPin())
|
||
arg += u'"PortsTCP machine->ext :" 5 1 "%s" 5 25 50 0 ' % ' '.join(machine.portTCPout())
|
||
arg += u'"PortsUDP ext->machine :" 6 1 "%s" 6 25 50 0 ' % ' '.join(machine.portUDPin())
|
||
arg += u'"PortsUDP machine->ext :" 7 1 "%s" 7 25 50 0 ' % ' '.join(machine.portUDPout())
|
||
if isadm and machine.proprietaire().__class__ == AssociationCrans:
|
||
arg += u'"Prise :" 8 1 "%s" 8 9 5 0 ' % machine.prise()
|
||
|
||
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 c.args[1] == 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'
|
||
elif len(c.args)>1 and c.args[1] == 3 and isadm:
|
||
# Mac douteuse
|
||
arg = u'--title "Adresse MAC" '
|
||
arg += u'--yesno "L\'adresse MAC ne correspond à aucun constructeur, 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.__str__() + '\n'
|
||
except RuntimeError, c: err += c.args[0] + '\n' # Plus d'IP libres, peut-être à traiter differement ?
|
||
|
||
if isadm:
|
||
try:
|
||
machine.portTCPin(result[3].split())
|
||
machine.portTCPout(result[4].split())
|
||
machine.portUDPin(result[5].split())
|
||
machine.portUDPout(result[6].split())
|
||
except ValueError, c: err += c.args[0] + '\n'
|
||
|
||
if isadm and machine.proprietaire().__class__ == AssociationCrans:
|
||
try: machine.prise(result[-1])
|
||
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 machine.modifs and confirm(machine):
|
||
return set_machine(machine)
|
||
|
||
def set_machine_exemption(machine):
|
||
"""Définit les réseau exemptés de comptage d'upload pour la machine"""
|
||
if __prompt_input_menu(machine.exempt, u'Exemption', u"Ajouter ou modifier un réseau/une ip vers lequel on ne compte pas l'upload (format x.y.z.t[/m])\nPour ajouter un réseau modifier la fin de la liste.") or confirm(machine):
|
||
machine.restore()
|
||
return 1
|
||
|
||
def set_machine_alias(machine):
|
||
"""Définit la liste des alias d'une machine"""
|
||
if __prompt_input_menu(machine.alias, 'Alias machine', "Entrez ou modifier un alias machine.\nPour ajouter un alias modifier le dernier de la liste.") or confirm(machine):
|
||
machine.restore()
|
||
return 1
|
||
|
||
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 "ERREUR n°%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 new_adher(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.
|
||
"""
|
||
|
||
while True:
|
||
if set_bases(adher): return 1
|
||
|
||
steps = [set_etudes,
|
||
set_type_de_connexion,
|
||
set_admin,
|
||
set_mail,
|
||
set_rque]
|
||
|
||
step = 0
|
||
while step < len(steps):
|
||
if steps[step](adher): step -= 1
|
||
else: step += 1
|
||
|
||
if not confirm(adher): 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:
|
||
payant = not isinstance(adher, Club) and adher.adherentPayant()
|
||
|
||
arg = u'--title "Modification de %s" ' % adher.Nom()
|
||
arg += u'--menu "Que souhaitez vous modifier ?" 0 0 0 '
|
||
arg += u'"Administratif" "Précâblage, carte d\'étudiant, études" '
|
||
if not payant:
|
||
arg += u'"Connexion" "Changer de type de connexion(gratuit->payant)" '
|
||
if adher.compte(): changement_compte = u", compte sur zamok"
|
||
else: changement_compte = u""
|
||
arg += u'"État-civil" "Nom, prénom%s" ' % changement_compte
|
||
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" '
|
||
if payant:
|
||
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:
|
||
if 'cransAccount' in adher._data['objectClass']:
|
||
arg += u'"Droits" "Modifier les droits alloués à cet adhérent" '
|
||
if 'posixAccount' in adher._data['objectClass']:
|
||
arg += u'"Shell" "Changer le shell de cet utilisateur" '
|
||
if isbureau and 'Nounou' not in adher.droits():
|
||
arg += u'"Droits" "Modifier les droits alloués à cet adhérent" '
|
||
if isdeconnecteur:
|
||
arg += u'"Blackliste" "Modifier la blackliste de cet adhérent" '
|
||
if isimprimeur:
|
||
arg += u'"Solde" "Effectuer un débit/crédit pour cet adhérent" '
|
||
|
||
annul, res = dialog(arg)
|
||
|
||
if annul: return 1
|
||
|
||
if res[0] == 'Etudes':
|
||
set_etudes(adher)
|
||
elif res[0] == 'État-civil':
|
||
set_etat_civil(adher)
|
||
elif res[0] == 'Administratif':
|
||
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] == 'Charte des MA' :
|
||
set_charte_MA(adher)
|
||
elif res[0] == 'Connexion':
|
||
if dlg.yesno(u"Passer à un compte payant ?") == 0:
|
||
# On attribue une ip à toute les machines
|
||
for m in adher.machines():
|
||
m.ip("<automatique>")
|
||
adher.adherentPayant(True)
|
||
elif res[0] == 'Adresse' or res[0] == 'Chambre':
|
||
arg = u'--title "Déménagement de %s" ' % adher.Nom()
|
||
arg += u'--menu "Question :" 0 0 0 '
|
||
arg += u'"1" "Déménagement sur le campus ? " '
|
||
arg += u'"2" "Déménagement à l\'extérieur en conservant les machines ?" '
|
||
arg += u'"3" "Départ du campus en conservant son compte ?" '
|
||
arg += u'"4" "Départ du campus en supprimant son compte ?" '
|
||
annul, result = dialog(arg)
|
||
if annul: return 1
|
||
if result[0] == '2':
|
||
if set_addr_ext(adher):
|
||
# Annulation
|
||
return modif_adher(adher)
|
||
adher.chbre('EXT')
|
||
elif result[0] == '3':
|
||
arg = u'--title "Départ de %s" ' % adher.Nom()
|
||
arg += u'--yesno "Le départ d\'un adhérent provoque la destruction de ses machines.\n'
|
||
arg += u'\nDoit-on continuer ?" 0 0'
|
||
no, res = dialog(arg)
|
||
if no: return modif_adher(adher)
|
||
for m in adher.machines():
|
||
m.delete("Depart du campus")
|
||
adher.chbre('EXT')
|
||
elif result[0] == '4':
|
||
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 modif_adher(adher)
|
||
arg = u'--title "Départ de %s" ' % adher.Nom()
|
||
arg += u'--yesno "Le départ du campus de %s va provoquer la destruction de son compte.\n' % adher.Nom()
|
||
arg += u'\nDoit-on continuer ?" 0 0'
|
||
no, res = dialog(arg)
|
||
if no: return modif_adher(adher)
|
||
for m in adher.machines():
|
||
m.delete("Depart du campus")
|
||
adher.delete("Depart du campus")
|
||
return
|
||
|
||
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 modif_adher(adher)
|
||
|
||
e = _set_chbre(adher, res[0])
|
||
if res[0] == 'EXT':
|
||
# Il faut demander l'adresse extérieure
|
||
if set_addr_ext(adher):
|
||
# Annulation
|
||
continue
|
||
if e:
|
||
arg = u'--title "Déménagement de %s" ' % adher.Nom()
|
||
arg += u'--msgbox "%s\n\n\n" 0 0' % e
|
||
dialog(arg)
|
||
else:
|
||
break
|
||
|
||
|
||
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 modif_adher(adher)
|
||
|
||
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 modif_adher(adher)
|
||
|
||
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)
|
||
|
||
elif res[0] == 'Solde':
|
||
set_solde(adher)
|
||
|
||
if adher.modifs:
|
||
return confirm(adher)
|
||
|
||
def modif_machine(machine):
|
||
"""
|
||
Modification de la machine fournie (instance de machine)
|
||
Retourne 1 si annulation.
|
||
"""
|
||
|
||
if not isadm:
|
||
step = 1
|
||
while 1:
|
||
|
||
if step == 1:
|
||
if set_machine(machine): return 1
|
||
else: step = 2
|
||
|
||
if step == 2:
|
||
if set_rque(machine): step = 1
|
||
else: return
|
||
|
||
else:
|
||
arg = u'--title "Modification de %s" ' % machine.nom()
|
||
arg += u'--menu "Que souhaitez vous modifier ?" 0 0 0 '
|
||
arg += u'"Informations" "Modifier le nom de machine, l\'IP, adresse MAC" '
|
||
arg += u'"Blackliste" "Modifier la blacklist de la machine" '
|
||
arg += u'"Alias" "Créer ou supprimer un alias de la machine" '
|
||
arg += u'"Exemptions" "Modifier la liste d\'exemption d\'upload de la machine" '
|
||
arg += u'"Remarques" "Ajouter ou supprimer une remarque de la machine" '
|
||
if isinstance(machine, BorneWifi) and isadm:
|
||
# Borne wifi
|
||
arg += u'"Wifi" "Modifier les paramètres spécifiques aux bornes wifi" '
|
||
|
||
|
||
|
||
annul, res = dialog(arg)
|
||
|
||
if annul: return 1
|
||
|
||
if res[0] == 'Informations':
|
||
set_machine(machine)
|
||
return
|
||
elif res[0] == 'Blackliste':
|
||
set_blackliste(machine)
|
||
elif res[0] == 'Alias':
|
||
set_machine_alias(machine)
|
||
elif res[0] == 'Exemptions':
|
||
set_machine_exemption(machine)
|
||
elif res[0] == 'Remarques':
|
||
set_rque(machine)
|
||
elif res[0] == 'Wifi':
|
||
set_wifi(machine)
|
||
if machine.modifs:
|
||
return confirm(machine)
|
||
|
||
|
||
########################################################################
|
||
## 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().decode(encoding)
|
||
if not i: i= u'*'
|
||
s.append(i)
|
||
|
||
### Contruction de la chaîne de recherche
|
||
filtre_adher = u'nom=%s&prenom=%s&tel=%s&chbre=%s&aid=%s&mail=%s&' % tuple(s[:6])
|
||
filtre_machine = u'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__ == AssociationCrans):
|
||
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)
|
||
i = affich_tools.prompt(u'Votre choix ? (0 pour annuler) %sid =' % quoi)
|
||
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(u'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
|
||
"""
|
||
|
||
# que signifient toutes ces initiales ?
|
||
# (a)jouter, (m)odifier, (d)eleter
|
||
# (M)achine, (A)dherent, (C)lub, K=crans, (B)orne
|
||
# (c)ourant = déja selectionné
|
||
|
||
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__ != AssociationCrans:
|
||
arg += u' "Modifier l\'inscription de %s" "" ' % proprio.Nom()
|
||
arg += u'"aMc" "Ajouter une machine à %s" "" ' % proprio.Nom()
|
||
if becane:
|
||
arg += u'"mMc" "Modifier la machine %s" "Modification du nom, de l\'IP, de la MAC, des alias, des exemptions..." ' % 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" "Suppression 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." '
|
||
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" "Suppression du club ainsi que de ses machines" '
|
||
if isadm:
|
||
arg += u'"" "---------------------------------------" "" '
|
||
if isadm:
|
||
arg += u'"aKM" "Ajouter une machine à l\'association" "" '
|
||
arg += u'"aKB" "Ajouter une borne wifi" "" '
|
||
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 new_adher(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 == 'aC':
|
||
# Ajout d'un club
|
||
proprio = Club()
|
||
if new_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 == 'aKM':
|
||
# Ajout machine au crans
|
||
becane = MachineCrans(AssociationCrans(db.conn))
|
||
if set_machine(becane):
|
||
becane.restore()
|
||
|
||
elif choix == 'aKB':
|
||
# Ajout borne wifi
|
||
becane = BorneWifi(AssociationCrans(db.conn))
|
||
if set_machine(becane):
|
||
becane.restore()
|
||
|
||
##############################################
|
||
|
||
if choix == 'aMc':
|
||
# Ajout d'une machine à l'adhérent/au club courant
|
||
|
||
# On ne peut avoir de machine fixe si on n'a pas payé
|
||
# la caution
|
||
caution_ok = 'k' in proprio.controle()
|
||
|
||
# On ne peut avoir une machine fixe que si on a pas
|
||
# déjà une machine fixe, sauf si on est membre actif
|
||
# (expérimental)
|
||
|
||
if not isinstance(proprio, Club) and not proprio.adherentPayant():
|
||
# Les gens qui ne paient pas n'ont le droit qu'à une
|
||
# seule machine fixe
|
||
if proprio.machines_fixes():
|
||
dlg.msgbox(u"Le type de compte de cet adhérent ne lui permet pas d'avoir de machine suplémentaire")
|
||
continue
|
||
else:
|
||
choix = "Fixe"
|
||
elif isinstance(proprio, Club) or not proprio.machines_fixes() or proprio.droits() or proprio.etudes(0) == 'Personnel ENS':
|
||
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]
|
||
else:
|
||
# Plus de machine fixe possible...
|
||
arg = u'--title "Nouvelle machine" '
|
||
arg += u'--menu " Non membre actif\n\n'
|
||
arg += u'Seuls les membres actifs peuvent posséder plusieurs\n'
|
||
arg += u'machines fixes. L\'adhérent actuel n\'est pas membre\n'
|
||
arg += u'actif, il n\'est donc possible que de lui ajouter une\n'
|
||
arg += u'machine wifi..." 0 0 0 '
|
||
arg += u'"OK" "OK, on lui rajoute une machine wifi" '
|
||
arg += u'"Annul" "Bon, on abandonne..." '
|
||
annul, result = dialog(arg)
|
||
if annul or result[0] == "Annul": continue
|
||
if result[0] == "OK":
|
||
choix = 'Wifi'
|
||
else:
|
||
choix = 'Fixe'
|
||
try:
|
||
if choix == 'Fixe':
|
||
becane = MachineFixe(proprio)
|
||
elif choix == 'Wifi':
|
||
becane = MachineWifi(proprio)
|
||
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 modif_machine(becane):
|
||
# Annulation des modifs
|
||
becane.restore()
|
||
|
||
elif choix == 'mCc':
|
||
# Modif club courant
|
||
if modif_club(proprio):
|
||
# Annulation des modifs
|
||
proprio.restore()
|
||
|
||
os.system('clear')
|
||
|
||
def killed(a, z):
|
||
sys.exit(254) # Va tomber dans les exceptions
|
||
|
||
if __name__ == '__main__':
|
||
global 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
|
||
|
||
if isadm:
|
||
debug = 1
|
||
|
||
# Phase principale
|
||
try:
|
||
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 s'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: %s
|
||
To: %s
|
||
Subject: Bugreport %s
|
||
|
||
""" % (From, ','.join(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(strftime('%M'))
|
||
# Restart toutes les 10 min : 03, 13, 23, 33, 43, 53
|
||
t = (13 - mn % 10) % 10 + 1 # Certaines machines le font -Aà 4-b
|
||
if t == 0: t = 10
|
||
print "Les modifications apportées à la base seront prises en compte dans %i min environ." % t
|
||
if debug:
|
||
print "Les services suivants seront redémarrés: "
|
||
for s in serv:
|
||
print '\t%s' % s
|
||
|
||
if debug: print '-*- Fin -*-'
|
||
|
||
# Rétablissement du Ctrl-C
|
||
signal.signal(signal.SIGINT, signal.SIG_DFL)
|
||
sys.exit(exit)
|
||
|