Serveur – Module principal

Script principal du serveur d’écoute de la Note Kfet 2015 Codé par 20-100, inspiré du protocole client/serveur de la webradio codé par Michou.

Author: Vincent Le Gallic <legallic@crans.org>

Dans ce fichier sont définies les classes suivantes :

• Server (un serveur qui répond à un unique client)
• MainServer (serveur qui attend les connexions entrantes et thread des instances de Server)

Si ce script est exécuté en tant que __main__, il instancie un MainServer et le lance.

Serveur.default_output_encoding = 'UTF-8'

Encodage qu’on utilise pour faire un print

class Serveur.Server(idServer, sock, address, auth, exiting)

Bases: object

Classe du serveur. Répond à un seul client.

_debug(debuglevel, text=u'')

Affiche des informations de debug.

_log(fonction, cur, params='', relevant_ids=[])

Enregistre une action dans la table de log. Fournir le curseur n’est pas facultatif et il n’est pas COMMITé.

_has_acl(access, surdroit=False, sousdroit=False)

Vérifie que l’utilisateur a le droit access (ou le surdroit si surdroit``est ``True).

_myself(idbde=None)

Vérifie si l’utilisateur courant a accès à ce compte parce que c’est le sien. NB : il doit aussi avoir le droit myself (comme ça on peut se l’enlever volontairement “pour laisser”).

Appelé sans le paramètre idbde, répond simplement si l’utilisateur courant peut accéder à son propre compte.

_refresh_session(droit)

Met à jour les timestamps de dernière action et parfois le cache de droits.

Est appelée à chaque action effectuée par le client.

_kill_session()

Réinitialise les paramètres de session utilisateur.

_has_timeouted(droit='alive')

Vérifie que l’utilisateur n’est pas inactif depuis trop longtemps pour être encore autorisé à utiliser le droit droit.

Avec droit = "alive", vérifie qu’il est encore authentifié.

_handle_duplicate_account(prenom, nom, email, comptes, from_function)

Gère les problèmes commun aux deux fonctions suivantes.

_jsonload(objet)

Charge un objet JSON. Lève une JsonError en cas d’échec.

_recv()

Lit sur la socket jusqu’à ce que l’output soit déJSON-izable

_recv_(size)

Reçoit un message, via ssl.

_send(objet, retcode=0, errormessage=u'')

Fabrique un message, pour envoyer objet avec retcode et errormessage (par défaut, 0 et "")

_send_(msg)

Envoie un message, via ssl. Il est parsé pour gérer les types pgsql, puis JSON-isé avant d’etre envoyé (avec un newline à la fin).

hello(data)

Réponse à un hello.

• Transmet un "ok" si la version du client est acceptée. (Indispensable pour continuer la communication)
• Sinon, transmet la liste des versions acceptées.
• data = "<version du client>"
• data = ["<version du client>", "<IP de l'utilisateur>"]

Seules certaines IPs réelles sont de confiance et autorisées à “cafter” l’IP de l’utilisateur (notamment le client web)

help()

Transmet la liste des commandes.

man(commande)

Transmet de l’aide sur la commande.

login(data)

data = [<username>, <password>, "bdd"/"special", <masque>]

Réponse à un login.

<masque> = acl qu’on ne veut pas avoir pour cette session.

• Pour un “special”, c’est une liste de droits
• Pour un “bdd”, c’est une liste [liste_des_droits, liste_des_surdroits, bool_supreme]

Vérifie que l’utilisateur existe et a les droits suffisants pour se loguer. Transmet les informations sur le compte si c’est le cas. C’est ici que sont rejetés les comptes limités à certaines IPs.

adduser(data)

Ajoute/met à jour un utilisateur spécial.

data = [<user>, <password>, <newacl>] (avec "-" en password pour le laisser inchangé).

deluser(user)

Supprime un utilisateur spécial.

die()

Réponse à un die (arrêt du serveur).

myconnection()

Transmet les infos sur la connection courante.

users()

