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