from vigilo.turbogears import VigiloAppConfig

import vigiboard

# W0611: Unused import: imports nécessaires pour le fonctionnement

rememberer_name = auth_tkt

post_login_url = /post_login

post_logout_url = /post_logout

[general]

request_classifier = vigilo.turbogears.repoze.classifier:vigilo_classifier

[mdproviders]

plugins =

    vigilo.turbogears.repoze.plugins.mduser:plugin

[nosetests]

cover-package=vigiboard

tests=vigiboard/tests

    url='http://www.projet-vigilo.org/',

    install_requires=[

        "vigilo-turbogears",

    ],

    packages=find_packages(exclude=['ez_setup']),

        'paste.app_factory': [

            'main = vigiboard.config.middleware:make_app',

        ],

        'vigilo.models': [

            'populate_db = vigiboard.websetup:populate_db',

        ],

import logging

from tg import expose, response

from datetime import datetime

from vigilo.turbogears.controllers import BaseController

class FeedsController(BaseController):

    # pylint: disable-msg=R0201,W0613

    def atom(self, token, username):

        """

        """

"""

from datetime import datetime, timedelta

import tw.forms as twf

from vigilo.models import tables

import urllib

from tg import config, url, request

import tw.forms as twf

from sqlalchemy.sql.expression import null as expr_null, union_all

from sqlalchemy import func

from vigilo.turbogears.helpers import get_current_user

from vigilo.models.session import DBSession

            items = DBSession.query(

                    Map.idmap,

                    Map.title,

                ).distinct(

                ).join(

                    (MAP_GROUP_TABLE, MAP_GROUP_TABLE.c.idmap == Map.idmap),

                    (MapNodeHost, MapNodeHost.idmap == Map.idmap),

                ).order_by(func.lower(Map.title).asc()

                ).filter(MapNodeHost.idhost == event.idhost)

            if not is_manager:

                mapgroups = get_current_user().mapgroups(only_direct=True)

                # pylint: disable-msg=E1103

            # La valeur -1 supprime la limite.

            if max_maps > 0:

            return

        states = []

            try:

                states.append(int(value))

            except (ValueError, TypeError):

                try:

                    states.append(StateName.statename_to_value(value))

                except:

                    pass

        if states:

à l'événement corrélé.

"""

import tw.forms as twf

from vigiboard.controllers.plugins import VigiboardRequestPlugin, INNER

from vigilo.models.session import DBSession

"""

import tw.forms as twf

from vigiboard.controllers.plugins import VigiboardRequestPlugin, INNER

from vigilo.models.session import DBSession

            twf.TextField(

                'hls',

                label_text=l_('High-Level Service'),

            )

        ]

sur lequel porte l'événement corrélé.

"""

import tw.forms as twf

from vigilo.models.functions import sql_escape_like

from vigiboard.controllers.plugins import VigiboardRequestPlugin, ITEMS

sur lequel porte l'événement corrélé.

"""

import tw.forms as twf

from sqlalchemy.sql.expression import union_all

from sqlalchemy.orm import aliased

de la commande de test exécutée par Nagios sur cet hôte/service.

"""

import tw.forms as twf

from vigilo.models.tables import Event

from vigilo.models.functions import sql_escape_like

            twf.TextField(

                'output',

                label_text=l_('Output'),

            )

        ]

ITIL de l'événement corrélé.

"""

import tw.forms as twf

from vigilo.models.tables import CorrEvent, StateName

from vigiboard.controllers.plugins import VigiboardRequestPlugin, ITEMS

à l'origine de l'événement corrélé.

"""

import tw.forms as twf

from vigilo.models.functions import sql_escape_like

from vigiboard.controllers.plugins import VigiboardRequestPlugin, ITEMS

            twf.TextField(

                'service',

                label_text=l_('Service'),

            )

        ]

import urllib

import tg

import tw.forms as twf

from vigilo.models.tables import CorrEvent, Event, StateName

from vigilo.models.session import DBSession

import urllib

import tg

import tw.forms as twf

from vigilo.models.tables import CorrEvent, StateName