Transmet la liste des utilisateurs spéciaux existants avec leurs droits.

whowith(data)

Transmet la liste des utilisateurs connectés et leurs ip, port ( + username, userid). En appliquant un filtre conditionnel sur ces attributs.

data = {"ip" : <listip>, "userid" : <listid>, "username" : <listnames>, "client" : <listversions>}, chacune des clés pouvant être absente.

Renvoie les utilisateurs tels que (utilisateur.ip ∈ <listip>) ET (utilisateur.userid ∈ <listid>) …

who()

Donne la liste des utilisateurs connectés et leurs ip, port ( + username, userid) N’est en fait qu’un alias de whowith({}).

whospecial()

Donne la liste des utilisateurs spéciaux connectés (ip, port, username)

whomanualclient()

Donne la liste des utilisateurs connectés en client manuel

whohttpclient()

Donne la liste des utilisateurs connectés en client http

whononeclient()

Donne la liste des utilisateurs connectés sans avoir déclaré leur client

client_speak(data)

Envoie un message à un Server particulier. Peut être appelée par un client (special user only).

client_broadcast(message)

Envoie un message à tous les clients connectés. Peut être appelée par un client (special user only).

search(data)

Fait une recherche sur les comptes. Peut nécessiter les droits full_search en fonction des champs demandés.

data = [<flags>, <liste_de_fields>, <terme_de_recherche>]

ou data = [<flags>, <dico {<field>: <terme_de_recherche>}>]

• les flags possibles sont :

• o : cherche aussi dans les comptes qui ne sont pas à jour d’adhésion
• a : affiche les alias
• A : cherche aussi dans les alias
• h : affiche l’historique des pseudos
• H : cherche aussi dans l’historique des pseudos
• b : ne cherche que les match sur le début du mot (LIKE ‘terme%’)
• i : insensible à la casse (ILIKE)
• x : exact match (LIKE ‘terme’) (le comportement par défaut est LIKE ‘%terme%’) (x écrase b)
• c : recherche conjonctive

• les fields possibles : idbde, pseudo, nom, prenom, mail, fonction, commentaire

• fields nécessitant full_search : tel, adresse, pbsante

Fait recherche sur tous les champs avec les options précisées par les flags. Transmet ensuite la liste des [idbde, nom, prenom, pseudo, mail, solde, section] qui matchent. Les idbde<0 sont ignorés.

quick_search(data)

data = une liste de 1 ou 2 éléments, contenant le terme recherché et éventuellement un flag o, x ou ox

Effectue une recherche simple :

• sur les pseudos, les alias et l’historique
• avec un filtre begin
• case insensitive
• on a juste le choix de préciser old ou pas (par défaut, on ne va pas chercher les comptes non à jour)
• cas particulier : si byidbde est à True, on ne fait rien de tout ça mais on cherche sur les idbde

Ne renvoie que ce qui a matché et l’idbde correspondant et l’appelle "terme" (que ce soit un pseudo, alias ou historique). Ne renvoie pas les comptes bloqués ou supprimés.

Renvoie également le nom/prénom du compte en question. Ainsi que le solde, sauf si hide_solde est à True.

Le paramètre exclude est une liste d’idbde à exclure d’office. Ce paramètre vaut None si aucun résultat ne doit être exclus.

Rajoute également un champ "was" qui peut être "pseudo", "alias" ou "historique". pour qu’on puisse savoir ce qui a matché (pour une mise en forme différente, par exemple)

Donne également des infos sur la négativité du compte, dans le champ "negatif" :

• 0 : en positif
• 1 : solde_negatif > solde > solde_tres_negatif
• 2 : solde_tres_negatif > solde > solde_pas_plus_negatif (forced sera nécessaire)
• 3 : solde_pas_plus_negatif > solde (overforced sera nécessaire)

Les idbde < 0 sont ignorés.

Transmet une liste de dictionnaires (un par résultat).

historique_pseudo(data)

Transmet la liste des anciens pseudos, même ceux qui ne référencent plus le compte.

