class TDeliveries(GenericRepository): """ Model de la table t_deliveries """ __tablename__='t_deliveries' __table_args__ = {'schema':'gas', 'extend_existing': True} id_delivery = db.Column(db.Unicode, server_default=FetchedValue(), primary_key = True) delivery_name = db.Column(db.Unicode) delivery_date = db.Column(db.Date) order_limit_date = db.Column(db.Date) delivery_discount = db.Column(db.Numeric) shipping = db.Column(db.Numeric) delivery_comment = db.Column(db.Unicode) delivery_organization = db.Column(db.Unicode) active = db.Column(db.Boolean) is_open = db.Column(db.Boolean) @classmethod def selectActiveDeliveries(cls, is_open=False): """ Methode qui retourne un tableau de tuples de id_delivery et de nom de la livraison Avec pour paramètres un id_order et un nom de livraison """ q = db.session.query(cls) q = q.order_by(desc(cls.delivery_date)) if is_open: q = q.filter(and_(TDeliveries.active == True, TDeliveries.is_open == True)) else: q = q.filter(TDeliveries.active == True) activedeliveries = [(o.id_delivery, o.delivery_name) for o in q.all()] activedeliveries.insert(0,(0, 'Cliquer ici pour choisir')) return activedeliveries
class CorRoleAppProfil(GenericRepository): """Classe de correspondance entre la table t_roles, t_profils et t_applications""" __tablename__ = "cor_role_app_profil" __table_args__ = {'schema': 'utilisateurs'} id_role = db.Column(db.Integer, ForeignKey('utilisateurs.t_roles.id_role'), primary_key=True) id_profil = db.Column(db.Integer, ForeignKey('utilisateurs.t_profils.id_profil'), primary_key=True) id_application = db.Column( db.Integer, ForeignKey('utilisateurs.t_applications.id_application'), primary_key=True) role_rel = relationship("TRoles") application_rel = relationship("TApplications") profil_rel = relationship("TProfils") # surchage de la méthode get_one car il n'y a pas de clé primaire unique sur une cor @classmethod def get_one(cls, id_role, id_application): return db.session.query(cls).filter_by( id_role=id_role, id_application=id_application).first() # surchage de la méthode delete car il n'y a pas de clé primaire unique sur une cor # TODO cette méthode supprime tous les profils pour une application et un role # faire une méthode qui supprime seulement un enregistrement grace à une PK unique # necessite ne pas utiliser le template table_database.html qui est trop génériqe @classmethod def delete(cls, id_role, id_application): cors = db.session.query(cls).filter_by( id_role=id_role, id_application=id_application).all() for cor in cors: db.session.delete(cor) try: db.session.commit() except Exception: db.session.rollback() raise @classmethod def add_cor(cls, id_app, tab_profil): dict_add = {} for d in tab_profil: dict_add = { 'id_role': d['id_role'], 'id_profil': d['id_profil'], 'id_application': id_app } cls.post(dict_add) @classmethod def del_cor(cls, id_app, tab_profil): for t in tab_profil: cls.query.filter(cls.id_role == t['id_role']).filter( cls.id_profil == t['id_profil']).filter( cls.id_application == id_app).delete() db.session.commit()
class TProfils(GenericRepository): """ Model de la classe t_profils """ __tablename__ = 't_profils' __table_args__ = {'schema': 'utilisateurs', 'extend_existing': True} id_profil = db.Column(db.Integer, primary_key=True) code_profil = db.Column(db.Unicode) nom_profil = db.Column(db.Unicode) desc_profil = db.Column(db.Unicode) @classmethod def get_profils_in_app(cls, id_application): """ Methode qui retourne tableau des profils utilisables pour une application Avec pour paramètre un id de l'application """ ''' Methode qui retourne tous les profils autorisés dans une app Parameters: id_app (int): l'id de l'application Returns: Array<TProfils> ''' return db.session.query(TProfils).join( CorProfilForApp, CorProfilForApp.id_profil == TProfils.id_profil).filter( CorProfilForApp.id_application == id_application).all() @classmethod def get_profils_out_app(cls, id_application): """ Methode qui retourne un dictionnaire des profils non utilisés pour une application Avec pour paramètre un id application """ q = db.session.query(cls) subquery = db.session.query(CorProfilForApp.id_profil).filter( CorProfilForApp.id_application == id_application) q = q.filter(cls.id_profil.notin_(subquery)) return [data.as_dict() for data in q.all()] @classmethod def choixSelect(cls, key='id_profil', label='nom_profil', id_application=None): """ Methode qui retourne un tableau de tuples d'id profil et de nom de profil Ce que l'on met en key et label sont paramétrable """ if id_application: profils = cls.get_profils_in_app(id_application) return [(getattr(d, key), getattr(d, label)) for d in profils] return [(getattr(d, key), getattr(d, label)) for d in cls.get_all()]
class TListes(GenericRepository): """ Model de la table t_listes """ __tablename__ = "t_listes" __table_args__ = {"schema": "utilisateurs", "extend_existing": True} id_liste = db.Column(db.Integer, primary_key=True) code_liste = db.Column(db.Unicode) nom_liste = db.Column(db.Unicode) desc_liste = db.Column(db.Unicode)
class TListes(GenericRepository): """ Model de la table t_listes """ __tablename__ = 't_listes' __table_args__ = {'schema': 'utilisateurs', 'extend_existing': True} id_liste = db.Column(db.Integer, primary_key=True) code_liste = db.Column(db.Unicode) nom_liste = db.Column(db.Unicode) desc_liste = db.Column(db.Unicode)
class VGroupOrdersSum(GenericRepository): """ Model de la classe v_group_orders_sum """ __tablename__ = 'v_group_orders_sum' __table_args__ = {'schema':'gas', 'extend_existing': True} id_delivery = db.Column(db.Unicode, primary_key = True) id_group = db.Column(db.Integer, primary_key = True) delivery_name = db.Column(db.Unicode) group_name = db.Column(db.Unicode) total = db.Column(db.Numeric)
class TApplications(GenericRepository): """ Model de la table t_applications """ __tablename__ = "t_applications" __table_args__ = {"schema": "utilisateurs", "extend_existing": True} id_application = db.Column(db.Integer, primary_key=True) code_application = db.Column(db.Unicode) nom_application = db.Column(db.Unicode) desc_application = db.Column(db.Unicode) id_parent = db.Column(db.Unicode)
class CorRoles(GenericRepository): """ Classe de correspondance entre un utilisateur et un groupe """ __tablename__ = "cor_roles" __table_args__ = {"schema": "utilisateurs"} id_role_groupe = db.Column(db.Integer, primary_key=True) id_role_utilisateur = db.Column(db.Integer, ForeignKey("utilisateurs.t_roles.id_role"), primary_key=True) t_roles = db.relationship("TRoles") @classmethod def test_role_in_grp(cls, id_role, id_group): """ Methode qui retourne vrai si le role appartient au groupe """ in_grp = (db.session.query(CorRoles).filter( CorRoles.id_role_utilisateur == id_role).filter( CorRoles.id_role_groupe == id_group).all()) if in_grp: return True return False @classmethod def add_cor(cls, id_group, ids_role): """ Methode qui ajoute des relations roles <-> groupe Avec pour paramètres un id de groupe(id_role) et un tableau d'id de roles """ dict_add = dict() dict_add["id_role_groupe"] = id_group for d in ids_role: dict_add["id_role_utilisateur"] = d cls.post(dict_add) @classmethod def del_cor(cls, id_group, ids_role): """ Methode qui supprime des relations roles <-> groupe Avec pour paramètres un id de groupe(id_role) et un tableau d'id de roles """ for d in ids_role: cls.query.filter(cls.id_role_groupe == id_group).filter( cls.id_role_utilisateur == d).delete() db.session.commit()
class TGroups(GenericRepository): """ Model de la table t_groups """ __tablename__ = 't_groups' __table_args__={'schema':'gas', 'extend_existing': True} id_group = db.Column(db.Integer, primary_key = True) group_name = db.Column(db.Unicode) group_leader = db.Column(db.Unicode) group_comment = db.Column(db.Unicode) group_main_email = db.Column(db.Unicode) group_main_tel = db.Column(db.Unicode) active = db.Column(db.Boolean) @classmethod def selectActiveGroups(cls, id_group=None): """ Methode qui retourne un tableau de tuples de id_group et de nom de relais actif """ q = db.session.query(cls) q = q.order_by(desc(cls.group_name)) q = q.filter(and_(TGroups.active==True, TGroups.id_group != 0)) if id_group is not None: q = q.filter(TGroups.id_group == id_group) activegroups = [(g.id_group, g.group_name) for g in q.all()] if id_group is None: activegroups.insert(0,(0, 'Cliquer ici pour choisir')) return activegroups
class TProfils(GenericRepository): """ Model de la classe t_profils """ __tablename__ = 't_profils' __table_args__ = {'schema':'gas', 'extend_existing': True} id_profil = db.Column(db.Integer,primary_key = True) profil_code = db.Column(db.Unicode) profil_name = db.Column(db.Unicode) profil_comment = db.Column(db.Unicode) @classmethod def choixSelect(cls,profil_code,profil_name): """ Methode qui retourne un tableau de tuples de code profil et de nom de profil Avec pour paramètres un code de profil et un nom de profil """ return [(d[profil_code], d[profil_name]) for d in cls.get_all(None, None, [profil_name])]
class CorProfilForApp(GenericRepository): """ Classe de correspondance entre la table t_applications et la table t_profils""" __tablename__ = "cor_profil_for_app" __table_args__ = {"schema": "utilisateurs", "extend_existing": True} id_application = db.Column( db.Integer, ForeignKey("utilisateurs.t_applications.id_application"), primary_key=True, ) id_profil = db.Column(db.Integer, ForeignKey("utilisateurs.t_profils.id_profil"), primary_key=True) profil_rel = relationship("TProfils") @classmethod def add_cor(cls, id_application, ids_profil): """ Methode qui ajoute des relations applications <-> profil Avec pour paramètres un id profil et un tableau d'id d'applications """ dict_add = dict() dict_add["id_application"] = id_application for d in ids_profil: dict_add["id_profil"] = d cls.post(dict_add) @classmethod def del_cor(cls, id_application, ids_profil): """ Methode qui supprime des relations applications <-> profil Avec pour paramètres un id profil et un tableau d'id d'applications """ for d in ids_profil: cls.query.filter(cls.id_application == id_application).filter( cls.id_profil == d).delete() db.session.commit()
class CorUserProfil(GenericRepository): """Classe de correspondance entre la table t_user, t_profils""" __tablename__= "cor_user_profil" __table_args__={'schema':'gas'} id_user = db.Column(db.Unicode,ForeignKey('gas.t_users.id_user'), primary_key = True) id_profil = db.Column(db.Integer,ForeignKey('gas.t_profils.id_profil'), primary_key = True) @classmethod def add_cor(cls, ids_user, id_profil): dict_add = dict() dict_add["id_profil"] = id_profil for d in ids_user: dict_add["id_user"] = d cls.post(dict_add) @classmethod def del_cor(cls,ids_user, id_profil): for d in ids_user: cls.query.filter(cls.id_profil == id_profil).filter(cls.id_user == d).delete() db.session.commit()
class TProducts(GenericRepository): """ Model de la table t_products """ __tablename__='t_products' __table_args__ = {'schema':'gas', 'extend_existing': True} id_product = db.Column(db.Integer, primary_key = True) id_delivery =db.Column(db.Unicode, ForeignKey('gas.t_deliveries.id_delivery')) product_name = db.Column(db.Unicode) product_unit = db.Column(db.Unicode) buying_price = db.Column(db.Numeric) selling_price = db.Column(db.Numeric) case_weight = db.Column(db.Numeric) product_comment = db.Column(db.Unicode) active = db.Column(db.Boolean) delivery_rel = relationship("TDeliveries")
class CorRoleListe(GenericRepository): """ Classe de correspondance entre la table t_roles et la table t_listes""" __tablename__ = "cor_role_liste" __table_args__ = {"schema": "utilisateurs"} id_role = db.Column(db.Integer, ForeignKey("utilisateurs.t_roles.id_role"), primary_key=True) id_liste = db.Column(db.Integer, ForeignKey("utilisateurs.t_listes.id_liste"), primary_key=True) role_rel = relationship("TRoles") @classmethod def add_cor(cls, id_liste, ids_role): """ Methode qui ajoute des relations roles <-> liste Avec pour paramètres un id de liste et un tableau d'id de roles """ dict_add = dict() dict_add["id_liste"] = id_liste for d in ids_role: dict_add["id_role"] = d cls.post(dict_add) @classmethod def del_cor(cls, id_liste, ids_role): """ Methode qui supprime des relations roles <-> liste Avec pour paramètres un id de liste et un tableau d'id de roles """ for d in ids_role: cls.query.filter(cls.id_liste == id_liste).filter( cls.id_role == d).delete() db.session.commit()
class TOrders(GenericRepository): """ Classe de correspondance entre la table t_groups et la table t_products""" __tablename__ = 't_orders' __table_args__= {'schema':'gas'} id_group = db.Column(db.Integer,ForeignKey('gas.t_groups.id_group'), primary_key = True) id_product = db.Column(db.Integer, ForeignKey('gas.t_products.id_product'),primary_key = True) product_case_number = db.Column(db.Integer) group_discount = db.Column(db.Numeric) group_rel = relationship("TGroups") product_rel = relationship("TProducts") @classmethod def add_cor(cls,id_group, products_number): """ Methode qui ajoute des relations group <-> produits --> nombre d'unités Avec pour paramètres un id de group et un id_produit et un nombre d'unités """ dict_add = dict() dict_add["id_group"] = id_group for p in products_number: dict_add["id_product"] = p.id_produit dict_add["product_case_number"] = p.product_case_number cls.post(dict_add) @classmethod def del_cor(cls,id_group,ids_product): """ Methode qui supprime des relations group <-> produit Avec pour paramètres un id de group et un tableau d'id de produit """ for p in ids_product: cls.query.filter(cls.id_group == id_group).filter(cls.id_produit == p).delete() db.session.commit()
class CorRoles(GenericRepository): """ Classe de correspondance entre un utilisateur et un groupe """ __tablename__ = 'cor_roles' __table_args__ = {'schema': 'utilisateurs'} id_role_groupe = db.Column(db.Integer, primary_key=True) id_role_utilisateur = db.Column(db.Integer, ForeignKey('utilisateurs.t_roles.id_role'), primary_key=True) t_roles = db.relationship('TRoles') @classmethod def add_cor(cls, id_group, ids_role): """ Methode qui ajoute des relations roles <-> groupe Avec pour paramètres un id de groupe(id_role) et un tableau d'id de roles """ dict_add = dict() dict_add["id_role_groupe"] = id_group for d in ids_role: dict_add["id_role_utilisateur"] = d cls.post(dict_add) @classmethod def del_cor(cls, id_group, ids_role): """ Methode qui supprime des relations roles <-> groupe Avec pour paramètres un id de groupe(id_role) et un tableau d'id de roles """ for d in ids_role: cls.query.filter(cls.id_role_groupe == id_group).filter( cls.id_role_utilisateur == d).delete() db.session.commit()
class VOrdersResult(GenericRepository): """ Model de la classe v_orders_result """ __tablename__ = 'v_orders_result' __table_args__ = {'schema':'gas', 'extend_existing': True} id_delivery = db.Column(db.Unicode, primary_key = True) id_product = db.Column(db.Integer, primary_key = True) delivery_name = db.Column(db.Unicode) delivery_discount = db.Column(db.Numeric) shipping = db.Column(db.Numeric) product_name = db.Column(db.Unicode) product_unit = db.Column(db.Unicode) case_number = db.Column(db.Integer) weight = db.Column(db.Numeric) selling_price = db.Column(db.Numeric) buying_price = db.Column(db.Numeric) benefice = db.Column(db.Numeric)
class TRoles(GenericRepository): """ Model de la table t_roles """ __tablename__ = "t_roles" __table_args__ = {"schema": "utilisateurs", "extend_existing": True} id_role = db.Column(db.Integer, primary_key=True) groupe = db.Column(db.Boolean) uuid_role = db.Column(UUID(as_uuid=True), default=select([func.uuid_generate_v4()])) identifiant = db.Column(db.Unicode) nom_role = db.Column(db.Unicode) prenom_role = db.Column(db.Unicode) desc_role = db.Column(db.Unicode) pass_md5 = db.Column("pass", db.Unicode) pass_plus = db.Column(db.Unicode) email = db.Column(db.Unicode) id_organisme = db.Column( db.Integer, ForeignKey("utilisateurs.bib_organismes.id_organisme")) organisme_rel = relationship("Bib_Organismes") remarques = db.Column(db.Unicode) active = db.Column(db.Boolean) pass5 = db.Column("pass", db.Unicode) pass_plus = db.Column(db.Unicode) champs_addi = db.Column(JSONB) # Add synonym for column pass # Hack because pass is an python reserved word pass_md5 = synonym("pass5") def set_password(self, password, password_confirmation): (self.pass_plus, self.pass_md5) = check_and_encrypt_password( password, password_confirmation, current_app.config["PASS_METHOD"] == "md5" or current_app.config["FILL_MD5_PASS"], ) @classmethod def choixSelect(cls, id="id_role", nom="full_name", aucun=None): """ Methode qui retourne une tableau de tuples d'id de roles et de nom de roles ACTIF Avec pour paramètres un id de role et un nom de role Le paramètre aucun si il a une valeur permet de rajouter le tuple (-1,Aucun) au tableau """ # recupère tous les role actif roles = cls.get_all(as_model=True, params=[{ "col": "active", "filter": True }]) choices = [] for role in roles: role_as_dict = role.as_dict_full_name() choices.append((role_as_dict[id], role_as_dict[nom])) if aucun != None: choices.append((-1, "Aucun")) return choices @classmethod def choix_group(cls, id, nom, aucun=None): """ Methode qui retourne une tableau de tuples d'id de groupes et de nom de goupes Avec pour paramètres un id de groupe et un nom de groupe Le paramètre aucun si il a une valeur permet de rajouter le tuple (-1,Aucun) au tableau """ q = db.session.query(cls).order_by(cls.identifiant) q = q.filter(cls.groupe == True) data = [data.as_dict(True) for data in q.all()] choices = [] for d in data: choices.append((d[id], d[nom])) if aucun != None: choices.append((-1, "Aucun")) return choices @classmethod def get_user_groups(cls, id_role): """ Get all groups of a user Parameters: id_role (int): the user's id Return: Array<TRoles> """ cor_role_query = db.session.query(CorRoles.id_role_groupe).filter( CorRoles.id_role_utilisateur == id_role) return db.session.query(TRoles).filter( TRoles.id_role.in_(cor_role_query)).all() @classmethod def get_user_lists(cls, id_role): """ Get all lists of a user Parameters: id_role (int): the user's id Return: Array<TListes> """ # get ids_role list from user and user groups ids_role = [id_role] ids_group = [group.id_role for group in cls.get_user_groups(id_role)] for id in ids_group: ids_role.append(id) cor_role_list_query = db.session.query(CorRoleListe.id_liste).filter( CorRoleListe.id_role.in_(ids_role)) return (db.session.query(TListes).filter( TListes.id_liste.in_(cor_role_list_query)).all()) @classmethod def get_user_app_profils(cls, id_role, id_application=None): """ Get all listapp profils of a user Parameters: id_role (int): the user's id id_application optional (int): application id Return: Array<CorRoleAppProfil> """ # get ids_role list from user and user groups ids_role = [id_role] ids_group = [group.id_role for group in cls.get_user_groups(id_role)] for id in ids_group: ids_role.append(id) # get right rows in cor_role_app_profil q = (db.session.query(CorRoleAppProfil).distinct( CorRoleAppProfil.id_application).filter( CorRoleAppProfil.id_role.in_(ids_role))) if id_application: q = q.filter(CorRoleAppProfil.id_application == id_application) q = q.order_by(CorRoleAppProfil.id_application) rights = q.all() return rights def get_full_name(self): """ Methode qui concatène le nom et prénom du role retourne un nom complet """ if self.prenom_role == None: full_name = self.nom_role else: full_name = self.nom_role + " " + self.prenom_role return full_name def as_dict_full_name(self): """ Methode qui ajout le nom complet d'un role au dictionnaire qui le défini retourne un dictionnaire d'un utilisateur avec une nouvelle 'full_name' """ full_name = self.get_full_name() user_as_dict = self.as_dict() user_as_dict["full_name"] = full_name return user_as_dict @classmethod def test_group(cls, tab): """ Methode qui test si le tableau contient un élement groupe = False, Si c'est le cas alors on remplace le boolean par un string du même nom retourne un tableau avec le groupe sous forme de string """ table = [] for d in tab: if d["groupe"] is False: d["groupe"] = "False" else: d["groupe"] = "True" table.append(d) return table @classmethod def get_user_in_list(cls, id_liste): """ Methode qui retourne un dictionnaire des roles d'une liste Avec pour paramètre un id_liste """ q = db.session.query(cls).filter(cls.active == True) q = q.order_by(desc(cls.nom_role)) q = q.join(CorRoleListe) q = q.filter(id_liste == CorRoleListe.id_liste) data = [data.as_dict_full_name() for data in q.all()] return data @classmethod def get_user_out_list(cls, id_liste): """ Methode qui retourne un dictionnaire de roles n'appartenant pas à une liste Avec pour paramètre un id_liste """ q = db.session.query(cls) q = q.order_by(desc(cls.nom_role)) subquery = (db.session.query(CorRoleListe.id_role).filter( CorRoleListe.id_liste == id_liste).all()) q = q.filter(cls.id_role.notin_(subquery)) # TODO filtrer les roles actifs data = [data.as_dict_full_name() for data in q.all()] return data @classmethod def get_user_in_group(cls, id_groupe): """ Methode qui retourne un dictionnaire de role appartenant à un groupe Avec pour paramètres un id de role """ q = db.session.query(cls).filter(cls.active == True) q = q.order_by(desc(cls.groupe)) q = q.join(CorRoles) q = q.filter(id_groupe == CorRoles.id_role_groupe) data = [data.as_dict_full_name() for data in q.all()] return data @classmethod def get_user_out_group(cls, id_groupe): """ Methode qui retourne un dictionnaire de role n'appartenant pas à un groupe donné Avec pour paramètre un id de role """ q = db.session.query(cls).filter(cls.id_role != id_groupe) q = q.order_by(desc(cls.groupe)) subquery = db.session.query(CorRoles.id_role_utilisateur).filter( CorRoles.id_role_groupe == id_groupe) subquery2 = db.session.query(CorRoles.id_role_groupe).filter( CorRoles.id_role_utilisateur == id_groupe) # TODO a vérifier (problème de récursivité) q = q.filter(cls.id_role.notin_(subquery)) q = q.filter(cls.id_role.notin_(subquery2)) # TODO filtrer les roles actifs data = [data.as_dict_full_name() for data in q.all()] return data @classmethod def get_user_profil_in_app(cls, id_application): """ Methode qui retourne un dictionnaire de roles avec leur profil sur une application Avec pour paramètre un id d'application Ne retourne que les utilisateurs actifs """ # get the user data = (db.session.query(cls, TProfils).join( CorRoleAppProfil, cls.id_role == CorRoleAppProfil.id_role).join( TProfils, TProfils.id_profil == CorRoleAppProfil.id_profil).filter( cls.active == True).filter(CorRoleAppProfil.id_application == id_application).order_by( desc(cls.groupe)).all()) user_with_profil = [] for d in data: user = d[0].as_dict_full_name() user["id_profil"] = d[1].id_profil user["profil"] = d[1].nom_profil user_with_profil.append(user) return user_with_profil @classmethod def get_user_profil_out_app(cls, id_application): """ Methode qui retourne un dictionnaire de roles n'ayant pas de droits sur une application Avec pour paramètre un id d'application """ q = db.session.query(cls) q = q.order_by(desc(cls.groupe)) subquery = db.session.query(distinct(CorRoleAppProfil.id_role)).filter( CorRoleAppProfil.id_application == id_application) q = q.filter(cls.id_role.notin_(subquery)) return [data.as_dict_full_name() for data in q.all()] @classmethod def get_groups(cls): """ Methode qui retourne une liste des roles de type groupe """ q = db.session.query(cls).filter(TRoles.groupe == True) return q.all()
class TUsers(GenericRepository): """ Model de la table t_users """ __tablename__ = 't_users' __table_args__={'schema':'gas', 'extend_existing': True} id_user = db.Column(db.Unicode, server_default=FetchedValue(), primary_key = True) id_group =db.Column(db.Unicode, ForeignKey('gas.t_groups.id_group')) identifiant = db.Column(db.Unicode) last_name = db.Column(db.Unicode) first_name = db.Column(db.Unicode) user_comment = db.Column(db.Unicode) pass_plus = db.Column(db.Unicode) email = db.Column(db.Unicode) active = db.Column(db.Boolean) group_rel = relationship("TGroups") def fill_password(self, password, password_confirmation): (self.pass_plus) = self.set_password( password, password_confirmation) @classmethod def set_password(cls, password, password_confirmation): if not password: raise ValueError("Password is null") if password != password_confirmation: raise ValueError("Password doesn't match") try: pass_plus = generate_password_hash(password.encode('utf-8')).decode('utf-8') except Exception as e: raise e return (pass_plus) def get_full_name(self): """ Methode qui concatène le nom et prénom d'un utilisateur' retourne un nom complet """ if self.first_name == None: full_name = self.last_name elif self.last_name == None: full_name = self.first_name elif self.last_name is not None and self.first_name is not None: full_name = self.last_name + ' ' + self.first_name else : full_name = '' return full_name def as_dict_full_name(self): """ Methode qui ajout le nom complet d'un user au dictionnaire qui le défini retourne un dictionnaire d'un utilisateur avec une nouvelle 'full_name' """ full_name = self.get_full_name() user_as_dict = self.as_dict() user_as_dict['full_name'] = full_name return user_as_dict @classmethod def get_users_in_profil(cls, id_profil): """ Methode qui retourne un dictionnaire des users d'un profil Avec pour paramètre un id_profil """ q = db.session.query(cls) q = q.order_by(desc(cls.last_name)) q = q.join(CorUserProfil) q = q.filter(id_profil == CorUserProfil.id_profil ) return [data.as_dict_full_name() for data in q.all()] @classmethod def get_users_out_profil(cls,id_profil): """ Methode qui retourne un dictionnaire de users n'appartenant pas à un profil Avec pour paramètre un id_profil """ q = db.session.query(cls) q = q.order_by(desc(cls.last_name)) subquery = db.session.query(CorUserProfil.id_user) subquery = subquery.filter(CorUserProfil.id_profil == id_profil) q = q.filter(and_(cls.id_user.notin_(subquery), cls.active == True)) #TODO filtrer les users actifs return [data.as_dict_full_name() for data in q.all()]
class TRoles(GenericRepository): """ Model de la table t_roles """ __tablename__ = 't_roles' __table_args__ = {'schema': 'utilisateurs', 'extend_existing': True} id_role = db.Column(db.Integer, primary_key=True) groupe = db.Column(db.Boolean) uuid_role = db.Column(UUID(as_uuid=True), default=select([func.uuid_generate_v4()])) identifiant = db.Column(db.Unicode) nom_role = db.Column(db.Unicode) prenom_role = db.Column(db.Unicode) desc_role = db.Column(db.Unicode) pass_md5 = db.Column("pass", db.Unicode) pass_plus = db.Column(db.Unicode) email = db.Column(db.Unicode) id_organisme = db.Column( db.Unicode, ForeignKey('utilisateurs.bib_organismes.id_organisme')) organisme_rel = relationship("Bib_Organismes") remarques = db.Column(db.Unicode) pn = db.Column(db.Boolean) active = db.Column(db.Boolean) session_appli = (db.Unicode) def fill_password(self, password, password_confirmation): (self.pass_plus, self.pass_md5) = self.set_password(password, password_confirmation) @classmethod def set_password(cls, password, password_confirmation): if not password: raise ValueError("Password is null") if password != password_confirmation: raise ValueError("Passwords doesn't match") try: pass_plus = generate_password_hash( password.encode('utf-8')).decode('utf-8') if config.FILL_MD5_PASS: pass_md5 = hashlib.md5(password.encode('utf-8')).hexdigest() else: pass_md5 = '' except Exception as e: raise e return (pass_plus, pass_md5) @classmethod def choixSelect(cls, id='id_role', nom='full_name', aucun=None): """ Methode qui retourne une tableau de tuples d'id de roles et de nom de roles ACTIF Avec pour paramètres un id de role et un nom de role Le paramètre aucun si il a une valeur permet de rajouter le tuple (-1,Aucun) au tableau """ # recupère tous les role actif roles = cls.get_all(as_model=True, params=[{ 'col': 'active', 'filter': True }]) choices = [] for role in roles: role_as_dict = role.as_dict_full_name() choices.append((role_as_dict[id], role_as_dict[nom])) if aucun != None: choices.append((-1, 'Aucun')) return choices @classmethod def choix_group(cls, id, nom, aucun=None): """ Methode qui retourne une tableau de tuples d'id de groupes et de nom de goupes Avec pour paramètres un id de groupe et un nom de groupe Le paramètre aucun si il a une valeur permet de rajouter le tuple (-1,Aucun) au tableau """ q = db.session.query(cls) q = q.filter(cls.groupe == True) data = [data.as_dict(True) for data in q.all()] choices = [] for d in data: choices.append((d[id], d[nom])) if aucun != None: choices.append((-1, 'Aucun')) return choices @classmethod def get_user_groups(cls, id_role): """ Get all groups of a user Parameters: id_role (int): the user's id Return: Array<TRoles> """ cor_role_query = db.session.query(CorRoles.id_role_groupe).filter( CorRoles.id_role_utilisateur == id_role) return db.session.query(TRoles).filter( TRoles.id_role.in_(cor_role_query)).all() @classmethod def get_user_lists(cls, id_role): """ Get all lists of a user Parameters: id_role (int): the user's id Return: Array<TListes> """ # get ids_role list from user and user groups ids_role = [id_role] ids_group = [group.id_role for group in cls.get_user_groups(id_role)] for id in ids_group: ids_role.append(id) cor_role_list_query = db.session.query(CorRoleListe.id_liste).filter( CorRoleListe.id_role.in_(ids_role)) return db.session.query(TListes).filter( TListes.id_liste.in_(cor_role_list_query)).all() @classmethod def get_user_app_profils(cls, id_role): """ Get all listapp profils of a user Parameters: id_role (int): the user's id Return: Array<CorRoleAppProfil> """ # get ids_role list from user and user groups ids_role = [id_role] ids_group = [group.id_role for group in cls.get_user_groups(id_role)] for id in ids_group: ids_role.append(id) # get right rows in cor_role_app_profil rights = db.session.query(CorRoleAppProfil) \ .distinct(CorRoleAppProfil.id_application) \ .filter(CorRoleAppProfil.id_role.in_(ids_role)) \ .order_by(CorRoleAppProfil.id_application) \ .all() return rights def get_full_name(self): """ Methode qui concatène le nom et prénom du role retourne un nom complet """ if self.prenom_role == None: full_name = self.nom_role else: full_name = self.nom_role + ' ' + self.prenom_role return full_name def as_dict_full_name(self): """ Methode qui ajout le nom complet d'un role au dictionnaire qui le défini retourne un dictionnaire d'un utilisateur avec une nouvelle 'full_name' """ full_name = self.get_full_name() user_as_dict = self.as_dict() user_as_dict['full_name'] = full_name return user_as_dict @classmethod def test_group(cls, tab): """ Methode qui test si le tableau contient un élement groupe = False, Si c'est le cas alors on remplace le boolean par un string du même nom retourne un tableau avec le groupe sous forme de string """ table = [] for d in tab: if d['groupe'] == False: d['groupe'] = 'False' else: d['groupe'] = 'True' table.append(d) return table @classmethod def get_user_in_list(cls, id_liste): """ Methode qui retourne un dictionnaire des roles d'une liste Avec pour paramètre un id_liste """ q = db.session.query(cls).filter(cls.active == True) q = q.order_by(desc(cls.nom_role)) q = q.join(CorRoleListe) q = q.filter(id_liste == CorRoleListe.id_liste) data = [data.as_dict_full_name() for data in q.all()] return data @classmethod def get_user_out_list(cls, id_liste): """ Methode qui retourne un dictionnaire de roles n'appartenant pas à une liste Avec pour paramètre un id_liste """ q = db.session.query(cls) q = q.order_by(desc(cls.nom_role)) subquery = db.session.query(CorRoleListe.id_role).filter( CorRoleListe.id_liste == id_liste).all() q = q.filter(cls.id_role.notin_(subquery)) #TODO filtrer les roles actifs data = [data.as_dict_full_name() for data in q.all()] return data @classmethod def get_user_in_group(cls, id_groupe): """ Methode qui retourne un dictionnaire de role appartenant à un groupe Avec pour paramètres un id de role """ q = db.session.query(cls).filter(cls.active == True) q = q.order_by(desc(cls.groupe)) q = q.join(CorRoles) q = q.filter(id_groupe == CorRoles.id_role_groupe) data = [data.as_dict_full_name() for data in q.all()] return data @classmethod def get_user_out_group(cls, id_groupe): """ Methode qui retourne un dictionnaire de role n'appartenant pas à un groupe donné Avec pour paramètre un id de role """ q = db.session.query(cls).filter(cls.id_role != id_groupe) q = q.order_by(desc(cls.groupe)) subquery = db.session.query(CorRoles.id_role_utilisateur).filter( CorRoles.id_role_groupe == id_groupe) subquery2 = db.session.query(CorRoles.id_role_groupe).filter( CorRoles.id_role_utilisateur == id_groupe) #a vérifier (problème de récursivité) q = q.filter(cls.id_role.notin_(subquery)) q = q.filter(cls.id_role.notin_(subquery2)) #TODO filtrer les roles actifs data = [data.as_dict_full_name() for data in q.all()] return data @classmethod def get_user_profil_in_app(cls, id_application): """ Methode qui retourne un dictionnaire de roles avec leur profil sur une application Avec pour paramètre un id d'application Ne retourne que les utilisateurs actifs """ # get the user data = db.session.query(cls, TProfils).join( CorRoleAppProfil, cls.id_role == CorRoleAppProfil.id_role).join( TProfils, TProfils.id_profil == CorRoleAppProfil.id_profil).filter( cls.active == True).filter(CorRoleAppProfil.id_application == id_application).order_by( desc(cls.groupe)).all() user_with_profil = [] for d in data: user = d[0].as_dict_full_name() user['id_profil'] = d[1].id_profil user['profil'] = d[1].nom_profil user_with_profil.append(user) return user_with_profil @classmethod def get_user_profil_out_app(cls, id_application): """ Methode qui retourne un dictionnaire de roles n'ayant pas de droits sur une application Avec pour paramètre un id d'application """ q = db.session.query(cls) q = q.order_by(desc(cls.groupe)) subquery = db.session.query(distinct(CorRoleAppProfil.id_role)).filter( CorRoleAppProfil.id_application == id_application) q = q.filter(cls.id_role.notin_(subquery)) return [data.as_dict_full_name() for data in q.all()]
class Bib_Organismes(GenericRepository): """ Model de la table Bib_Organismes """ __tablename__ = "bib_organismes" __table_args__ = {"schema": "utilisateurs"} id_organisme = db.Column(db.Integer, primary_key=True) uuid_organisme = db.Column(UUID(as_uuid=True), default=select([func.uuid_generate_v4()])) nom_organisme = db.Column(db.Unicode) adresse_organisme = db.Column(db.Unicode) cp_organisme = db.Column(db.Unicode) ville_organisme = db.Column(db.Unicode) tel_organisme = db.Column(db.Unicode) fax_organisme = db.Column(db.Unicode) email_organisme = db.Column(db.Unicode) url_organisme = db.Column(db.Unicode) url_logo = db.Column(db.Unicode) id_parent = db.Column(db.Integer)
class CorRoleAppProfil(GenericRepository): """ Classe de correspondance entre la table t_roles, t_profils et t_applications """ __tablename__ = "cor_role_app_profil" __table_args__ = {"schema": "utilisateurs", "extend_existing": True} id_role = db.Column(db.Integer, ForeignKey("utilisateurs.t_roles.id_role"), primary_key=True) id_profil = db.Column(db.Integer, ForeignKey("utilisateurs.t_profils.id_profil"), primary_key=True) id_application = db.Column( db.Integer, ForeignKey("utilisateurs.t_applications.id_application"), primary_key=True, ) is_default_group_for_app = db.Column(db.Boolean, default=False) role_rel = relationship("TRoles") application_rel = relationship("TApplications") profil_rel = relationship("TProfils") # surchage de la méthode get_one # car il n'y a pas de clé primaire unique sur une cor @classmethod def get_one(cls, id_role, id_application): return (db.session.query(cls).filter_by( id_role=id_role, id_application=id_application).first()) @classmethod def get_default_for_app(cls, id_application): return (db.session.query(cls).filter_by( id_application=id_application).filter_by( is_default_group_for_app=True).first()) # surchage de la méthode delete car # il n'y a pas de clé primaire unique sur une cor # TODO cette méthode supprime tous les profils # pour une application et un role # faire une méthode qui supprime seulement # un enregistrement grace à une PK unique # necessite ne pas utiliser le template # table_database.html qui est trop génériqe @classmethod def delete(cls, id_role, id_application): cors = (db.session.query(cls).filter_by( id_role=id_role, id_application=id_application).all()) for cor in cors: db.session.delete(cor) try: db.session.commit() except Exception: db.session.rollback() raise @classmethod def add_cor(cls, id_app, tab_profil): dict_add = {} for d in tab_profil: dict_add = { "id_role": d["id_role"], "id_profil": d["id_profil"], "id_application": id_app, } cls.post(dict_add) @classmethod def del_cor(cls, id_app, tab_profil): for t in tab_profil: cls.query.filter(cls.id_role == t["id_role"]).filter( cls.id_profil == t["id_profil"]).filter( cls.id_application == id_app).delete() db.session.commit()
class VGroupOrdersDetail(GenericRepository): """ Model de la classe v_group_orders_detail """ __tablename__ = 'v_group_orders_detail' __table_args__ = {'schema':'gas', 'extend_existing': True} id_delivery = db.Column(db.Unicode, primary_key = True) id_group = db.Column(db.Integer, primary_key = True) id_product = db.Column(db.Integer, primary_key = True) delivery_name = db.Column(db.Unicode) group_name = db.Column(db.Unicode) product_name = db.Column(db.Unicode) product_unit = db.Column(db.Unicode) product_case_number = db.Column(db.Integer) selling_price = db.Column(db.Numeric) buying_price = db.Column(db.Numeric) weight = db.Column(db.Numeric)