/ - Diff - Vigiboard - UNITY 360

     # DB - sqlite fails, not postgresql ready, use mysql for now
     #sqlalchemy.url = sqlite:///%(here)s/devdata.db
     #sqlalchemy.url=mysql://vigiboard:penmdor@localhost/vigiboard
     #sqlalchemy.url=postgres://vigiboard@localhost/vigiboard
     sqlalchemy.url=mysql://root:tandreja@localhost:3306/vigiboard
     sqlalchemy.url=postgres://vigiboard:tandreja@localhost/vigiboard
     #sqlalchemy.url=mysql://root:tandreja@localhost:3306/vigiboard
     #echo shouldn't be used together with the logging module.
     sqlalchemy.echo = false
     sqlalchemy.echo_pool = false

     port = 5000
     [app:main]
     sqlalchemy.url=mysql://root:tandreja@localhost:3306/vigiboard_test
     sqlalchemy.url=postgres://vigiboard:tandreja@localhost/vigiboard_test
     #sqlalchemy.url=mysql://root:tandreja@localhost:3306/vigiboard_test
     #sqlalchemy.url = sqlite:///:memory:
     use = config:development.ini

         """
         # Requête permettant d'obtenir les groups directs de l'utilisateur
         groups = DBSession.query(Groups.name).join(
             ( GroupPermissions , Groups.name == GroupPermissions.groupname ),
             ( Permission ,
-...
             ).filter(Permission.permission_name.in_(
                 tg.request.environ.get('repoze.who.identity').get('permissions')
             ))
         lst_grp = Set([i.name for i in groups])
         lst_tmp = lst_grp
         # On recherche maintenant les groupes indirect
         while len(lst_tmp) > 0:
             groups = DBSession.query(Groups.name).filter(Groups.parent.in_(lst_tmp))
             tmp = Set([])

                     sql.func.count(Events.idevent)],
                 outerjoin = [(ServiceHautNiveau,
                     ServiceHautNiveau.servicename_dep == Events.servicename)],
                 groupby = [(Events.idevent)],
                 groupby = [(Events),(ServiceHautNiveau.servicename_dep)],
                 name = _(u'SHNs impacté'),
                 style = {'style':'text-align:center'}
                ))

                      ServiceGroups.groupname.in_(self.user_groups),
                      not_(and_(Events.active == False,
                          Events.status == 'AAClosed')),
                      Events.timestamp_active != None,
                      not_(Events.timestamp_active.like('0000-00-00 00:00:00'))]
             self.orderby = [asc(Events.status),
                      Events.timestamp_active != None#,
                      #not_(Events.timestamp_active.like('0000-00-00 00:00:00'))
+                     ]
             self.orderby = [desc(Events.status),
                                     desc(Events.active),
                                     desc(Events.severity),
                                     asc(Events.hostname),

                 output = '', event_timestamp = datetime.now(),
                 last_check = datetime.now(), recover_output = '',
                 timestamp_active = datetime.now(),
                 timestamp_cleared="0000-00-00 00:00:00", trouble_ticket = None,
                 timestamp_cleared=None, trouble_ticket = None,
                 occurence = 1):
             self.hostname = hostname

     from vigiboard.model import metadata
     from vigiboard.config.vigiboard_config import vigiboard_config
     from vigiboard.model.vigiboard_bdd.graph import Graph
     from vigiboard.model.vigiboard_bdd.graphgroups import GraphGroups
     # Generation par SQLAutoCode
     graphtogroups =  Table(

         Column(u'servicename',
             String(length=100, convert_unicode=True, assert_unicode=None),
             ForeignKey(vigiboard_config['vigiboard_bdd.basename'] + \
                     u'servicehautniveau.servicename'),
                     u'service.name'),
             primary_key=True, nullable=False),
         Column(u'function',
             String(length=50, convert_unicode=True, assert_unicode=None),

     """
     from nose.tools import assert_true
     from vigiboard.model import DBSession, Groups, Permission, GroupPermissions
     from vigiboard.model import DBSession, Groups, Permission, GroupPermissions, Events
     from vigiboard.tests import TestController
     from vigiboard.controllers.vigiboard_ctl import get_user_groups
     from vigiboard.tests import setup_db, teardown_db
     import tg
     import transaction
     #Create an empty database before we start our tests for this module
     def setup():
         """Function called by nose on module load"""
         setup_db()
     #Teardown that database
     def teardown():
         """Function called by nose after all tests in this module ran"""
         teardown_db()
     class TestUserUtils(TestController):
         """Test de la classe User Utils"""
         def tearDown(self):
             DBSession.rollback()
             teardown_db()
             transaction.begin()
         def test_get_user_groups(self):
             """
-...
             # On commence par peupler la base
             DBSession.add(Groups(name="hostmanagers"))
             DBSession.add(Groups(name="hosteditors", parent="hostmanagers"))
             DBSession.add(Groups(name = "hostmanagers"))
             DBSession.add(Groups(name = "hosteditors", parent="hostmanagers"))
             DBSession.query(Permission).filter(
                 Permission.permission_name == u'manage')[0].permission_id
             idmanagers = DBSession.query(Permission).filter(
                     Permission.permission_name == 'manage')[0].permission_id
                     Permission.permission_name == u'manage')[0].permission_id
             ideditors = DBSession.query(Permission
                     ).filter(Permission.permission_name == 'edit')[0].permission_id
                     ).filter(Permission.permission_name == u'edit')[0].permission_id
             DBSession.add(GroupPermissions(groupname = "hostmanagers",
                     idpermission = idmanagers))
             DBSession.add(GroupPermissions(groupname = "hosteditors",
                     idpermission = ideditors))
             # On commit car app.get fait un rollback ou équivalent
             transaction.commit()
             transaction.commit()
             # On obtient les variables de sessions comme si on était loggué
             # en tant que manager
             environ = {'REMOTE_USER': 'manager'}
             response = self.app.get('/', extra_environ=environ)
             tg.request = response.request
             # On récupère la liste des groups auquel on appartient
             grp = get_user_groups()
             # On vérifi que la liste est correcte (vérifi la gestion des
             # groupes sous forme d'arbre)
             assert_true( 'hostmanagers' in grp and 'hosteditors' in grp)
             assert_true( 'hostmanagers' in grp and 'hosteditors' in grp ,
                 msg = "il est dans %s" % grp)
             # On recommence pour l'utilisateur editor
             environ = {'REMOTE_USER': 'editor'}
             response = self.app.get('/', extra_environ=environ)
             tg.request = response.request
             grp = get_user_groups()
             assert_true( not('hostmanagers' in grp) and 'hosteditors' in grp)
             assert_true( not('hostmanagers' in grp) and 'hosteditors' in grp,
                 msg = "il est dans %s" % grp)

     import tg
     import transaction
     #Create an empty database before we start our tests for this module
     def setup():
         """Function called by nose on module load"""
         setup_db()
     #Teardown that database
     def teardown():
         """Function called by nose after all tests in this module ran"""
         teardown_db()
     class TestVigiboardRequest(TestController):
         """Test de la classe Vigiboard Request"""
         def tearDown(self):
             DBSession.rollback()
             transaction.begin()
             teardown_db()
         def test_creation_requete(self):
             """
             Génération d'une requête avec application d'un plugin et
             des permissions
             """
             # On commence par peupler la base de donnée actuellement vide
             # les groups et leurs dépendances
-...
             DBSession.add(ServiceGroups(servicename = "monserviceuser",
                 groupname = "hosteditors"))
             DBSession.flush()
             # On commit tout car app.get fait un rollback ou équivalent
             transaction.commit()
             # On indique qui on est et on requête l'index pour obtenir
             # toutes les variables de sessions
             environ = {'REMOTE_USER': 'editor'}

ID	9c0dbb6a047a9654ae4b7861a725086a786597ce
Parent	35cea70e
Child	8cb5da40

Project

General

Profile

Revision 9c0dbb6a