search_historique_pseudo(data)

Effectue une recherche dans les historiques de pseudos, même ceux qui ne référencent plus le compte.

data = [<terme de recherche>, <filter "b", "x" ou "">]

Transmet la liste de ceux qui ont matché.

whoami()

Transmet la totalité des données de l’utilisateur courant (sauf la photo).

compte(data)

Transmet la totalité des informations du compte demandé (sauf la photo).

get_display_info(data)

data = une liste d’idbde``o``

liste_droits()

Renvoie un dico contenant les personnes ayant des droits differents de juste basic.

adherent(data)

Transmet la totalité des informations du compte demandé (sauf la photo).

get_tarifs_adhesion()

Envoie les prix des adhésions avec ou sans WEI.

chgpass(data)

Change le mot de passe d’un compte.

data = [<idbde>, <nouveau mdp>] (non hashé)

_log relevant ids : idbde

set_passwd(data)

Change le mot de passe d’un compte.

data = [<idbde>, <nouveau mdp>] (non hashé)

_log relevant ids : idbde

generate_reset_password(data)

Envoie un mail contenant un lien permettant de réinitialiser le mot de passe du compte.

data = [<prenom>, <nom>, <mail>]

confirm_reset_password(data)

Change le mot de passe grâce à un token reçu par mail.

data = [<token>, <nouveau mot de passe>]

_log relevant ids : idbde

confirm_email(data)

Confirme l’adresse mail du compte grâce à un token reçu par mail.

data = [<idbde>, <hash>]

_log relevant ids : idbde

update_compte(data)

data = <un dictionnaire>

Modifie le compte.

On ne fournit que les champs qu’on cherche à modifier. Les champs possibles sont :

• "idbde" : ne peut pas être modifié, sert à identifier le compte qu’on cherche à modifier.
• "type" : "personne" ou "club"
• "pseudo" : pseudonyme du compte
• "passwd" : ne peut pas être modifié, utiliser Server.chgpass()
• "nom" : nom de famille de l’adhérent
• "prenom" : prénom de l’adhérent
• "tel" : numéro de téléphone
• "mail" : adresse e-mail pour joindre le détenteur du compte
• "adresse" : adresse de l’adhérent/local du club
• "fonction" : fonction au sein du BDE
• "normalien" : vrai si l’adhérent est normalien (n’a pas vraiment de sens pour les clubs)
• "pbsante" : problème de santé ou allergie alimentaire particulièr-e dont le BDE devrait avoir connaissance (pour le WEI, par exemple)
• "droits" : liste des droits
• "surdroits" : liste des surdroits
• "report_period" : durée (en minutes) entre deux rapports. (-1 = jamais, 0 = dès qu’une transaction a lieu)
• "next_report_date" : date du prochain rapport mail (cf BaseFonctions.isPgsqlDate() pour le format de date)
• "bloque" : si vrai, le compte ne peut plus effectuer de transactions
• "section" : section pour l’année en cours
• "commentaire" : random garbage

_log relevant ids : idbde

supprimer_compte(data)

Place le champ deleted du compte à true.

data = <idbde> ou [<idbde>, True].

Échoue si le solde du compte est non nul. Si le deuxième paramètre est à True, anonymise le compte.

_log relevant ids : idbde

update_photo(data)

data = [<idbde>, <la photo base64-encodée>, <format de la photo>]

Range la photo dans le répertoire des photos après resize/conversion. Insulte si le format de photo n’est pas pris en charge ou si sa taille est trop grande.

get_last_modified_photo(data)

data = <idbde>

Transmet la date (timestamp unix) de dernière modification de la photo n°``<idbde>``.

get_photo(data)

Transmet une photo, en base64.

get_preinscription(data)

data = <preid>

Transmet les informations d’une préinscription.

get_preinscriptions()

Transmet la liste des préinscriptions.

preinscrire(dico)

Enregistre une préinscription.

Les données sont envoyées sous forme d’un dico {"champ": <valeur>} Vérifie que les champs indispensables ("nom", "prenom" et "mail") sont corrects.

