ServeurFonctions – Module contenant toutes les méthodes du Server

Ce module a pour seul but d’être appelé par serveur.py En effet, le code étant trop monolithique, les fonctions sont définies ici et les méthodes de Server sont les fonctions de ce module.

(Attention, de ce fait, une bonne partie de la documentation est dupliquée)

Évidemment elles sont toutes appelées avec comme premier paramètre self.

ServeurFonctions._has_acl(self, access, surdroit=False, sousdroit=False)[source]

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

ServeurFonctions._myself(self, idbde=None)[source]

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.

ServeurFonctions._kill_session(self)[source]

Réinitialise les paramètres de session utilisateur.

ServeurFonctions._refresh_session(self, droit)[source]

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

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

ServeurFonctions._has_timeouted(self, droit='alive')[source]

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é.

ServeurFonctions._pasledroit(self, failacl)[source]

Pour factoriser toutes les réponses “Tu n’as pas le droit...”.

ServeurFonctions._badparam(self, failcmd)[source]

Pour factoriser toutes les réponses “Mauvais paramètre”.

ServeurFonctions.hello(self, data)[source]

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)

ServeurFonctions.help(self)[source]

Transmet la liste des commandes.

ServeurFonctions.man(self, commande)[source]

Transmet de l’aide sur la commande.

ServeurFonctions.die(self)[source]

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

ServeurFonctions.login(self, data)[source]

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.

ServeurFonctions.adduser(self, data)[source]

Ajoute/met à jour un utilisateur spécial.

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

ServeurFonctions.deluser(self, user)[source]

Supprime un utilisateur spécial.

ServeurFonctions.myconnection(self)[source]

Transmet les infos sur la connection courante.

ServeurFonctions.users(self)[source]

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

ServeurFonctions.whowith(self, data)[source]

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>) …

ServeurFonctions.client_speak(self, data)[source]

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

ServeurFonctions.client_broadcast(self, message)[source]

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

ServeurFonctions.search(self, data)[source]

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.

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).

ServeurFonctions._handle_duplicate_account(self, prenom, nom, email, comptes, from_function)[source]

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

ServeurFonctions.generate_reset_password(self, data)[source]

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

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

ServeurFonctions.confirm_reset_password(self, data)[source]

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

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

_log relevant ids : idbde

ServeurFonctions.confirm_email(self, data)[source]

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

data = [<idbde>, <hash>]

_log relevant ids : idbde

ServeurFonctions.get_display_info(self, data)[source]

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

ServeurFonctions.historique_pseudo(self, data)[source]

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

ServeurFonctions.search_historique_pseudo(self, data)[source]

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é.

ServeurFonctions.chgpass(self, data)[source]

Change le mot de passe d’un compte.

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

_log relevant ids : idbde

ServeurFonctions.update_compte(self, data)[source]

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

ServeurFonctions.update_photo(self, data)[source]

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.

ServeurFonctions.get_last_modified_photo(self, data)[source]

data = <idbde>

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

ServeurFonctions.get_photo(self, data)[source]

Transmet une photo, en base64.

ServeurFonctions.whoami(self)[source]

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

ServeurFonctions.compte(self, data)[source]

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

ServeurFonctions.preinscrire(self, dico)[source]

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

ServeurFonctions.get_preinscription(self, data)[source]

data = <preid>

Transmet les informations d’une préinscription.

ServeurFonctions.get_preinscriptions(self)[source]

Transmet la liste des préinscriptions.

ServeurFonctions.del_preinscription(self, data)[source]

data = <preid>

Supprime une préinscription.

_log relevant ids : preid

ServeurFonctions.get_default_pseudo(self, data)[source]

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

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

ServeurFonctions._private_adhesion(self, idbde, annee, debit, section, wei=False, cur=None)[source]

Adhère idbde pour l’année annee.

Enregistre la transaction "Adhésion" et l’adhésion. Update le solde sans faire de vérification. (crédite la note 0). Retourne l’id de la transaction d’adhésion et celui de l’adhésion elle-même.

Si on l’appelle avec cur=<un_curseur>, ce curseur est utilisé et n’est pas COMMITé à la fin.

ServeurFonctions.inscrire(self, data)[source]
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)

ServeurFonctions.__in_cheap_period(self)[source]

Renvoie le booléen correspondant à si on est dans la période pendant laquelle l’adhesion est moins chère

ServeurFonctions.__price_today(self)[source]

Renvoie le prix de l’adhésion correspondant à la période de l’année actuelle

ServeurFonctions.get_tarifs_adhesion(self)[source]

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

ServeurFonctions.readherer(self, data)[source]

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

ServeurFonctions.supprimer_compte(self, data)[source]

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

ServeurFonctions.get_boutons(self, search_et_categ)[source]

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
ServeurFonctions.get_un_bouton(self, data)[source]

data = <id>

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

ServeurFonctions.get_boutons_categories(self, all=False)[source]

Transmet la liste des catégories de boutons existantes.

