/ - Diff - Vigigraph - UNITY 360

Revision b430ccc5

ID	b430ccc508ccc259db8d1b30f85b473ff4da4ab5
Parent	8f6567c2
Child	7e6517fe

Added by Francois POIROTTE over 13 years ago

Fusion du travail fait dans la branche 'nested_sets' vers le trunk.

git-svn-id: https://vigilo-dev.si.c-s.fr/svn@6116 b22e2e97-25c9-44ff-b637-2e5ceca36478

     from vigilo.models.tables import SupItemGroup
     from vigilo.models.tables import PerfDataSource
     from vigilo.models.tables import Graph, GraphGroup
     from vigilo.models.tables.grouphierarchy import GroupHierarchy
     from vigilo.models.tables import Change
     from vigilo.models.tables.secondary_tables import SUPITEM_GROUP_TABLE
-...
             Un critere peut correspondre a un intitule complet hote ou graphe
             ou a un extrait.
             @param kwargs : arguments nommes
             @type kwargs : dict
                              ( arguments nommes -> host et graphe )
             @return: couples hote-graphe
             @rtype: document json (sous forme de dict)
             @rtype: dict
             """
             user = get_current_user()
             items = []
-...
             if user is None:
                 return dict(items=[])
             # On a un nom d'indicateur, mais pas de nom d'hôte,
             # on considère que l'utilisateur veut tous les indicateurs
             # On a un nom de graphe, mais pas de nom d'hôte,
             # on considère que l'utilisateur veut tous les graphes
             # correspondant au motif, quel que soit l'hôte.
             if search_form_graph:
                 if not search_form_host:
-...
             if not is_manager:
                 supitemgroups = [sig[0] for sig in user.supitemgroups() if sig[1]]
                 # pylint: disable-msg=E1103
                 items = items.join(
                     (GroupHierarchy, GroupHierarchy.idchild == \
                         SUPITEM_GROUP_TABLE.c.idgroup)
                 ).filter(GroupHierarchy.idparent.in_(supitemgroups))
                 items = items.filter(
                     SUPITEM_GROUP_TABLE.c.idgroup.in_(supitemgroups))
             items = items.limit(100).all() # pylint: disable-msg=E1103
             if not search_form_graph:
-...
             is_manager = in_group('managers').is_met(request.environ)
             if not is_manager:
                 supitemgroups = [sig[0] for sig in user.supitemgroups() if sig[1]]
                 graphs = graphs.join(
                         (GroupHierarchy, GroupHierarchy.idchild == \
                             SUPITEM_GROUP_TABLE.c.idgroup)
                     ).filter(GroupHierarchy.idparent.in_(supitemgroups))
                 graphs = graphs.filter(
                     SUPITEM_GROUP_TABLE.c.idgroup.in_(supitemgroups))
             graphs = graphs.all()
             return dict(host=host, start=start, duration=duration,
-...
                 ).join(
                     (SUPITEM_GROUP_TABLE, SUPITEM_GROUP_TABLE.c.idsupitem == \
                         Host.idhost),
                 ).filter(Host.name.like(query + '%')
                 ).filter(Host.name.like(query + u'%')
                 ).order_by(
                     Host.name.asc(),
+                )
-...
             is_manager = in_group('managers').is_met(request.environ)
             if not is_manager:
                 supitemgroups = [sig[0] for sig in user.supitemgroups() if sig[1]]
                 hosts = hosts.join(
                         (GroupHierarchy, GroupHierarchy.idchild == \
                             SUPITEM_GROUP_TABLE.c.idgroup)
                     ).filter(GroupHierarchy.idparent.in_(supitemgroups))
                 hosts = hosts.filter(
                     SUPITEM_GROUP_TABLE.c.idgroup.in_(supitemgroups))
             return dict(hosts=hosts)
-...
             # Si l'identifiant du groupe parent n'est pas
             # spécifié, on retourne la liste des groupes racines,
             # fournie par la méthode get_root_hosts_groups.
             # fournie par la méthode get_root_host_groups.
             if parent_id is None:
                 return self.get_root_host_groups()
             # TODO: Utiliser un schéma de validation
             parent_id = int(parent_id)
             # On vérifie si le groupe parent fait partie des
             # groupes auxquel l'utilisateur a accès, et on
             # retourne une liste vide dans le cas contraire
             parent = DBSession.query(SupItemGroup).get(parent_id)
             if not parent:
                 return dict(groups = [], leaves = [])
             # On récupère la liste des groupes qui ont pour parent
             # le groupe dont l'identifiant est passé en paramètre
             # et auquel l'utilisateur a accès.
             db_groups = list(parent.children) # copie
             user = get_current_user()
             is_manager = in_group('managers').is_met(request.environ)
             user_groups = {}
             if not is_manager:
                 direct_access = False
                 user = get_current_user()
                 user_groups = dict(user.supitemgroups())
                 # On regarde d'abord si le groupe fait partie de ceux
                 # auquels l'utilisateur a explicitement accès, ou s'il
                 # est un parent des groupes auxquels l'utilisateur a accès
                 if parent_id in user_groups.keys():
                     direct_access = user_groups[parent_id]
                 # Dans le cas contraire, on vérifie si le groupe est un
                 # sous-groupe des groupes auxquels l'utilisateur a accès
                 else:
                     id_list = [ug for ug in user_groups.keys() if user_groups[ug]]
                     child_groups = DBSession.query(SupItemGroup.idgroup
                         ).distinct(
                         ).join(
                             (GroupHierarchy,
                                 GroupHierarchy.idchild == SupItemGroup.idgroup),
                         ).filter(GroupHierarchy.idparent.in_(id_list)
                         ).filter(GroupHierarchy.hops > 0
                         ).all()
                     for ucg in child_groups:
                         if ucg.idgroup == parent_id:
                             direct_access = True
                             break
                     # Sinon, l'utilisateur n'a pas accès à ce groupe
                     else:
                         return dict(groups = [], leaves = [])
             # On récupère la liste des groupes dont
             # l'identifiant du parent est passé en paramètre
             db_groups = DBSession.query(
                 SupItemGroup
             ).join(
                 (GroupHierarchy, GroupHierarchy.idchild == \
                     SupItemGroup.idgroup),
             ).filter(GroupHierarchy.hops == 1
             ).filter(GroupHierarchy.idparent == parent_id
             ).order_by(SupItemGroup.name.asc())
             if not is_manager and not direct_access:
                 id_list = [ug for ug in user_groups.keys()]
                 db_groups = db_groups.filter(
                     SupItemGroup.idgroup.in_(id_list))
                 copy = list(db_groups)
                 for db_group in copy:
                     if not user_groups.get(db_group.idgroup, False):
                         db_groups.remove(db_group)
             groups = []
             for group in db_groups.all():
             for group in db_groups:
                 groups.append({
                     'id'   : group.idgroup,
                     'name' : group.name,
-...
             # On récupère la liste des hôtes appartenant au
             # groupe dont l'identifiant est passé en paramètre
             hosts = []
             if is_manager or direct_access:
             if is_manager or user_groups.get(parent_id, False):
                 db_hosts = DBSession.query(
                     Host.idhost,
                     Host.name,
                 ).join(
                     (SUPITEM_GROUP_TABLE,
                         SUPITEM_GROUP_TABLE.c.idsupitem == Host.idhost
                         ),
                     SUPITEM_GROUP_TABLE,
                 ).filter(SUPITEM_GROUP_TABLE.c.idgroup == parent_id
                 ).order_by(Host.name.asc())
                 hosts = []
-...
             # Si l'identifiant de l'hôte n'est pas spécifié, on
             # retourne un dictionnaire contenant deux listes vides
             if host_id is None:
                 return dict(groups = [], graphs=[])
                 return dict(groups = [], leaves=[])
             # On vérifie les permissions sur l'hôte
             # TODO: Utiliser un schéma de validation
             host_id = int(host_id)
             host = DBSession.query(Host
                 ).filter(Host.idhost == host_id
                 ).first()
             host = DBSession.query(Host).get(host_id)
             if host is None:
                 return dict(groups = [], graphs=[])
                 return dict(groups = [], leaves=[])
             user = get_current_user()
             if not host.is_allowed_for(user):
                 return dict(groups = [], graphs=[])
                 return dict(groups = [], leaves=[])
             # On récupère la liste des groupes de graphes associés à l'hôte
             host_graph_groups = DBSession.query(
-...
                         GRAPH_PERFDATASOURCE_TABLE.c.idgraph == Graph.idgraph),
                 (PerfDataSource, PerfDataSource.idperfdatasource == \
                         GRAPH_PERFDATASOURCE_TABLE.c.idperfdatasource),
                 (SUPITEM_GROUP_TABLE, \
                     SUPITEM_GROUP_TABLE.c.idsupitem == PerfDataSource.idhost),
             ).filter(PerfDataSource.idhost == host_id
             ).order_by(GraphGroup.name.asc()
             ).all()
             ).order_by(GraphGroup.name.asc())
             host_graph_groups = host_graph_groups.all()
             # Si l'identifiant du groupe parent n'est pas spécifié,
             # on récupère la liste des groupes de graphes racines.
             if parent_id is None:
                 graph_groups = GraphGroup.get_top_groups()
                 graph_groups = GraphGroup.get_top_groups()[0].children
             # Sinon on récupère la liste des graphes dont le
             # groupe passé en paramètre est le parent direct
             # groupe passé en paramètre est le parent direct.
             else:
                 # TODO: Utiliser un schéma de validation
                 parent_id = int(parent_id)
                 graph_groups = DBSession.query(
                     GraphGroup
                 ).join(
                     (GroupHierarchy, GroupHierarchy.idchild == \
                         GraphGroup.idgroup),
                 ).filter(GroupHierarchy.hops == 1
                 ).filter(GroupHierarchy.idparent == parent_id
                 ).order_by(GraphGroup.name.asc()
                 ).all()
                 parent = DBSession.query(GraphGroup).get(parent_id)
                 graph_groups = parent.children
             # On réalise l'intersection des deux listes
             groups = []
-...
             @rtype : C{dict} of C{list} of C{dict} of C{mixed}
             """
             # On récupère tous les groupes qui ont un parent.
             children = DBSession.query(
                 SupItemGroup,
             ).distinct(
             ).join(
                 (GroupHierarchy, GroupHierarchy.idchild == SupItemGroup.idgroup)
             ).filter(GroupHierarchy.hops > 0)
             # Ensuite on les exclut de la liste des groupes,
             # pour ne garder que ceux qui sont au sommet de
             # l'arbre et qui constituent nos "root groups".
             root_groups = DBSession.query(
                 SupItemGroup,
             ).except_(children
             ).order_by(SupItemGroup.name)
             root_groups = list(SupItemGroup.get_top_groups()[0].children)
             # On filtre ces groupes racines afin de ne
             # retourner que ceux auquels l'utilisateur a accès
             user = get_current_user()
             is_manager = in_group('managers').is_met(request.environ)
             if not is_manager:
                 user_groups = [ug[0] for ug in user.supitemgroups()]
                 root_groups = root_groups.filter(
                     SupItemGroup.idgroup.in_(user_groups))
                 user_groups = [sig[0] for sig in user.supitemgroups()]
                 copy = list(root_groups)
                 for root_group in copy:
                     if root_group.idgroup not in user_groups:
                         root_groups.remove(root_group)
             groups = []
             for group in root_groups.all():
             for group in root_groups:
                 groups.append({
                     'id'   : group.idgroup,
                     'name' : group.name,

     from vigigraph.tests import TestController
     from vigilo.models.session import DBSession
     from vigilo.models.tables import Host, Graph, GraphGroup
     from vigilo.models.demo.functions import \
         add_graph, add_graphgroup, add_graph2group, \
         add_perfdatasource, add_perfdatasource2graph, \
         add_vigiloserver, add_application
     from vigilo.models.demo.functions import *
     from vigigraph.tests.functional.test_host_selection_form import populateDB
-...
             # de graphes retournée est vide
             self.assertEqual(
                 json, {
                     'graphs': [],
                     'leaves': [],
                     'groups': []
+                }
+            )
-...
             # de graphes retournée est vide
             self.assertEqual(
                 json, {
                     'graphs': [],
                     'leaves': [],
                     'groups': []
+                }
+            )
-...
             # de graphes retournée est vide
             self.assertEqual(
                 json, {
                     'graphs': [],
                     'leaves': [],
                     'groups': []
+                }
+            )
-...
             # de graphes retournée est vide
             self.assertEqual(
                 json, {
                     'graphs': [],
                     'leaves': [],
                     'groups': []
+                }
+            )
-...
             # de graphes retournée est vide
             self.assertEqual(
                 json, {
                     'graphs': [],
                     'leaves': [],
                     'groups': []
+                }
+            )
-...
             # de graphes retournée est vide
             self.assertEqual(
                 json, {
                     'graphs': [],
                     'leaves': [],
                     'groups': []
+                }
+            )
-...
             # de graphes retournée est vide
             self.assertEqual(
                 json, {
                     'graphs': [],
                     'leaves': [],
                     'groups': []
+                }
+            )
-...
             # graphes retournée est vide
             self.assertEqual(
                 json, {
                     'graphs': [],
                     'leaves': [],
                     'groups': []
+                }
+            )

     from vigigraph.tests import TestController
     from vigilo.models.session import DBSession
     from vigilo.models.tables import Host, SupItemGroup, Permission
     from vigilo.models.demo.functions import add_supitemgroup, \
         add_host, add_host2group, add_usergroup, add_user, \
         add_supitemgrouppermission, add_usergroup_permission
     from vigilo.models.demo.functions import *
     def populateDB():
-...
         """
         # Ajout d'un groupe d'hôtes principal
         mainhostgroup = add_supitemgroup(u'mhg', None)
         mainhostgroup = add_supitemgroup(u'mhg')
         # Ajout d'un premier groupe d'hôtes de second niveau
         hostgroup1 = add_supitemgroup(u'hg1', mainhostgroup)
-...
             self.assertEqual(
                 json, {
                     'leaves': [
                         {'id': host1.idhost, 'name': host1.name}
                         {'id': host1.idhost, 'name': host1.name},
                     ],
                     'groups': [
                         {'id': hostgroup1.idgroup, 'name': hostgroup1.name},
-...
             # Récupération des groupes d'hôtes
             # accessibles à l'utilisateur 'poweruser'
             response = self.app.post(
                 '/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
                 }, extra_environ={'REMOTE_USER': 'poweruser'})
                 '/rpc/hosttree?parent_id=%d' % mainhostgroup.idgroup, {},
                 extra_environ={'REMOTE_USER': 'poweruser'})
             json = response.json
             # On s'assure que la liste de groupes d'hôtes retournée
-...
             self.assertEqual(
                 json, {
                     'leaves': [
                         {'id': host1.idhost, 'name': host1.name}
                         {'id': host1.idhost, 'name': host1.name},
                     ],
                     'groups': [
                         {'id': hostgroup1.idgroup, 'name': hostgroup1.name},
-...
             # Récupération des hôtes du groupe 'hg2'
             # accessibles à l'utilisateur 'user'
             response = self.app.post(
                 '/rpc/hosttree?parent_id=%s' % (hostgroup2.idgroup, ), {
                 }, extra_environ={'REMOTE_USER': 'user'})
                 '/rpc/hosttree?parent_id=%s' % hostgroup2.idgroup, {},
                 extra_environ={'REMOTE_USER': 'user'})
             json = response.json
             # On s'assure que la liste d'hôtes retournée est vide
-...
             # Récupération des hôtes du groupe 'mhg'
             # accessibles à l'utilisateur 'visitor'
             response = self.app.post(
                 '/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
                 }, extra_environ={'REMOTE_USER': 'visitor'})
                 '/rpc/hosttree?parent_id=%s' % mainhostgroup.idgroup, {},
                 extra_environ={'REMOTE_USER': 'visitor'})
             json = response.json
             # On s'assure que la liste d'hôtes retournée est vide

             """
             Résultats de la recherche sur un hôte avec les bons droits
             """
             # Récupération du groupe d'hôtes 'mhg' dans la base de données
             mainhostgroup = DBSession.query(SupItemGroup).filter(
                 SupItemGroup.name == u'mhg').first()
-...
             # On s'assure que les deux listes retournées contiennent
             # respectivement le nom de l'hôte et son identifiant
             print repr(DBSession.query(SupItemGroup.name, SupItemGroup.left, SupItemGroup.right, SupItemGroup.depth).all())
             self.assertEqual(
                 json, {
                     'labels': [[host2.name, None]],

Also available in: Unified diff

Project

General

Profile

Revision b430ccc5