from vigilo.models.session import DBSession

from vigilo.models.tables import Event, EventHistory, CorrEvent, SupItem, \

from vigilo.models.functions import sql_escape_like

from vigilo.models.tables.secondary_tables import EVENTSAGGREGATE_TABLE

        }, error_handler=process_form_errors)

    @expose('events_table.html')

    @require(Any(not_anonymous(), msg=l_("You need to be authenticated")))

            host=None, service=None, output=None, trouble_ticket=None,

            from_date=None, to_date=None, *argv, **krgv):

        """

            'tt': '',

            'from_date': '',

            'to_date': '',

        }

        # Application des filtres si nécessaire

            aggregates.add_filter(

        if host:

            search['host'] = host

                'tt': '',

                'from_date': '',

                'to_date': '',

            },

           refresh_times=config['vigiboard_refresh_times'],

        )

                'tt': '',

                'from_date': '',

                'to_date': '',

            },

           refresh_times=config['vigiboard_refresh_times'],

        )

                'tt': '',

                'from_date': '',

                'to_date': '',

            },

            refresh_times=config['vigiboard_refresh_times'],

        )

from vigilo.models.session import DBSession

from vigilo.models.tables import Event, CorrEvent, EventHistory, \

                        Host, LowLevelService, StateName

from vigiboard.widgets.edit_event import create_edit_event_form, EditEventForm

from vigiboard.widgets.search_form import create_search_form, SearchForm

from vigiboard.controllers.plugins import VigiboardRequestPlugin

        lang = lang.replace('_', '-')

        lang = lang.split('-')[0]

        self.lang = lang

        self.generaterq = False

        lls_query = DBSession.query(

            LowLevelService.idservice.label("idsupitem"),

            LowLevelService.servicename.label("servicename"),

            Host.name.label("hostname"),

        ).join(

        ).outerjoin(

            ),

        )

        host_query = DBSession.query(

            Host.idhost.label("idsupitem"),

            expr_null().label("servicename"),

            Host.name.label("hostname"),

        )

        # concerné par une alerte, avec prise en compte des droits d'accès.

        # On est obligés d'utiliser sqlalchemy.sql.expression.union

        # pour indiquer à SQLAlchemy de NE PAS regrouper les tables

from nose.tools import assert_equal

from vigilo.models.session import DBSession

                            Event, CorrEvent, ImpactedPath, ImpactedHLS

from vigiboard.tests import TestController

    """ Peuple la base de données. """

    # On ajoute un groupe d'hôtes

    DBSession.add(hostmanagers)

    DBSession.flush()

    # On lui octroie les permissions

    manage_perm = Permission.by_permission_name(u'manage')

    hostmanagers.permissions.append(manage_perm)

    DBSession.add(host)

    # On affecte cet hôte au groupe précédemment créé.

    DBSession.flush()

    # On ajoute un évènement causé par cet hôte.

            extra_environ={'REMOTE_USER': 'manager'})

        # On vérifie que le plugin retourne bien les 4 HLS impactés.

        assert_equal(resp.json, {"services": ['HLS12', 'HLS22']})

import transaction

from vigilo.models.session import DBSession

from vigiboard.tests import TestController

def populate_DB():

    """ Peuple la base de données. """

    # On ajoute les groupes et leurs dépendances

    DBSession.add(hosteditors)

    DBSession.add(hostmanagers)

    DBSession.flush()

    manage_perm = Permission.by_permission_name(u'manage')

    edit_perm = Permission.by_permission_name(u'edit')

    DBSession.add(editorhost)

    # Affectation des hôtes aux groupes.

    DBSession.flush()

    # Création des services techniques de test.

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

                            Host, Permission, StateName, \

                            LowLevelService, Event, CorrEvent

    """

    timestamp = datetime.now()

    DBSession.add(hostgroup)

    host = Host(

        name=u'bar',

        checkhostcmd=u'',

    DBSession.add(host)

    DBSession.flush()

    DBSession.flush()

    DBSession.add(servicegroup)

    service = LowLevelService(

        host=host,

        command=u'',

    DBSession.add(service)

    DBSession.flush()

    DBSession.flush()

    event = Event(

        """Dialogue des détails avec un LLS et les bons droits."""

        hostgroup, idcorrevent, idcause = insert_deps(True)

        manage = Permission.by_permission_name(u'manage')

        DBSession.flush()

        transaction.commit()

        """Dialogue des détails avec un hôte et les bons droits."""

        hostgroup, idcorrevent, idcause = insert_deps(False)

        manage = Permission.by_permission_name(u'manage')

        DBSession.flush()

        transaction.commit()

from vigilo.models.session import DBSession

from vigilo.models.tables import Event, EventHistory, CorrEvent, \

from vigiboard.tests import TestController

def populate_DB():

    """ Peuple la base de données. """

    # On ajoute un groupe d'hôtes et un groupe de services.

    DBSession.flush()

    # On ajoute la permission 'manage' à ces deux groupes.

    manage_perm = Permission.by_permission_name(u'manage')

    DBSession.flush()

    # On crée un hôte de test, et on l'ajoute au groupe d'hôtes.

        weight = 42,

    )

    DBSession.add(managerhost)

    DBSession.flush()

    # On crée un services de bas niveau, et on l'ajoute au groupe de services.

        weight = 42,

    )

    DBSession.add(managerservice)

    DBSession.flush()

    return (managerhost, managerservice)

from vigilo.models.session import DBSession

from vigilo.models.tables import Event, EventHistory, CorrEvent, \

from vigiboard.tests import TestController

def populate_DB(caused_by_service):

    """ Peuple la base de données. """

    # On ajoute un groupe d'hôtes et un groupe de services.

    DBSession.flush()

    # On ajoute la permission 'manage' à ces deux groupes.

    manage_perm = Permission.by_permission_name(u'manage')

    DBSession.flush()

    # On crée un hôte de test, et on l'ajoute au groupe d'hôtes.

        weight = 42,

    )

    DBSession.add(managerhost)

    DBSession.flush()

    # On crée un services de bas niveau, et on l'ajoute au groupe de services.

        weight = 42,

    )

    DBSession.add(managerservice)

    DBSession.flush()

    if caused_by_service:

def add_masked_event(idcorrevent):

    transaction.begin()

    nb_hosts = DBSession.query(Host).count()

    masked_host = Host(

        weight = 42,

    )

    DBSession.add(masked_host)

    DBSession.flush()

    event = Event(

from vigilo.models.session import DBSession

from vigilo.models.tables import Event, EventHistory, CorrEvent, \

from vigiboard.tests import TestController

def populate_DB():

    """ Peuple la base de données. """

    # On ajoute un groupe d'hôtes et un groupe de services.

    DBSession.flush()

    # On ajoute la permission 'manage' à ces deux groupes.

    manage_perm = Permission.by_permission_name(u'manage')

    DBSession.flush()

    # On crée un 2 hôtes, et on les ajoute au groupe d'hôtes.

        weight = 42,

    )

    DBSession.add(host1)

    host2 = Host(

        name = u'host2',      

        checkhostcmd = u'halt',

        weight = 42,

    )

    DBSession.add(host2)

    DBSession.flush()

    # On crée 2 services de bas niveau, et on les ajoute au groupe de services.

        weight = 42,

    )

    DBSession.add(service1)

    service2 = LowLevelService(

        host = host2,

        servicename = u'service2',

        weight = 42,

    )

    DBSession.add(service2)

    DBSession.flush()

    return ([host1, host2], [service1, service2])

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

def insert_deps():

    """Insère les dépendances nécessaires aux tests."""

    timestamp = datetime.now()

        name=u'foo',

    )

    DBSession.add(hostgroup)

    DBSession.flush()

    host = Host(

        name=u'bar',

        checkhostcmd=u'',

    DBSession.add(host)

    DBSession.flush()

    DBSession.flush()

    event = Event(

        # pour lesquel l'utilisateur a les permissions.

        hostgroup = insert_deps()

        manage = Permission.by_permission_name(u'manage')

        DBSession.flush()

        transaction.commit()

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

def insert_deps():

    """Insère les dépendances nécessaires aux tests."""

    timestamp = datetime.now()

        name=u'foo',

    )

    DBSession.add(hostgroup)

    DBSession.flush()

    host = Host(

        name=u'bar',

        checkhostcmd=u'',

    DBSession.add(host)

    DBSession.flush()

    DBSession.flush()

    event = Event(

        # ayant la permission 'manage' de voir cette alerte.

        hostgroup = insert_deps()

        manage = Permission.by_permission_name(u'manage')

        DBSession.flush()

        transaction.commit()

        # On envoie une requête avec recherche sur le groupe d'hôtes créé,

        # on s'attend à recevoir 1 résultat.

            extra_environ={'REMOTE_USER': 'manager'})

        # Il doit y avoir 1 seule ligne de résultats.

        """Teste la recherche par hostgroup sur un groupe inexistant."""

        # On envoie une requête avec recherche sur un groupe d'hôtes

        # qui n'existe pas, on s'attend à n'obtenir aucun résultat.

            extra_environ={'REMOTE_USER': 'manager'})

        # Il doit y avoir 1 seule ligne de résultats.

        # On envoie une requête avec recherche sur le groupe d'hôtes créé,

        # mais avec un utilisateur ne disposant pas des permissions adéquates.

        # On s'attend à n'obtenir aucun résultat.

            extra_environ={'REMOTE_USER': 'manager'})

        # Il doit y avoir 1 seule ligne de résultats.

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