ServeurFonctions.get_clubs(self)[source]

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

ServeurFonctions.create_bouton(self, data)[source]

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

ServeurFonctions.update_bouton(self, data)[source]

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

ServeurFonctions.delete_bouton(self, ident)[source]

Supprime le bouton n°``ident``.

_log relevant ids : idbouton

ServeurFonctions._insert_transaction(self, typ, idemetteur, iddestinataire, qte, montant, description, categorie, valide, cantinvalidate=False, cur=None)[source]

Met une transaction dans la table et update les soldes émetteur et destinataire si valide = True.

Ne sert qu’à factoriser du code et ne fait absolument aucune vérification. Renvoie l’id de la transaction.

Si on l’appelle avec ``cur=<un_curseur>``, celui-ci est utilisé et n’est pas COMMITé à la fin.

ServeurFonctions._une_transaction(self, typ, idemetteur, iddestinataire, qte, montant, description, categorie='', forced=False, overforced=False, doitanyway=False, justtesting=False, cantinvalidate=False, cur=None)[source]

Effectue la transaction demandée. Ne peut pas être appelée par le client. Ne fait pas de vérification de droits.

Si l’émetteur a un solde trop faible, et que l’utilisateur courant n’a pas les droits nécessaires, la transaction est enregistrée en valide = false.

Ne log rien, ne debug rien (c’est le rôle des fonctions appelantes).

Renvoie une paire :
  • une chaîne de la forme "{ok|failed} : {normal|forced|overforced}[ needed]"
  • l’id de la transaction

On peut l’appeler avec doitanyway à True et alors, pour peu que les comptes existent, on fera la transaction, même si les comptes ne sont pas à jour d’adhésion ou si les droits forced/overforced ne sont pas présents. (Utile pour les adhésions)

Si justtesting est à True, la transaction n’est pas insérée, on répond juste si elle aurait pu être faite.

Si on l’appelle avec ``cur=<un_curseur>``, il est utilisé et n’est pas COMMITé à la fin.

ServeurFonctions._un_credit_ou_un_retrait(self, retrait, mode, compte, montant, commentaire, params_pay, doitanyway, cur=None)[source]

Effectue un crédit ou un retrait (si retrait=True) sans aucune vérification. Pour usage interne. Pour un crédit, retourne une liste contenant l’id de transaction, et l’id de chèque/virement/carte bancaire s’il y a lieu, None sinon. Voir les docs de ServeurFonctions._un_credit() et ServeurFonctions._un_retrait().

ServeurFonctions._un_credit(self, mode, destinataire, montant, commentaire, params_pay={}, doitanyway=False, cur=None)[source]

Aucune vérification, effectue vraiment le crédit. Ne peut pas être appelée par le client.

Update en conséquence les soldes de -1, -2, -3 et du destinataire. Crée le cheque ou le virement si besoin.

  • mode = "cheque", "especes", "virement" ou "soge"
  • params_pay = {"nom": "Passoire", "prenom": "Toto", "banque": s"sogé"}
ServeurFonctions.crediter(self, data)[source]

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)

ServeurFonctions._une_conso(self, successes, idcompte, idbouton, qte, forced=False, overforced=False)[source]

Fait consommer un bouton à un compte. Ne peut pas être appelée par le client.

Ne fait pas de vérification de droits (fait seulement des choses différentes en fonction de forced/overforced/rien).

_log relevant ids : idemetteur, iddestinataire, idbouton, idtransaction

ServeurFonctions.consos(self, data)[source]

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.

ServeurFonctions._un_transfert(self, successes, idemetteur, iddestinataire, montant, qte, motif, forced=False, overforced=False)[source]

Effectue un seul transfert. Ne peut pas être appelée par le client.

Ne fait pas de vérification de droits (fait seulement des choses différentes en fonction de forced/overforced/rien). Renvoie quand même un échec sur des montants<0.

_log relevant ids : idemetteur, iddestinataire, idtransaction

ServeurFonctions.transferts(self, data)[source]

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).

ServeurFonctions._un_don(self, successes, iddestinataire, montant, motif)[source]

Effectue un seul don. Ne peut pas être appelée par le client.

Ne fait pas de vérification de droits, empêche juste de finir en négatif. Renvoie quand même un échec sur des montants<0.

_log relevant ids : idemetteur, iddestinataire, idtransaction

ServeurFonctions.dons(self, data)[source]

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).

ServeurFonctions._un_retrait(self, mode, emetteur, montant, commentaire, params_pay={})[source]

Aucune vérification, effectue vraiment le retrait. Ne peut pas être appelée par le client.

Update en conséquence les soldes de -1, -2, -3 et de l’émetteur. Crée le cheque ou le virement si besoin. (en retrait = true)

  • mode = "cheque", "especes" ou "virement"
  • paramas_pay = {"nom": "Passoire", "prenom": "Toto", "banque": "sogé"}
ServeurFonctions.retirer(self, data)[source]

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).