_log relevant ids : preid

del_preinscription(data)

data = <preid>

Supprime une préinscription.

_log relevant ids : preid

get_default_pseudo(data)

data = [<nom>, <prénom>]

Transmet le résultat de la génération du pseudo pour ce couple (nom, prénom).

inscrire(data)

Deux possibilités :

• data = [<ident>, <dico>, <pay>, <from_wei>]
• data = [<ident>, <dico>, <pay>, <from_wei>, <override_adh>]

Si <from_wei> est faux, <ident> est une <preid>

• Valide une préinscription. ** <preid> est l’identifiant de préinscription, ** <dico> contient des tas d’infos ("wei" et "annee" étant obligatoires) ** <pay> = [<on_note>, <type_de_paiement>, <params>], avec :

  ** <on_note> = solde à ajouter à la note (en centimes) ** <type_de_paiement> à valeur dans "cheque", "especes", "virement", "soge" ** params = {"nom": <nom>, "prenom": <prenom>, "banque": <banque>}

  ** <overripde_adh> est le montant qu’on veut que l’adhérent paye pour son inscription

  (facultatif, nécessite le droit "adhesions_admin" si différent du montant par défaut)

Sinon <ident> est un <idwei> :

** <idwei> est l’identifiant du wei ** <dico> contient des tas d’infos ** <pay> = [<on_note>, <type_de_paiement>, <params>], avec : plus tard ....

_log relevant ids : preid, idbde, id de la transaction de crédit (ou NULL), id de moyen de paiement (ou NULL), id de la transaction d’adhésion (ou NULL), id de l’adhésion (ou NULL)

readherer(data)

Effectue une réadhésion.

data = un dico

• Clés obligatoires : "idbde", "section".
• Clé facultative : "wei", "pay"
• pay = un dico.

• Clé obligatoire : "type" ("especes", "cheque", "virement")
• Clés conditionnelles : "prenom", "nom", "banque" (à fournir si type est "cheque" ou "virement")
• Clés facutatives : "montant" (par défaut, vaudra le montant de l’adhésion)

_log relevant ids : idbde, id de la transaction de crédit pré-adhésion (ou NULL), id du moyen de paiement (ou NULL), id de la transaction d’adhésion, id de l’adhésion

alias(data)

data = [<idbde>, <alias>]

Ajoute un alias à un compte.

_log relevant ids : idbde, idalias

unalias(data)

data = [<id>, <booléen all>]

• Si all = False : supprime l’alias d’id <id>
• Si all = True : supprime tous les alias du compte d’idbde <id>

_log relevant ids : l’id il faudrait regarder dans la colonne params pour savoir si data contenait un idbde ou un idalias

get_boutons(search_et_categ)

search_et_categ = [<terme>, <categorie>, <flags>]

Transmet la liste (json) des boutons qui matchent le terme de recherche et qui sont dans la catégorie (si elle est différente de "") et qui ont affiche = true

Le paramètre flags est optionnel et peut contenir les drapeaux suivants :

• a (all) –> Cherche parmi _tous_ les boutons (même les non affichés)
• b (begin) –> Matche terme à partir du début du label

get_boutons_categories(all=False)

Transmet la liste des catégories de boutons existantes.

get_un_bouton(data)

data = <id>

Transmet les informations sur le bouton n°``<id>``.

get_clubs()

