def _refine_by_promo(select, promo_list=None):
"""
Methode interne pour affiner un select par promo, en utilisant une liste de promos
@note:
On a une str qui represente une liste de promos ou de ranges de promos (type 2008-2010)
si on a 2008 on fait promo = 2008
si on a 08 on fait promo = 1908 ou promo = 2008
:param select: le select à affiner
:param promo_list: la liste des promos à filtrer
:return: select WHERE promo IN promo_list
"""
if select is not None:
statement = None
if promo_list is not None:
anc = __ancien
# on decoupe l'input par les caracteres espace
# pour faire une list de promos
for subset in promo_list.strip().split():
# on redecoupe par tiret '-', pour voir si on a des promos solo
# ou bien des ranges de promo
sub_tab = subset.split('-')
if len(sub_tab) > 1:
# si on trouve un tiret on prend les deux premiers elements
annee_debut = sub_tab[0]
annee_fin = sub_tab[1]
elif len(sub_tab) == 1:
# sinon on considere qu'on a pas de fin
annee_debut = sub_tab[0]
annee_fin = None
# si on a juste une annee
if helper.is_valid_integer(annee_debut) and not helper.is_valid_integer(annee_fin):
# note : on traite les annees pour taper 08 et que ca cherche sur 2008 et 1908
if statement is not None:
statement |= _or_annee(statement, annee_debut)
else:
statement = _or_annee(statement, annee_debut)
# si on a un range d'annees
else:
if helper.is_valid_integer(annee_debut) and helper.is_valid_integer(annee_fin):
if statement is not None:
statement |= (anc.c.promo.between(annee_debut, annee_fin))
else:
statement = anc.c.promo.between(annee_debut, annee_fin)
if statement is not None:
return select.where(statement)
else:
return select
else:
return None
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 resend(id_user):
"""
Méthode pour renvoyer l'email de confirmation d'une inscription
:param id_user: id_user de la préinscription à renvoyer par mail
"""
if helper.is_valid_integer(id_user) is not None:
utilisateur = user.find_user_by_id(id_user)
if utilisateur is not None and not utilisateur.actif:
signature = helper.generate_signed_string_from_mail(utilisateur.mail)
helper.send_activation_mail(utilisateur.mail, signature)
flash(
"Succès : un mail d'activation te sera envoyé prochainement",
"success"
)
app.logger.info("RESEND - resend mail for user with id %s", utilisateur.id)
else:
flash("Echec : aucune inscription trouvée, "
"merci de contacter l'adminsitrateur pour plus d'information", "danger")
app.logger.error("RESEND - try resend but no utilisateur found for id %s", id_user)
else:
flash("Echec : pas d'id utilisateur, "
"merci de contacter l'adminsitrateur pour plus d'information", "danger")
app.logger.error("RESEND - no id user")
return redirect(url_for("login"))
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 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 update_fiche_ancien(id_ancien, telephone="", mobile="", site="", mail_perso=""):
"""
Mettre à jour une fiche ancien par id_ancien
:param id_ancien: int, l'id_ancien
:param telephone: str < 20 char
:param mobile: str < 20 char
:param site: str < 200 char
:param mail_perso: str < 75 char
: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(
telephone=telephone,
mobile= mobile,
site = site,
mail_perso=mail_perso
)
result = engine.execute(up)
if result is not None:
success = update_ancien_date(id_ancien)
return success