ServeurFonctions.alias(self, data)[source]

data = [<idbde>, <alias>]

Ajoute un alias à un compte.

_log relevant ids : idbde, idalias

ServeurFonctions.unalias(self, data)[source]

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

ServeurFonctions.get_activites(self, data)[source]

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).

ServeurFonctions.get_activite(self, data)[source]

data = <id>

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

ServeurFonctions._handle_negative_duration(self, exc)[source]

Si l’erreur est bien un problème de durée négative, transmet un message d’erreur, sinon relève l’exception.

ServeurFonctions.add_activite(self, data)[source]

Ajoute une activité.

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

_log relevant ids : idact

ServeurFonctions.update_activite(self, data)[source]

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

ServeurFonctions.del_activite(self, data)[source]

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

Supprime une activité.

_log relevant ids : idact

ServeurFonctions._get_activity_overlap(idact, cur)[source]

Renvoie la liste des activités déjà validées qui entrent en collision avec l’activité n°``idact``

ServeurFonctions.valider_activite(self, data)[source]

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

ServeurFonctions.devalider_activite(self, data)[source]

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

ServeurFonctions._invitable(self, idact, respo, isadmin, nom=None, prenom=None)[source]

Ne peut pas être appelée par le client.

Peut être utilisé sans préciser nom ni respo, et alors permet de savoir si l’utilisateur courant a le droit d’inviter quelqu’un à cette activité. (NB : le test des [3] invités par inviteur ne sera alors pas fait. On veut qu’un utilisateur puisse voir/supprimer ses invités même si il en a déjà [3])

Renvoie [<boolén ok/pas ok pour inviter>, <une liste de keywords>, <a>, <b>] :
((<a>, <b>) vaut (max_pers, max_an) si on eu le temps d’atteindre les tests les concernant, (0, 0) sinon)
Explication des keywords :
  • "<fail>" = <signification> (<seul/cumulable>) [True]

    [True] est présent si ce champ n’empêche pas la réponse d’être True. Typiquement, si on a déjà 3 invités ou si on est en négatif, on ne peux plus inviter mais on peut quand même voir ses invités.

  • "404" : cette activité n’existe pas (seul)

  • "nolist" : la liste d’invités de cette activité n’existe pas ou n’est pas accessible (activité non validée, ou liste imprimée) (seul)

  • "already invited" : cette personne a déjà été invitée à cette activité (seul)

  • "closed" : la liste n’est plus ou pas encore ouverte (cumulable)

  • "negatif" : l’inviteur est en négatif, il n’a pas le droit d’inviter (cumulable) [True]

  • "max perso" : l’inviteur a déjà invité [3] invités à cette activité (cumulable) [True]

  • "max annee" : cet invité a déjà invité [5] fois dans l’année (cumulable)

ServeurFonctions.add_invite(self, data)[source]

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é

ServeurFonctions.del_invite(self, data)[source]

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é

ServeurFonctions._get_invites(idact, responsable=None, compute_times=False)[source]

Récupère la liste des invités d’une activité dans la base de données. Si responsable n’est pas None, ne renvoie que les invités invités par ce responsable. Si compute_times est vrai, on rajoute un champs "times" qui compte le nombre de fois qu’un invité est venu dans l’année.

ServeurFonctions.get_invites(self, data)[source]

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"

ServeurFonctions._make_html(template, dico_sur, dico_to_escape)[source]

Fabrique une chaîne html en plaçant les valeur du dico dans le template mais en prenant soin de les échapper.

ServeurFonctions._make_pdf_from_html(htmlraw)[source]

Fabrique un pdf à partir d’une chaîne html.

Renvoie (rawpdf, None) ou (None, message d’erreur).

ServeurFonctions.liste_invites(self, data)[source]

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" :
ServeurFonctions.mayi(self, data)[source]

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
ServeurFonctions.historique_transactions(self, data)[source]

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)
ServeurFonctions._can_toggle_transaction(self, transaction)[source]

Dit si l’utilisateur a le droit de changer le statut valide/invalide de la transaction. Cela dépend de ses droits, de la date de la transaction et si elle est cantinvalidate.

La règle est la suivante : on peut valider/dévalider une transaction si on aurait le droit de faire la transaction que va effectuer cette validation/dévalidation.

ServeurFonctions._valider_ou_devalider_transaction(self, idtransaction, validate)[source]

Si validate est True, valide la transaction n°``idtransaction``, sinon, la dévalide. Répercute les effets sur les soldes.

_log relevant ids : idtransaction

ServeurFonctions.valider_transaction(self, data)[source]

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

ServeurFonctions.devalider_transaction(self, data)[source]

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

ServeurFonctions._factorize_idbde(liste)[source]

Prend en entrée une liste d’idbde On renvoie une liste de couple (idbde,count(idbde))

ServeurFonctions.liste_droits(self)[source]

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

ServeurFonctions.django_get_accessible_pages(self, liste_pages)[source]

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