from vigilo.models.functions import sql_escape_like

            twf.TextField(

                'trouble_ticket',

                label_text=l_('Trouble Ticket'),

            ),

            twf.SingleSelectField(

                'ack',

"""VigiBoard Controller"""

from datetime import datetime

from time import mktime

from pkg_resources import resource_filename, working_set

from tg.exceptions import HTTPNotFound

from tg import expose, validate, require, flash, url, \

    tmpl_context, request, response, config, session, redirect

from sqlalchemy import asc

from sqlalchemy.sql import func

from sqlalchemy.orm import aliased

from sqlalchemy.sql.expression import or_

from vigilo.models.session import DBSession

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

    Le controller général de vigiboard

    """

    _tickets = None

    error = ErrorController()

    autocomplete = AutoCompleteController()

        )

        # Paramètres de tri

        order = validators.OneOf(['asc', 'desc'], if_missing='asc')

        chained_validators = [create_search_form.validator]

    @validate(

        validators=IndexSchema(),

        error_handler = process_form_errors)

    @require(access_restriction)

        """

        Page d'accueil de Vigiboard. Elle affiche, suivant la page demandée

        (page 1 par defaut), la liste des événements, rangés par ordre de prise

            Event.idsupitem == aggregates.items.c.idsupitem))

        aggregates.add_order_by(asc(aggregates.items.c.hostname))

        # On ne garde que les champs effectivement renseignés.

        for column in search.copy():

            if not search[column]:

        )

    def i18n(self):

        try:

        except KeyError:

        lang = get_lang()

        # Localise le fichier *.mo actuellement chargé

        # et génère le chemin jusqu'au *.js correspondant.

            languages=lang)

        js = filename[:-3] + '.js'

        error_handler = process_form_errors)

    @expose('raw_events_table.html')

    @require(access_restriction)

        """

        Affichage de la liste des événements bruts masqués d'un événement

        corrélé (événements agrégés dans l'événement corrélé).

        error_handler = process_form_errors)

    @expose('history_table.html')

    @require(access_restriction)

        """

        Affichage de l'historique d'un événement brut.

        Pour accéder à cette page, l'utilisateur doit être authentifié.

        error_handler = process_form_errors)

    @expose('events_table.html')

    @require(access_restriction)

        """

        Affichage de l'historique de l'ensemble des événements corrélés

        jamais ouverts sur l'hôte / service demandé.

from tg import expose, validate, require, flash, tmpl_context, \

    request, config, redirect

                                    has_permission, not_anonymous

from formencode.compound import All as All_

from formencode.foreach import ForEach

from sqlalchemy.exc import InvalidRequestError, IntegrityError

from sqlalchemy.sql.expression import asc, desc

from vigilo.turbogears.controllers import BaseController

from vigilo.models.session import DBSession

from vigilo.models.tables import SupItem, Host, LowLevelService, \

                            HighLevelService, StateName, Silence, UserSupItem

from vigilo.models.tables.secondary_tables import SILENCE_STATE_TABLE

from vigilo.models.utils import group_concat

from vigiboard.lib import error_handler

from time import mktime

from tg import config, tmpl_context, request, url

from paste.deploy.converters import aslist

from sqlalchemy import not_, and_, asc, desc

from formencode.api import FancyValidator, Invalid

from datetime import datetime

def get_calendar_lang():

    import tg

    # TODO: Utiliser le champ "language" du modèle pour cet utilisateur ?

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

from vigilo.models.demo import functions

class TestDetailsPluginMapsHostLimited(TestController):

    """

    """

    application_under_test = 'limited_maps'

    # Seules les 2 premières cartes doivent figurer.

    # de détecter qu'il y avait plus de cartes que la limite.

    manager = [[1, 'M1'], [2, 'M2']]

    # L'utilisateur avec droits étendus voit

    # L'utilisateur avec droits restreints ne voit

    # qu'une seule carte : "M2".

    restricted = [[2, 'M2']]

    def shortDescription(self, *args, **kwargs):

        """Description courte du test en cours d'exécution."""

        # On fait manuellement ce que l'initialisation de VigiMap ferait

        # (car on est dans les tests de VigiBoard, pas ceux de VigiMap).

        root = functions.add_mapgroup(u'Root')

        print "Creation hote, service et cartes"

        host = functions.add_host(u'localhost éçà')

        print "Insertion evenement correle"

        timestamp = datetime.now()

        supitem = DBSession.query(self.supitem_class).one()

            event = functions.add_event(supitem, u'DOWN', u'', timestamp)

        else: # Sinon, il s'agit d'un LowLevelService.

            event = functions.add_event(supitem, u'CRITICAL', u'', timestamp)

        functions.add_correvent([event], timestamp=timestamp)

        DBSession.flush()

        transaction.commit()

        return correvent.idcorrevent

    def test_maps_links_anonymous(self):

    Idem que la classe mère mais teste un événement corrélé

    portant sur un service de l'hôte plutôt que sur l'hôte lui-même.

    """

    def shortDescription(self, *args, **kwargs):

        """Description courte du test en cours d'exécution."""

    Idem que la classe mère mais teste un événement corrélé

    portant sur un service de l'hôte plutôt que sur l'hôte lui-même.

    """

    def shortDescription(self, *args, **kwargs):

        """Description courte du test en cours d'exécution."""

    Idem que la classe mère mais teste un événement corrélé

    portant sur un service de l'hôte plutôt que sur l'hôte lui-même.

    """

    def shortDescription(self, *args, **kwargs):

        """Description courte du test en cours d'exécution."""

        """

        Tableau des événements corrélés pour un service de bas niveau.

        """

        # L'utilisateur n'est pas authentifié.

        response = self.app.get(url, status=401)

        """

        Tableau des événements corrélés pour un hôte.

        """

        # L'utilisateur n'est pas authentifié.

        response = self.app.get(url, status=401)

        from_date = from_date.strftime("%Y-%m-%d %I:%M:%S %p")

        to_date = datetime.now().strftime("%Y-%m-%d %I:%M:%S %p")

    def test_future_end_date(self):

        """Contrôle des dates. Vérifie que date de fin < date courante."""

        to_date = datetime.now() + timedelta(seconds=60)

        to_date = to_date.strftime("%Y-%m-%d %I:%M:%S %p")

    def test_dates_inconsistency(self):

        """Contrôle des dates. Vérifie date de début <= date de fin."""

        from_date = from_date.strftime("%Y-%m-%d %I:%M:%S %p")

        to_date = timestamp.strftime("%Y-%m-%d %I:%M:%S %p")

"""Le formulaire d'édition d'un événement."""

from tw.api import WidgetsList

from tw.forms import TableForm, SingleSelectField, TextField, \

                        HiddenField, Label

"""Le formulaire de recherche/filtrage."""

import tw.forms as twf

import tg