def reset_password_by_id(id_user, new_pass):
"""
Mettre a jour le mot de passe d'un utilisateur, SANS VERIFICATION de l'ancien mot de passe.
Utilisé uniquement dans le cas du rest des mots de passe.
Pour un changement de mot de passe, voir :func:`update_password_by_id`.
:param id_user: user id_user
:param old_pass: ancien mot de passe, doit être vérifié pour voir si on a le droit d'update (mieux qu'un fresh login)
:param new_pass: nouveau mot de passe
:rtype : bool
:return : True si ok, False si nok
"""
result = False
if new_pass is not None:
up = __utilisateur.update(
).where(
__utilisateur.c.id_utilisateur == id_user
).values(
password = gen(new_pass,'pbkdf2:sha512:1000', 12)
)
engine.execute(up)
result = True
return result
def update_adresse_perso(id_ancien, ville, id_pays, adresse="", code=""):
"""
Mettre à jour l'adresse active d'un ancien, en updatant ou insérant.
En updatant ou insérant la ville au passage
:param id_ancien: int, id_ancien
:param adresse: str, l'adresse en texte libre
:param ville: str, la ville en texte libre
:param code: int, le ocde postal en texte libre puis converti en int
:param id_pays: int
:return: boolean success = true si ça marche, false sinon
"""
success = False
id_adresse = None
new_adresse = True
aaa = __asso_ancien_adresse
# 1 : est-ce que l'adresse existe ?
sel = select([aaa.c.id_adresse]).where(and_(aaa.c.actif == True, aaa.c.id_ancien == id_ancien))
res = engine.execute(sel).first()
if res is not None:
id_adresse = res[0]
new_adresse = False
id_adresse = _insert_update_adresse(ville, id_pays, id_adresse, adresse, code)
if new_adresse:
# insérer l'asso
ins = __asso_ancien_adresse.insert().values(id_ancien=id_ancien, id_adresse=id_adresse, actif=True)
engine.execute(ins)
success = update_ancien_date(id_ancien)
return success
def update_password_by_id(id_user, old_pass, new_pass):
"""
Mettre a jour le mot de passe d'un utilisateur. Pour verification, on utilise son ancien mot de passe
:param id_user: user id_user
:param old_pass: ancien mot de passe, doit être vérifié pour voir si on a le droit d'update (mieux qu'un fresh login)
:param new_pass: nouveau mot de passe
:rtype : bool
:return : True si ok, False si nok
"""
result = False
res = __select_user_by_id(id_user)
if old_pass is None:
old_pass = ""
if res is not None and new_pass is not None:
row = res.first()
if row is not None and check(row['password'], old_pass) and new_pass is not None:
up = __utilisateur.update(
).where(
__utilisateur.c.id_utilisateur == id_user
).values(
password = gen(new_pass,'pbkdf2:sha512:1000', 12)
)
engine.execute(up)
result = True
return result
def activate_user(id_user):
"""
Activer un utilisateur
:param id_user: L'utilisateur à activer
"""
res = False
if id_user is not None:
up = __utilisateur.update().where(__utilisateur.c.id_utilisateur == id_user).values(actif=True)
engine.execute(up)
res = True
return res
def set_default_experience(id_ancien, id_experience):
"""
marquer une expérience comme "active", et "désactiver" les
autre expériences d'un ancien donner.
:param id_ancien:
:param id_experience:
:return:
"""
up = __experience.update().where(__experience.c.id_ancien==id_ancien).values(actif=False)
engine.execute(up)
up = __experience.update().where(__experience.c.id_experience==id_experience).values(actif=True)
engine.execute(up)
def _insert_update_adresse(ville, id_pays, id_adresse, adresse="", code=""):
"""
Mettre à jour une adresse perso ou pro, en updatant ou insérant.
En updatant ou insérant la ville au passage
:param id_ancien: int, id_ancien
:param adresse: str, l'adresse en texte libre
:param ville: str, la ville en texte libre
:param code: int, le ocde postal en texte libre puis converti en int
:param id_pays: int
:return: id_adresse: l'id de l'adresse insérée / updatéee
"""
# 2 : est-ce que la ville existe ? si non, insert !
id_ville = None
if helper.is_valid_integer(id_pays):
sel = select([__ville.c.id_ville])
sel = sel.where(and_(_slug_by_column(__ville.c.slug, helper.slugify(ville), True), __ville.c.id_pays == id_pays))
sel = sel.distinct()
res = engine.execute(sel).first()
if res is not None:
# si la ville existe, on récupère son numéro
id_ville = res[0]
elif (ville is not None and ville != "") and (id_pays is not None and id_pays != ""):
# si la ville n'existe pas, mais qu'il y a un texte et un pays
# on l'insère et on récupère son numéro
ins = __ville.insert().values(nom=ville, slug=helper.slugify(ville), id_pays=id_pays)
engine.execute(ins)
sel = select([__ville.c.id_ville])
sel = sel.where(and_(_slug_by_column(__ville.c.slug, helper.slugify(ville), True), __ville.c.id_pays == id_pays))
res = engine.execute(sel).first()
id_ville = res[0]
# 3 : update (ou insert) de l'adresse
if id_ville is not None:
if id_adresse is not None:
a = __adresse
# si l'adresse existe, la mettre à jour
up = a.update().where(a.c.id_adresse == id_adresse).values(id_ville=id_ville, adresse=adresse, code=code)
engine.execute(up)
else:
a = __adresse
# si l'adresse n'existe pas, l'insérer
ins = a.insert().values(id_ville=id_ville, adresse=adresse, code=code)
engine.execute(ins)
sel = select([a.c.id_adresse]).where(and_(a.c.id_ville == id_ville, a.c.adresse == adresse, a.c.code == code))
id_adresse = engine.execute(sel).first()[0]
return id_adresse
def find_ancien_filtres(nouveau = None, bloque = None):
"""
Trouver tous les anciens qui ont le flag "nouveau", ou "bloques"
:param bool nouveau: True = Chercher uniquement les nouveaux
False = Chercher uniquement les autres
None (default) = Chercher tous les anciens
:param bool bloque: True = Chercher uniquement les bloqués
False = Chercher uniquement les autres
None (default) = Chercher tous les anciens
:return:
- SELECT DISTINCT * FROM ancien WHERE nouveau = True
"""
sel = select([__ancien]).distinct()
if nouveau is not None:
sel = sel.where(__ancien.c.nouveau == nouveau)
if bloque is not None:
sel = sel.where(__ancien.c.bloque == bloque)
return engine.execute(sel).fetchall()
def create_ancien(prenom, nom, promo, ecole, mail_asso, diplome):
"""
Créer un ancien à partir des données d'un formulaire
:param str prenom:
:param str nom:
:param int promo:
:param str ecole: In E, P, N
:param str mail_asso:
:param str diplome:
:return:
"""
ins = __ancien.insert().returning(__ancien.c.id_ancien).values(
prenom=prenom,
prenom_slug=helper.slugify(prenom),
nom=nom,
nom_slug=helper.slugify(nom),
ecole=ecole,
promo=promo,
mail_asso=mail_asso,
diplome=diplome,
)
inserted_id = engine.execute(ins).first()[0]
update_ancien_date(inserted_id)
return inserted_id
def create_user(mail, password):
"""
Créer un utilisateur dans la base de données.
:param mail: le mail de l'utilisateur, unique
:param password: le mot de passe
"""
res = False
if mail is not None:
ins = __utilisateur.insert().values(
id_ancien = None,
mail = mail.lower(),
password = gen(password,'pbkdf2:sha512:1000', 12)
)
engine.execute(ins)
res = True
return res
def update_ancien_date(id_ancien):
"""
Mettre à jour ancien.date_update pour marquer que la fiche ancien à été mise à jour à la date du jour
:param id_ancien: l'id de l'ancien
:return: boolean success = true si l'update fonctionne
"""
success = False
if helper.is_valid_integer(id_ancien):
up = __ancien.update().where(
__ancien.c.id_ancien == id_ancien
).values(
date_update=date.today()
)
result = engine.execute(up)
if result is not None:
# Update le ts_vector (fulltext) associé à l'ancien en question.
# Étrangement, il faut EXPLICITEMENT démarrer une transaction et la commiter
conn = engine.connect()
trans = conn.begin()
conn.execute(func.reset_fulltext_by_id_ancien(id_ancien))
trans.commit()
conn.close()
success = True
return success
def count_fulltext(search_terms, actif = True, bloque = False):
"""
Compter les anciens trouvés par la recherche fulltext
:param str search_terms: Termes utilisés pour la recherche
:param bool actif: True (default) = Chercher uniquement les actifs
False = Chercher uniquement les inactifs
None = Chercher TOUS les anciens
:param bool bloque: True = Chercher uniquement les bloqués
False (default) = Chercher uniquement les autres
None = Chercher tous les anciens
:return int: le nombre d'anciens qui satisfont les termes de recherche
"""
sel = select([func.count(__ancien.c.id_ancien.distinct())]).where("fulltext @@ to_tsquery('french', :input_str)")
sel = sel.where(__ancien.c.nouveau == False)
if actif is not None:
sel = sel.where(__ancien.c.actif == actif)
if bloque is not None:
sel = sel.where(__ancien.c.bloque == bloque)
res = engine.execute(sel, input_str=helper.prepare_for_fulltext(search_terms)).first()[0]
return res
def get_next_photo_id():
"""
récupérer un id pour la photo pour ne pas écraser une photo existante
:return: long, un id
"""
# TODO : déplacer ça dans l'annuaire
res = engine.execute(__s_id_photo)
return res
def remove_experience(id_ancien, id_experience):
"""
Supprimer une experience, en vérifiant qu'elle est bien associée au bon ancien
:param id_ancien:
:param id_experience:
:return:
"""
suppr = __experience.delete().where(
and_(
__experience.c.id_ancien == id_ancien,
__experience.c.id_experience == id_experience
)
)
success = update_ancien_date(id_ancien)
engine.execute(suppr)
def update_ancien_valider(id_ancien):
"""
Valider un ancien
:param int id_ancien: l'id de l'ancien à valider
"""
success = False
if id_ancien is not None:
up = __ancien.update().where(
__ancien.c.id_ancien == id_ancien
).values(
nouveau = False
)
engine.execute(up)
success = True
return success
def update_user_admin(id_utilisateur, admin):
"""
Donner / retirer le status d'admin à un utilisateur
:param int id_utilisateur: l'id de l'utilisateur à rendre admin
:param bool admin: Donner admin (True) ou retirer admin (False)
:return:
"""
success = False
if id_utilisateur is not None and admin is not None:
up = __utilisateur.update().where(
__utilisateur.c.id_ancien == id_utilisateur
).values(
admin = admin
)
engine.execute(up)
success = True
return success
def update_ancien_bloque(id_ancien, bloque):
"""
Bloquer ou débloquer un ancien
:param int id_ancien: l'id de l'ancien à bloquer/débloquer
:param bool bloque: Pour bloquer (True) ou débloquer (False)
:return:
"""
success = False
if id_ancien is not None and bloque is not None:
up = __ancien.update().where(
__ancien.c.id_ancien == id_ancien
).values(
bloque = bloque
)
engine.execute(up)
success = True
return success
def __select_user_by_id(id_user=None):
"""
Recuperer un user par mail (unique)
:param id_user: id de l'utilisateur
:rtype : sqlalchemy.core.ResultProxy
:return : SELECT * FROM utilisateur WHERE id_utilisateur=id_user;
"""
result = None
if id_user is not None:
sel = select([__utilisateur]).where(__utilisateur.c.id_utilisateur == id_user)
result = engine.execute(sel)
return result
def find_entreprise_autocomplete(term, limit=5):
"""
Rechercher une liste d'entreprise pour l'autocomplete
:param term: terme de recherche (un seul)
:return: SELECT nom FROM entreprise WHERE entreprise.slug LIKE 'term%'
"""
result = None
if not (term is None or term == ""):
sel = select([__entreprise.c.nom], __entreprise.c.slug.like(helper.slugify(term)+'%'))
sel = sel.distinct().order_by(__entreprise.c.nom).limit(limit)
result = engine.execute(sel)
return result
def update_photo(id_ancien, filename):
"""
Mettre à jour la photo d'un ancien, par ID
:param id_ancien: int, id de l'ancien (ya rly)
:param filename: le nom de la photo
:return: boolean success = true si l'update fonctionne
"""
success = False
up = __ancien.update().where(__ancien.c.id_ancien == id_ancien).values(photo=filename)
result = engine.execute(up)
if result is not None:
success = update_ancien_date(id_ancien)
return success
def find_ancien_by_mail_asso(mail_asso):
"""
Rechercher un ancien par son "mail à vie" de l'association. Utilisé pour associer
un user et un ancien.
:param mail_asso: [email protected] (ou mines-nancy.org ou mines-saint-etienne.org)
:return:
- SELECT DISTINCT * FROM ancien WHERE mail_asso = mail_asso;
- First result only
- NONE if not found
"""
sel = select([__ancien], __ancien.c.mail_asso == mail_asso).distinct()
res = engine.execute(sel).first()
return res
def ancien_has_experience(id_ancien, id_experience):
"""
Vérifier qu'une expérience donnée est bien associée à l'ancien
en question.
:param id_ancien:
:param id_experience:
:return:
"""
sel = select(
[__experience.c.id_experience],
and_(__experience.c.id_experience==id_experience, __experience.c.id_ancien==id_ancien)
)
res = engine.execute(sel).first()
return res is not None
def find_ancien_by_id_linkedin(id_linkedin):
"""
Trouver un ancien par ID_linkedin.
:param id_linkedin: l'id renvoyé par LinkedIn pour identifier un compte.
:return :
- SELECT DISTINCT * FROM ancien WHERE id_linkedin = id_linkedin;
- First result only
- NONE if not found
"""
sel = select([__ancien], __ancien.c.id_linkedin == id_linkedin).distinct()
res = engine.execute(sel)
if res is not None:
res = res.first()
return res
def find_user_by_id_ancien(id_ancien, actif_only=False):
"""
Rechercher un utilisateur par id ancien
:param id_ancien: int, id_ancien
:return: Utilisateur (None if not exist)
"""
if id_ancien is not None:
condition = __utilisateur.c.id_ancien == id_ancien
if actif_only:
condition &= __utilisateur.c.actif
sel = select([__utilisateur]).where(condition)
result = engine.execute(sel)
if result is not None:
row = result.first()
if row is not None:
return Utilisateur(row['id_utilisateur'], row['mail'], row['id_ancien'], row['actif'], row['admin'])
return None
def update_actif(id_ancien, actif):
"""
Mettre à jour une fiche ancien : la rendre active ou inactive
:param int id_ancien: Id de l'ancien à modifier
:param bool actif: Status à affecter à l'ancien
:return: bool succes = true si l'update fonctionne
"""
success = False
up = __ancien.update().where(
__ancien.c.id_ancien == id_ancien
).values(
actif=actif
)
result = engine.execute(up)
if result is not None:
success = update_ancien_date(id_ancien)
return success
def find_user_by_mail(mail, actif_only=True):
"""
Rechercher un utilisateur dans l'annuaire
:param mail: le mail de l'utilisateur
:rtype: Utilisateur
:return: un utilisateur
"""
if mail is not None:
condition = __utilisateur.c.mail == mail.lower()
if actif_only:
condition &= __utilisateur.c.actif
sel = select([__utilisateur]).where(condition)
res = engine.execute(sel)
if res is not None:
row = res.first()
if row is not None:
return Utilisateur(row['id_utilisateur'], row['mail'], row['id_ancien'], row['actif'], row['admin'])
return None
def find_ancien_by_id(id_ancien, actif = None, nouveau = False, bloque = False):
"""
Rechercher un ancien par id
:param int id_ancien: l'id ancien (sisi)
:param bool actif: True = Chercher uniquement les actifs
False = Chercher uniquement les inactifs
None (default) = Chercher TOUS les anciens
:param bool nouveau: True = Chercher uniquement les nouveaux
False (default) = Chercher uniquement les autres
None = Chercher tous les anciens
:param bool bloque: True = Chercher uniquement les bloqués
False (default) = Chercher uniquement les autres
None = Chercher tous les anciens
:return: SELECT DISTINCT *
FROM ancien
WHERE
id_ancien = id_ancien
(AND actif = actif)
(AND nouveau = nouveau)
(AND bloque = bloque);
"""
sel = select([__ancien], __ancien.c.id_ancien == id_ancien).distinct()
if actif is not None:
sel = sel.where(__ancien.c.actif == actif)
if bloque is not None:
sel = sel.where(__ancien.c.bloque == bloque)
if nouveau is not None:
sel = sel.where(__ancien.c.nouveau == nouveau)
res = engine.execute(sel).first()
return res
def find_adresse_by_id_ancien(id_ancien):
"""
Rechercher une adresse par id_ancien
:param id_ancien:
:return: Select * from adresse join asso where asso.id_ancien=truc
"""
if id_ancien is not None and type(id_ancien) is int:
aaa = __asso_ancien_adresse
sel = select(
[__adresse.c.adresse,
__adresse.c.code,
__ville.c.nom,
__pays.c.nom,
__pays.c.id_pays],
and_(aaa.c.id_ancien == id_ancien, aaa.c.actif==True),
from_obj=aaa.join(__adresse).outerjoin(__ville).outerjoin(__pays),
use_labels=True).distinct()
return engine.execute(sel).first()
else:
return None
def update_linkedin_ancien(id_ancien, id_linkedin=None, url_linkedin=None):
"""
Mettre à jour le compte linkedin d'un ancien
:param id_ancien: id de l'ancien en question
:param id_linkedin: id_linkedin à sauvegarder
:param url_linkedin: profil public linkedin à sauvegarder
:return: True si success
"""
success = False
if helper.is_valid_integer(id_ancien):
up = __ancien.update().where(
__ancien.c.id_ancien == id_ancien
).values(
id_linkedin=id_linkedin,
url_linkedin= url_linkedin
)
result = engine.execute(up)
if result is not None:
success = update_ancien_date(id_ancien)
return success
def find_user_by_mail_and_password(mail, password, actif_only=True):
"""
Rechercher un utilisateur dans l'annuaire
:param form: request form
:rtype: Utilisateur
:return: un utilisateur
"""
res = None
if password is None:
password = ""
if mail is not None:
condition = __utilisateur.c.mail == mail.lower()
if actif_only:
condition &= __utilisateur.c.actif
sel = select([__utilisateur]).where(condition)
res = engine.execute(sel)
if res is not None:
row = res.first()
if row is not None and check(row['password'], password):
return Utilisateur(row['id_utilisateur'], row['mail'], row['id_ancien'], row['actif'], row['admin'])
return None
def update_id_ancien(id_user, id_ancien):
"""
Mettre à jour l'id_ancien pour un utilisateur donné
:params :
id_user -- user id
id_ancien -- id de l'ancien à associer à ce compte
:return : L'objet utilisateur
"""
res = False
if id_ancien and id_user:
up = __utilisateur.update().where(
__utilisateur.c.id_utilisateur == id_user
).values(
id_ancien = id_ancien
)
sql_result = engine.execute(up)
if sql_result is not None:
sql_result.close() # close this shit.
res = True
return res