Transmet la liste des {"idbde : <idbde>, "pseudo": <pseudo>} pour tous les clubs

create_bouton(data)

data = {"label" : <nom du bouton>, "montant" : <prix en centimes>, "destinataire" : <idbde du compte à créditer>, "categorie" : <nom de la catégorie>,              "affiche" : <booléen afficher le bouton ?>, "description" : <description du bouton>, "consigne" : <booléen est-ce une bouteille consignée ?> }

Champs obligatoires : label, montant, destinataire, categorie

Valeur par défaut des champs facultatifs : affiche : True, description : "", consigne : False

Ajoute un bouton. La catégorie doit déjà exister.

(créer des catégories doit se faire en accès direct à la base)

_log relevant ids : idbouton

update_bouton(data)

data = un dictionnaire contenant au moins la clé "id" et pouvant contenir les clés de create_bouton.

Édite le bouton data["id"].

_log relevant ids : idbouton

delete_bouton(ident)

Supprime le bouton n°``ident``.

_log relevant ids : idbouton

crediter(data)

data = [<iddestinataire>, <montant>, <typ_paiement>, <params_pay>]

Fait un crédit (pas de possibilité de faire plusieurs crédits à la fois).

<params_pay> = {"nom": <nom>, "prenom": <prénom>, "banque": <banque>, ["comm"/"commentaire"/"motif" : "plouf plouf"]}

(<params_pay> peut rester vide pour un crédit espèces)

_log relevant ids : idbde du destinataire, id de la transaction, id du moyen de paiement (ou NULL)

credit(data)

data = [<iddestinataire>, <montant>, <typ_paiement>, <params_pay>]

Fait un crédit (pas de possibilité de faire plusieurs crédits à la fois).

<params_pay> = {"nom": <nom>, "prenom": <prénom>, "banque": <banque>, ["comm"/"commentaire"/"motif" : "plouf plouf"]}

(<params_pay> peut rester vide pour un crédit espèces)

_log relevant ids : idbde du destinataire, id de la transaction, id du moyen de paiement (ou NULL)

consos(data)

data = liste de [<idbouton>, <idcompte>, <quantité>]

Fait consommer tous les boutons à tous les comptes.

Transmet une liste de [<retcode>, [<idbouton>, <idbde>], <errmsg>] correspondant au succès des différentes transactions demandées.

transferts(data)

data = [<liste_d'émetteurs>, <liste_de_recepteurs>, <montant>, <motif>]

Effectue le même transfert de chacun des émetteurs vers chacun des destinataires.

Transmet une liste de [<retcode>, [<emetteur>, <destinataire>], <errmsg>] correspondant au succès des différentes transactions (autant que de #émetteurs * #destinataires).

dons(data)

data = [<liste_de_destinataires>, <montant>, <motif>]

Effectue le même don vers chacun des destinataires.

Renvoie une liste de [<retcode>, <iddestinataire>, <errmsg>] correspondant au succès des différentes transactions (une par destinataire).

retirer(data)

data = [<idemetteur>, <montant>, <typ_paiement>, <params_pay>]

Fait un retrait (pas de possibilité de faire plusieurs retraits à la fois).

<params_pay> = {"nom": <nom>, "prenom": <prénom>, "banque": <banque>, ["comm"/"commentaire"/"motif" : "plouf plouf"]}

(<params_pay> peut rester vide pour un retrait espèces).

retrait(data)

data = [<idemetteur>, <montant>, <typ_paiement>, <params_pay>]

Fait un retrait (pas de possibilité de faire plusieurs retraits à la fois).

<params_pay> = {"nom": <nom>, "prenom": <prénom>, "banque": <banque>, ["comm"/"commentaire"/"motif" : "plouf plouf"]}

(<params_pay> peut rester vide pour un retrait espèces).

historique_transactions(data)

Renvoie l’historique des transactions de :

• data = [idbde, num_page, nb] : les nb consos de la page n°``num_page`` du compte idbde
• data = "last" : les consos récentes
• data = ["last", begin, nb] : les nb dernières consos à partir de la n°``begin``

Dans le cas "last", renvoie une liste de transactions. Dans le cas idbde, renvoie un dictionnaire contenant les champs suivants :

• "historique" : la liste des transactions
• "nb_transactions" : le nombre total de transactions pour ce compte
• "nb_pages" : le nombre de pages que ça prendrait en les affichant à nb par page
• "num_page" : le numéro de la page effectivement envoyée (si on charge un numéro trop élevé/négatif, on est ramené à la page max/min)

valider_transaction(data)

Valide une transaction qui était invalidée. Répercute les effets sur les soldes.

devalider_transaction(data)

Invalide une transaction qui était validée. Répercute les effets sur les soldes.

get_activites(data)

data = [<terme de recherche>, <flags>] ou [<terme>] ou <terme>

Transmet la liste des activités.

Les flags :

• m : renvoie seulment les activités soumises par l’utilisateur courant (donne du coup accès aux non validées).
• A : administration (affiche aussi les activités non validées) (A écrase m)
• o : renvoie aussi les activités passées de l’année en cours. (par défaut, donne seulement les activités debut>now()) (o écrase A)

Les flags A et o nécessitent les droits activites_admin

Chaque retour a un champ "invitable" dans lequel on a [<on peut inviter>, <liste de keywords des tests qui ont fail>]. La liste n’étant pas forcément vide dans le cas où on peut inviter (un admin peut bypasser certains tests).

activites(data)

data = [<terme de recherche>, <flags>] ou [<terme>] ou <terme>

Transmet la liste des activités.

Les flags :

• m : renvoie seulment les activités soumises par l’utilisateur courant (donne du coup accès aux non validées).
• A : administration (affiche aussi les activités non validées) (A écrase m)
• o : renvoie aussi les activités passées de l’année en cours. (par défaut, donne seulement les activités debut>now()) (o écrase A)

Les flags A et o nécessitent les droits activites_admin

Chaque retour a un champ "invitable" dans lequel on a [<on peut inviter>, <liste de keywords des tests qui ont fail>]. La liste n’étant pas forcément vide dans le cas où on peut inviter (un admin peut bypasser certains tests).

get_activite(data)

data = <id>

Transmet les informations sur l’activité demandée.

activite(data)

data = <id>

Transmet les informations sur l’activité demandée.

add_activite(data)

Ajoute une activité.

data = un dico avec les clés "debut", "fin", "titre", "lieu", "description", "signature" et "liste"

_log relevant ids : idact

update_activite(data)

Modifie une activité.

data = [<un dico contenant au moins le champs "id">, <flag "A" facultatif>]

Champs possiblement modifiables : "debut", "fin", "titre", "lieu", "description", "signature", "liste", "listeimprimee"

On ne peut modifier une activité que si :

• on en est le responsable et qu’elle n’a pas été validée
• ou bien on a les droits activites_admin (et on les a demandés)

Les champs "listimprimee" et "responsable" nécessitent de toutes façons les droits activites_admin

_log relevant ids : idact

del_activite(data)

data = [<id>, <flag "A" facultatif>]

Supprime une activité.

_log relevant ids : idact

valider_activite(data)

data = <id>

Valider une activité.

NB : N’échoue pas si l’activité n’existe pas ou si elle était déjà validée.

_log relevant ids : idact

devalider_activite(data)

data = <id>

Dévalider une activité.

NB : N’échoue pas si l’activité n’existe pas ou si elle n’était déjà pas validée.

_log relevant ids : idact

add_invite(data)

data = [<data2>, <flag "A" facultatif>]

Ajouter un invité à une activité.

data2 = [<nom>, <prenom>, <id activité>]

ou data2 = [<nom>, <prenom>, <id activité>, <id responsable>] mais il faut les droits invites_admin

Pour pouvoir inviter, il faut :

• que l’activité ait une liste et qu’elle soit validée
• que la liste ne soit pas imprimée
• que l’invité n’existe pas déjà pour cette activité
• si on n’est pas admin, il faut vérifier :

• now() < debut - configurations.liste_invites_closing_time
• now() > debut - configurations.liste_invites_opening_time
• current_user.solde >= configurations.solde_negatif
• current_user a invité strictement moins de configurations.max_invitation_par_personne personnes à cette activité
• <nom>, <prenom> a été invité strictement moins de configurations.max_invitation_par_an fois cette année

_log relevant ids : id de l’invité ajouté, id du responsable de l’invité

del_invite(data)

data = [<id>, <flag "A" facultatif>]

Supprimer un invité.

Évidemment si on n’est pas admin, on ne peut supprimer qu’un invité qu’on a invité soi-même et avant que la liste ne soit imprimée ou fermée.

_log relevant ids : id de l’invité

get_invites(data)

data = [<id de l'activité>, <flag "A" facultatif>]

Afficher les invités.

Avec le flag A, affichera tous les invités, pas seulement ceux invités par le current_user. Renvoie aussi le pseudo du responsable dans le champ "pseudo"

liste_invites(data)

data = [<id de l'activité>, <format de sortie>]

Transmet la liste des invites d’une activités.

Le format de sortie peut être :

• "python" : la liste en format python, (même chose que get_invites)
• "html" : un tableau en html
• "pdf" :

wei_get_info(idwei)

Fonction renvoyant les informations d’un idwei

wei_main()

Fonction donnant tous les droits et toutes les infos nécessaires au fonctionnement basique de l’application WEI.

Ne prend aucun argument.

Renvoie les droits wei, myself, inscriptions, preinscriptions sous la forme d’un dictionnaire de booléen.

wei_get_listes(data)

Fonction renvoyant la liste des préinscrits et des inscrits au WEI.

Prend 1 argument, 1a, qui spécifie où les entrées doivent être recherchées

La réponse est, en fonction des cas:

• Si 1a vaut True :

• liste_1a : liste des inscrits au WEI en 1A

• Sinon, un dictionnaire contenant 2 listes :

• liste_pre : liste des préinscriptions, toutes années confondues
• liste_insc : liste des inscriptions, toutes années confondues

wei_readherer(data)

Effectue la réadhésion d’un 2A+ inscrit au WEI

wei_search(data)

Fonction effectuant les recherches dans la table des inscriptions WEI à partir des champs donnés.

data = [is_pre, id, champs] :

• is_pre : booléen indiquant dans quelle table chercher (1a ou vieux)
• id : idbde du compte appelant la fonction
• champs :dictionnaire contenant les champs de recherche

La réponse est un dictionnaire contenant les champs suivants :

• done : booléen indiquant si le compte effectuant la recherche est déjà (pré)inscrit
• resultats : liste contenant les résultats de la recherche
• etat_demande : indique l’état de l’inscription de l’utilisateur (None si non effectuée, False si non validée, True si validée)

wei_compute_form(data)

Fonction effectuant traitant les données des formulaires d’inscription en fonction du type de formulaire (1A/vieux)

data = ["type", formulaire] :

• type : indique le type de formulaire soumis ('1a' ou 'vieux')
• formulaire est un dictionnaire représentant ledit formulaire.

wei_update_tables(data)

Fonction mettant à jour les statuts d’inscription dans les tables WEI.

data = [operations] :

• operations est un dictionnaire contenant les valeurs des cases cochées dans le formulaire de la liste des inscrits.

Renvoie None dans tous les cas.

wei_modify(data)

Modifie les données d’une entrée des tables WEI à partir des données fournies

data = [idwei, donnees] :

• idwei : id de l’entrée à mettre à jour
• donnees : un dictionnaire contenant les données à injecter dans la table

wei_modify1a(data)

Modifie les données d’une entrée des tables WEI à partir des données fournies

data = [idwei, donnees] :

• idwei : id de l’entrée à mettre à jour
• donnees : dictionnaire contenant les données à injecter dans la table

wei_creer_note(idwei)

Crée une note à partir d’une inscription WEI pour 1A

idwei est le numéro d’inscription WEI dans la table wei_1a

_log relevant ids : idwei, id de la transaction d’adhésion, id de l’adhésion

wei_admin(data)

Traitement des paramètres du WEI modifiés par un GC WEI. data est un dictionnaire de paramètres avec les clés suivantes : * wei_name (str) : Nom du WEI * wei_contact (str) : Adresse de contact * wei_begin (str) : Date de début du WEI * wei_end (str) : Date de fin du WEI * wei_1a_available (bool) : Ouverture des inscriptions 1A * wei_vieux_available (bool) : Ouverture des inscriptions 2A+ * prix_wei_normalien (int) : Prix WEI normalien * prix_wei_non_normalien (int): Prix WEI non normalien

liste_remises()

Renvoie la liste des remises

En sortie : * clos = liste des remises qui sont en cours * non_clos = liste des remises qui sont terminées

remises_open()

Renvoie la liste des idremise non closes

creer_remise(data)

Créé une remise dans la base de donnée.

• data = type_remise, n’est pas utilisé pour le moment.

_log relevant ids : id de la remise

liste_cheques(data)

Renvoie des listes de chèques.

Prend en entrée : * data = [“idremise”, <int>] -> on recherche par idremise * data = [“date”, <date>, <date>] -> on recherche par date

Renvoie en sortie : * un dictionnaire contenant les dates recalculées * une liste de chèques non traites / checked = False * une liste de chèques traites / checked = True

transaction(data)

Renvoie toutes les informations disponibles sur une transaction

• data = idtransaction, l’id de la transaction dont on veut les infos

ajout_remise(data)

Modifie l’état de remise d’une transaction.

• data[“action”] = ajout ou delete
• data contient idremise, idtransaction ainsi que les informations disponibles sur la transaction.

clore_remise(data)

Clos une remise en prenant en compte les dernières modifications.

• data["commentaire"] = <str>
• data["idremise"] = <int>

#TODO y’en a encore

_log relevant ids : id de la remise

infos_remise(data)

Renvoie les informations sur la remise idremise

• data = idremise

django_get_accessible_pages(liste_pages)

Donne la liste des pages accessibles en fonction des droits de l’utilisateur

mayi(data)

Permet de demander si on a tel ou tel droit. (Par exemple utile aux client pour afficher/masquer certaines fonctions dont l’utilisation ne serait pas autorisée.)

• data = <un droit> : transmet si l’utilisateur a le droit <un droit>
• data = "alive" : transmet si l’utilisateur est toujours logué (permet de vérifier qu’on n’a pas timeouté)
• data = "pages" : transmet la liste des pages accessible à l’utilisateur
• data = "droits" ou data = "rights" : transmet la liste des droits existants
• data = "full_rights" : transmet dans un dictionnaire les listes (exhaustives) des droits et surdroits de l’utilisateur

_select(cmd, param=None)

Sélectionne la bonne commande et l’exécute. Transmet une erreur au client si l’exécution est impossibe (commande inexistante, paramètre attendu, …)

_run()

Boucle du serveur.

class Serveur.MainServer

Bases: object

Classe principale.

_debug(debuglevel, text=u'', linejumps=0)

Affiche des informations de debug.

speak(idServer, message, broadcasting=False)

Envoie un message au client d’un Server particulier. Usage MainServer seulement.

Lève une exception si l’idServer n’existe pas. Est appelé par Server.client_broadcast() si le client a les droits.

broadcast(message)

Envoie un message à tous les clients connectés. Usage MainServer uniquement.

Est appelé par Server.client_broadcast() si le client a les droits.

run()

Accepte les connexions.

stopping(reason='(NO REASON ?!!)')

Arrête le serveur en précisant pourquoi.

active_clients()

Retourne le nombre de threads Server.

bind(addr, port)

Ajoute un port à écouter.

reload()

Appelée en cas de SIGHUP

run_as_daemon(outfile)

Utilisé quand le MainServer est lancé en daemon

Serveur.override_configuration()

Parse sys.argv pour potentiellement écraser des variables de configuration de config.py

Serveur.affiche_options()

Affiche les variables de configuration qui peuvent être redéfinies au runtime.

class Serveur.Writer(filename=None)

Bases: object

Pour écrire ailleurs que sur stdout

write(message)

Écrit message dans le Writer

Serveur.closing()

Ferme le fichier de log et termine.

(Comme il est possible qu’on soit lancé en daemon, donc, qu’on ait forké, il ne faut pas appeler cette fonction n’importe où.)