def insert_deps():

    """Insère les dépendances nécessaires aux tests."""

    DBSession.add(host)

    DBSession.flush()

    DBSession.add(hostgroup)

    DBSession.flush()

    event = Event(

        supitem=host,

        timestamp=timestamp,

    # On attribut les permissions.

    manage = Permission.by_permission_name(u'manage')

    DBSession.flush()

    return timestamp

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

                                    Host, Permission, StateName, \

                                    LowLevelService, Event, CorrEvent

    """Insère les dépendances nécessaires aux tests."""

    timestamp = datetime.now()

    DBSession.add(hostgroup)

    host = Host(

        name=u'bar',

        checkhostcmd=u'',

    DBSession.add(host)

    DBSession.flush()

    DBSession.flush()

    DBSession.add(servicegroup)

    service = LowLevelService(

        host=host,

        command=u'',

    DBSession.add(service)

    DBSession.flush()

    DBSession.flush()

    event = Event(

class TestSearchFormService(TestController):

    """Teste la récupération d'événements selon le groupe de services."""

        """

        Teste la recherche par service avec des droits implicites

        (droits accordés car l'utilisateur a les droits sur l'hôte).

        print "Adding permission for 'manager' on host group '%s'" % \

            hostgroup.name

        manage = Permission.by_permission_name(u'manage')

        DBSession.flush()

        transaction.commit()

        print "There are %d columns in the result set" % len(cols)

        assert_true(len(cols) > 1)

        """

        Teste la recherche par service avec des droits explicites

        (droits accordés car l'utilisateur a explicitement les droits

        print "Adding permission for 'manager' on service group '%s'" % \

            servicegroup.name

        manage = Permission.by_permission_name(u'manage')

        DBSession.flush()

        transaction.commit()

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

def insert_deps():

    """Insère les dépendances nécessaires aux tests."""

    DBSession.add(host)

    DBSession.flush()

        name=u'foo',

    )

    DBSession.add(servicegroup)

    service = LowLevelService(

        host=host,

        command=u'',

    DBSession.add(service)

    DBSession.flush()

    event = Event(

        supitem=service,

        timestamp=timestamp,

        # ayant la permission 'manage' de voir cette alerte.

        servicegroup = insert_deps()

        manage = Permission.by_permission_name(u'manage')

        DBSession.flush()

        transaction.commit()

        # On envoie une requête avec recherche sur le groupe

        # de services créé, on s'attend à recevoir 1 résultat.

            extra_environ={'REMOTE_USER': 'manager'})

        # Il doit y avoir 1 seule ligne de résultats.

        """Teste la recherche par servicegroup sur un groupe inexistant."""

        # On envoie une requête avec recherche sur un groupe de services

        # qui n'existe pas, on s'attend à n'obtenir aucun résultat.

            extra_environ={'REMOTE_USER': 'manager'})

        # Il doit y avoir 1 seule ligne de résultats.

        # On envoie une requête avec recherche sur le groupe de services

        # services créé, mais avec un utilisateur ne disposant pas des

        # permissions adéquates. On s'attend à n'obtenir aucun résultat.

            extra_environ={'REMOTE_USER': 'manager'})

        # Il doit y avoir 1 seule ligne de résultats.

from nose.tools import assert_true

from vigilo.models.session import DBSession

from vigiboard.tests import TestController

class TestGroupPermissionsInheritance(TestController):

        """

        # Création de 2 groupes d'utilisateurs.

        DBSession.add(hosteditors)

        DBSession.add(hostmanagers)

        # L'attribution des permissions.

        manage_perm = Permission.by_permission_name(u'manage')

        edit_perm = Permission.by_permission_name(u'edit')

        DBSession.flush()

        transaction.commit()

        username = response.request.environ \

            ['repoze.who.identity'] \

            ['repoze.who.userid']

        # Permet de rafraîchir les instances.

        # On vérifie que la liste est correcte : le manager doit avoir accès

        # aux groupes 'hostmanagers' & 'hosteditors' (dont il hérite).

        username = response.request.environ \

            ['repoze.who.identity'] \

            ['repoze.who.userid']

        # L'utilisateur editor ne doit avoir accès qu'au groupe 'hosteditors'.

        assert_true(not(hostmanagers.idgroup in grp) and

    style = 'display: none'

    class fields(WidgetsList):

        host = TextField(label_text=l_('Host'))

        service = TextField(label_text=l_('Service'))

        output = TextField(label_text=l_('Output'))